?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
TESTING -- override pthreads to fix gstreamer v5
[wine/multimedia.git] / dlls / ws2_32 / tests / sock.c
blobaeb7a62257cc7c86d8789f2806e19adc437257f1
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 int (WINAPI *pInetPtonA)(INT,LPCSTR,LPVOID);
72 static int (WINAPI *pInetPtonW)(INT,LPWSTR,LPVOID);
73 static int (WINAPI *pWSALookupServiceBeginW)(LPWSAQUERYSETW,DWORD,LPHANDLE);
74 static int (WINAPI *pWSALookupServiceEnd)(HANDLE);
75 static int (WINAPI *pWSALookupServiceNextW)(HANDLE,DWORD,LPDWORD,LPWSAQUERYSETW);
76 static int (WINAPI *pWSAEnumNameSpaceProvidersA)(LPDWORD,LPWSANAMESPACE_INFOA);
77 static int (WINAPI *pWSAEnumNameSpaceProvidersW)(LPDWORD,LPWSANAMESPACE_INFOW);
78 static int (WINAPI *pWSAPoll)(WSAPOLLFD *,ULONG,INT);
79
80 /* Function pointers from iphlpapi */
81 static DWORD (WINAPI *pGetAdaptersInfo)(PIP_ADAPTER_INFO,PULONG);
82 static DWORD (WINAPI *pGetIpForwardTable)(PMIB_IPFORWARDTABLE,PULONG,BOOL);
83
84 /**************** Structs and typedefs ***************/
85
86 typedef struct thread_info
87 {
88 HANDLE thread;
89 DWORD id;
90 } thread_info;
91
92 /* Information in the server about open client connections */
93 typedef struct sock_info
94 {
95 SOCKET s;
96 struct sockaddr_in addr;
97 struct sockaddr_in peer;
98 char *buf;
99 int n_recvd;
100 int n_sent;
101 } sock_info;
102
103 /* Test parameters for both server & client */
104 typedef struct test_params
105 {
106 int sock_type;
107 int sock_prot;
108 const char *inet_addr;
109 short inet_port;
110 int chunk_size;
111 int n_chunks;
112 int n_clients;
113 } test_params;
114
115 /* server-specific test parameters */
116 typedef struct server_params
117 {
118 test_params *general;
119 DWORD sock_flags;
120 int buflen;
121 } server_params;
122
123 /* client-specific test parameters */
124 typedef struct client_params
125 {
126 test_params *general;
127 DWORD sock_flags;
128 int buflen;
129 } client_params;
130
131 /* This type combines all information for setting up a test scenario */
132 typedef struct test_setup
133 {
134 test_params general;
135 LPVOID srv;
136 server_params srv_params;
137 LPVOID clt;
138 client_params clt_params;
139 } test_setup;
140
141 /* Thread local storage for server */
142 typedef struct server_memory
143 {
144 SOCKET s;
145 struct sockaddr_in addr;
146 sock_info sock[MAX_CLIENTS];
147 } server_memory;
148
149 /* Thread local storage for client */
150 typedef struct client_memory
151 {
152 SOCKET s;
153 struct sockaddr_in addr;
154 char *send_buf;
155 char *recv_buf;
156 } client_memory;
157
158 /* SelectReadThread thread parameters */
159 typedef struct select_thread_params
160 {
161 SOCKET s;
162 BOOL ReadKilled;
163 } select_thread_params;
164
165 /* Tests used in both getaddrinfo and GetAddrInfoW */
166 static const struct addr_hint_tests
167 {
168 int family, socktype, protocol;
169 DWORD error;
170 } hinttests[] = {
171 {AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0 },
172 {AF_UNSPEC, SOCK_STREAM, IPPROTO_UDP, 0 },
173 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_TCP, 0 },
174 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, 0 },
175 {AF_INET, SOCK_STREAM, IPPROTO_TCP, 0 },
176 {AF_INET, SOCK_STREAM, IPPROTO_UDP, 0 },
177 {AF_INET, SOCK_DGRAM, IPPROTO_TCP, 0 },
178 {AF_INET, SOCK_DGRAM, IPPROTO_UDP, 0 },
179 {AF_UNSPEC, 0, IPPROTO_TCP, 0 },
180 {AF_UNSPEC, 0, IPPROTO_UDP, 0 },
181 {AF_UNSPEC, SOCK_STREAM, 0, 0 },
182 {AF_UNSPEC, SOCK_DGRAM, 0, 0 },
183 {AF_INET, 0, IPPROTO_TCP, 0 },
184 {AF_INET, 0, IPPROTO_UDP, 0 },
185 {AF_INET, SOCK_STREAM, 0, 0 },
186 {AF_INET, SOCK_DGRAM, 0, 0 },
187 {AF_UNSPEC, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT },
188 {AF_UNSPEC, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT },
189 {AF_INET, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT },
190 {AF_INET, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT },
191 {AF_UNSPEC, SOCK_STREAM, 999, 0 },
192 {AF_UNSPEC, SOCK_STREAM, 999, 0 },
193 {AF_INET, SOCK_DGRAM, 999, 0 },
194 {AF_INET, SOCK_DGRAM, 999, 0 },
195 };
196
197 /**************** Static variables ***************/
198
199 static DWORD tls; /* Thread local storage index */
200 static HANDLE thread[1+MAX_CLIENTS];
201 static DWORD thread_id[1+MAX_CLIENTS];
202 static HANDLE server_ready;
203 static HANDLE client_ready[MAX_CLIENTS];
204 static int client_id;
205
206 /**************** General utility functions ***************/
207
208 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len);
209 static SOCKET setup_connector_socket(struct sockaddr_in *addr, int len, BOOL nonblock);
210
211 static int tcp_socketpair(SOCKET *src, SOCKET *dst)
212 {
213 SOCKET server = INVALID_SOCKET;
214 struct sockaddr_in addr;
215 int len;
216 int ret;
217
218 *src = INVALID_SOCKET;
219 *dst = INVALID_SOCKET;
220
221 *src = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
222 if (*src == INVALID_SOCKET)
223 goto end;
224
225 server = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
226 if (server == INVALID_SOCKET)
227 goto end;
228
229 memset(&addr, 0, sizeof(addr));
230 addr.sin_family = AF_INET;
231 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
232 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
233 if (ret != 0)
234 goto end;
235
236 len = sizeof(addr);
237 ret = getsockname(server, (struct sockaddr*)&addr, &len);
238 if (ret != 0)
239 goto end;
240
241 ret = listen(server, 1);
242 if (ret != 0)
243 goto end;
244
245 ret = connect(*src, (struct sockaddr*)&addr, sizeof(addr));
246 if (ret != 0)
247 goto end;
248
249 len = sizeof(addr);
250 *dst = accept(server, (struct sockaddr*)&addr, &len);
251
252 end:
253 if (server != INVALID_SOCKET)
254 closesocket(server);
255 if (*src != INVALID_SOCKET && *dst != INVALID_SOCKET)
256 return 0;
257 closesocket(*src);
258 closesocket(*dst);
259 return -1;
260 }
261
262 static void set_so_opentype ( BOOL overlapped )
263 {
264 int optval = !overlapped, newval, len = sizeof (int);
265
266 ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
267 (LPVOID) &optval, sizeof (optval) ) == 0,
268 "setting SO_OPENTYPE failed\n" );
269 ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
270 (LPVOID) &newval, &len ) == 0,
271 "getting SO_OPENTYPE failed\n" );
272 ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
273 }
274
275 static int set_blocking ( SOCKET s, BOOL blocking )
276 {
277 u_long val = !blocking;
278 return ioctlsocket ( s, FIONBIO, &val );
279 }
280
281 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
282 {
283 char c, *p;
284 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
285 memset ( p, c, chunk_size );
286 }
287
288 static int test_buffer ( char *buf, int chunk_size, int n_chunks )
289 {
290 char c, *p;
291 int i;
292 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
293 {
294 for ( i = 0; i < chunk_size; i++ )
295 if ( p[i] != c ) return i;
296 }
297 return -1;
298 }
299
300 /*
301 * This routine is called when a client / server does not expect any more data,
302 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
303 */
304 static void read_zero_bytes ( SOCKET s )
305 {
306 char buf[256];
307 int tmp, n = 0;
308 while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
309 n += tmp;
310 ok ( n <= 0, "garbage data received: %d bytes\n", n );
311 }
312
313 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int flags, int sendlen )
314 {
315 char* last = buf + buflen, *p;
316 int n = 1;
317 for ( p = buf; n > 0 && p < last; )
318 {
319 n = send ( s, p, min ( sendlen, last - p ), flags );
320 if (n > 0) p += n;
321 }
322 wsa_ok ( n, 0 <=, "do_synchronous_send (%x): error %d\n" );
323 return p - buf;
324 }
325
326 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int flags, int recvlen )
327 {
328 char* last = buf + buflen, *p;
329 int n = 1;
330 for ( p = buf; n > 0 && p < last; )
331 {
332 n = recv ( s, p, min ( recvlen, last - p ), flags );
333 if (n > 0) p += n;
334 }
335 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
336 return p - buf;
337 }
338
339 static int do_synchronous_recvfrom ( SOCKET s, char *buf, int buflen, int flags, struct sockaddr *from, int *fromlen, int recvlen )
340 {
341 char* last = buf + buflen, *p;
342 int n = 1;
343 for ( p = buf; n > 0 && p < last; )
344 {
345 n = recvfrom ( s, p, min ( recvlen, last - p ), flags, from, fromlen );
346 if (n > 0) p += n;
347 }
348 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
349 return p - buf;
350 }
351
352 /*
353 * Call this routine right after thread startup.
354 * SO_OPENTYPE must by 0, regardless what the server did.
355 */
356 static void check_so_opentype (void)
357 {
358 int tmp = 1, len;
359 len = sizeof (tmp);
360 getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
361 ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
362 }
363
364 static void compare_addrinfo (ADDRINFO *a, ADDRINFO *b)
365 {
366 for (; a && b ; a = a->ai_next, b = b->ai_next)
367 {
368 ok(a->ai_flags == b->ai_flags,
369 "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags);
370 ok(a->ai_family == b->ai_family,
371 "Wrong family %d != %d\n", a->ai_family, b->ai_family);
372 ok(a->ai_socktype == b->ai_socktype,
373 "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype);
374 ok(a->ai_protocol == b->ai_protocol,
375 "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol);
376 ok(a->ai_addrlen == b->ai_addrlen,
377 "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen);
378 ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)),
379 "Wrong address data\n");
380 if (a->ai_canonname && b->ai_canonname)
381 {
382 ok(!strcmp(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n",
383 a->ai_canonname, b->ai_canonname);
384 }
385 else
386 ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n",
387 a->ai_canonname, b->ai_canonname);
388 }
389 ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b);
390 }
391
392 static void compare_addrinfow (ADDRINFOW *a, ADDRINFOW *b)
393 {
394 for (; a && b ; a = a->ai_next, b = b->ai_next)
395 {
396 ok(a->ai_flags == b->ai_flags,
397 "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags);
398 ok(a->ai_family == b->ai_family,
399 "Wrong family %d != %d\n", a->ai_family, b->ai_family);
400 ok(a->ai_socktype == b->ai_socktype,
401 "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype);
402 ok(a->ai_protocol == b->ai_protocol,
403 "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol);
404 ok(a->ai_addrlen == b->ai_addrlen,
405 "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen);
406 ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)),
407 "Wrong address data\n");
408 if (a->ai_canonname && b->ai_canonname)
409 {
410 ok(!lstrcmpW(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n",
411 wine_dbgstr_w(a->ai_canonname), wine_dbgstr_w(b->ai_canonname));
412 }
413 else
414 ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n",
415 a->ai_canonname, b->ai_canonname);
416 }
417 ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b);
418 }
419
420 /**************** Server utility functions ***************/
421
422 /*
423 * Even if we have closed our server socket cleanly,
424 * the OS may mark the address "in use" for some time -
425 * this happens with native Linux apps, too.
426 */
427 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
428 {
429 int err, wsaerr = 0, n_try = BIND_TRIES;
430
431 while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
432 ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
433 n_try-- >= 0)
434 {
435 trace ( "address in use, waiting ...\n" );
436 Sleep ( 1000 * BIND_SLEEP );
437 }
438 ok ( err == 0, "failed to bind: %d\n", wsaerr );
439 }
440
441 static void server_start ( server_params *par )
442 {
443 int i;
444 test_params *gen = par->general;
445 server_memory *mem = LocalAlloc ( LPTR, sizeof ( server_memory ) );
446
447 TlsSetValue ( tls, mem );
448 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
449 NULL, 0, par->sock_flags );
450 ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
451
452 mem->addr.sin_family = AF_INET;
453 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
454 mem->addr.sin_port = htons ( gen->inet_port );
455
456 for (i = 0; i < MAX_CLIENTS; i++)
457 {
458 mem->sock[i].s = INVALID_SOCKET;
459 mem->sock[i].buf = LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
460 mem->sock[i].n_recvd = 0;
461 mem->sock[i].n_sent = 0;
462 }
463
464 if ( gen->sock_type == SOCK_STREAM )
465 do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
466 }
467
468 static void server_stop (void)
469 {
470 int i;
471 server_memory *mem = TlsGetValue ( tls );
472
473 for (i = 0; i < MAX_CLIENTS; i++ )
474 {
475 LocalFree ( mem->sock[i].buf );
476 if ( mem->sock[i].s != INVALID_SOCKET )
477 closesocket ( mem->sock[i].s );
478 }
479 ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
480 LocalFree ( mem );
481 ExitThread ( GetCurrentThreadId () );
482 }
483
484 /**************** Client utilitiy functions ***************/
485
486 static void client_start ( client_params *par )
487 {
488 test_params *gen = par->general;
489 client_memory *mem = LocalAlloc (LPTR, sizeof (client_memory));
490
491 TlsSetValue ( tls, mem );
492
493 WaitForSingleObject ( server_ready, INFINITE );
494
495 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
496 NULL, 0, par->sock_flags );
497
498 mem->addr.sin_family = AF_INET;
499 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
500 mem->addr.sin_port = htons ( gen->inet_port );
501
502 ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
503
504 mem->send_buf = LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
505 mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
506 fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
507
508 SetEvent ( client_ready[client_id] );
509 /* Wait for the other clients to come up */
510 WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
511 }
512
513 static void client_stop (void)
514 {
515 client_memory *mem = TlsGetValue ( tls );
516 wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%x): %d\n" );
517 LocalFree ( mem->send_buf );
518 LocalFree ( mem );
519 ExitThread(0);
520 }
521
522 /**************** Servers ***************/
523
524 /*
525 * simple_server: A very basic server doing synchronous IO.
526 */
527 static VOID WINAPI simple_server ( server_params *par )
528 {
529 test_params *gen = par->general;
530 server_memory *mem;
531 int pos, n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
532 id = GetCurrentThreadId();
533
534 trace ( "simple_server (%x) starting\n", id );
535
536 set_so_opentype ( FALSE ); /* non-overlapped */
537 server_start ( par );
538 mem = TlsGetValue ( tls );
539
540 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
541 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%x): listen failed: %d\n");
542
543 trace ( "simple_server (%x) ready\n", id );
544 SetEvent ( server_ready ); /* notify clients */
545
546 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
547 {
548 trace ( "simple_server (%x): waiting for client\n", id );
549
550 /* accept a single connection */
551 tmp = sizeof ( mem->sock[0].peer );
552 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
553 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%x): accept failed: %d\n" );
554
555 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
556 "simple_server (%x): strange peer address\n", id );
557
558 /* Receive data & check it */
559 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
560 ok ( n_recvd == n_expected,
561 "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
562 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
563 ok ( pos == -1, "simple_server (%x): test pattern error: %d\n", id, pos);
564
565 /* Echo data back */
566 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
567 ok ( n_sent == n_expected,
568 "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
569
570 /* cleanup */
571 read_zero_bytes ( mem->sock[0].s );
572 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "simple_server (%x): closesocket error: %d\n" );
573 mem->sock[0].s = INVALID_SOCKET;
574 }
575
576 trace ( "simple_server (%x) exiting\n", id );
577 server_stop ();
578 }
579
580 /*
581 * oob_server: A very basic server receiving out-of-band data.
582 */
583 static VOID WINAPI oob_server ( server_params *par )
584 {
585 test_params *gen = par->general;
586 server_memory *mem;
587 u_long atmark = 0;
588 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, tmp,
589 id = GetCurrentThreadId();
590
591 trace ( "oob_server (%x) starting\n", id );
592
593 set_so_opentype ( FALSE ); /* non-overlapped */
594 server_start ( par );
595 mem = TlsGetValue ( tls );
596
597 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
598 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "oob_server (%x): listen failed: %d\n");
599
600 trace ( "oob_server (%x) ready\n", id );
601 SetEvent ( server_ready ); /* notify clients */
602
603 trace ( "oob_server (%x): waiting for client\n", id );
604
605 /* accept a single connection */
606 tmp = sizeof ( mem->sock[0].peer );
607 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
608 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "oob_server (%x): accept failed: %d\n" );
609
610 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
611 "oob_server (%x): strange peer address\n", id );
612
613 /* check initial atmark state */
614 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
615 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
616
617 /* Receive normal data */
618 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
619 ok ( n_recvd == n_expected,
620 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
621 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
622 ok ( pos == -1, "oob_server (%x): test pattern error: %d\n", id, pos);
623
624 /* check atmark state */
625 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
626 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
627
628 /* Echo data back */
629 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
630 ok ( n_sent == n_expected,
631 "oob_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
632
633 /* Receive a part of the out-of-band data and check atmark state */
634 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, 8, 0, par->buflen );
635 ok ( n_recvd == 8,
636 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, 8 );
637 n_expected -= 8;
638
639 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
640 todo_wine ok ( atmark == 0, "oob_server (%x): not at the OOB mark: %i\n", id, atmark );
641
642 /* Receive the rest of the out-of-band data and check atmark state */
643 do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
644
645 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
646 todo_wine ok ( atmark == 0, "oob_server (%x): not at the OOB mark: %i\n", id, atmark );
647
648 /* cleanup */
649 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "oob_server (%x): closesocket error: %d\n" );
650 mem->sock[0].s = INVALID_SOCKET;
651
652 trace ( "oob_server (%x) exiting\n", id );
653 server_stop ();
654 }
655
656 /*
657 * select_server: A non-blocking server.
658 */
659 static VOID WINAPI select_server ( server_params *par )
660 {
661 test_params *gen = par->general;
662 server_memory *mem;
663 int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
664 id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
665 n_set, delta, n_ready;
666 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
667 fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
668
669 trace ( "select_server (%x) starting\n", id );
670
671 set_so_opentype ( FALSE ); /* non-overlapped */
672 server_start ( par );
673 mem = TlsGetValue ( tls );
674
675 wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
676 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%x): listen failed: %d\n");
677
678 trace ( "select_server (%x) ready\n", id );
679 SetEvent ( server_ready ); /* notify clients */
680
681 FD_ZERO ( &fds_openrecv );
682 FD_ZERO ( &fds_recv );
683 FD_ZERO ( &fds_send );
684 FD_ZERO ( &fds_opensend );
685
686 FD_SET ( mem->s, &fds_openrecv );
687
688 while(1)
689 {
690 fds_recv = fds_openrecv;
691 fds_send = fds_opensend;
692
693 n_set = 0;
694
695 wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
696 "select_server (%x): select() failed: %d\n" );
697
698 /* check for incoming requests */
699 if ( FD_ISSET ( mem->s, &fds_recv ) ) {
700 n_set += 1;
701
702 trace ( "select_server (%x): accepting client connection\n", id );
703
704 /* accept a single connection */
705 tmp = sizeof ( mem->sock[n_connections].peer );
706 mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
707 wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%x): accept() failed: %d\n" );
708
709 ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
710 "select_server (%x): strange peer address\n", id );
711
712 /* add to list of open connections */
713 FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
714 FD_SET ( mem->sock[n_connections].s, &fds_opensend );
715
716 n_connections++;
717 }
718
719 /* handle open requests */
720
721 for ( i = 0; i < n_connections; i++ )
722 {
723 if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
724 n_set += 1;
725
726 if ( mem->sock[i].n_recvd < n_expected ) {
727 /* Receive data & check it */
728 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 );
729 ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
730 mem->sock[i].n_recvd += n_recvd;
731
732 if ( mem->sock[i].n_recvd == n_expected ) {
733 int pos = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
734 ok ( pos == -1, "select_server (%x): test pattern error: %d\n", id, pos );
735 FD_CLR ( mem->sock[i].s, &fds_openrecv );
736 }
737
738 ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
739 }
740 }
741
742 /* only echo back what we've received */
743 delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
744
745 if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
746 n_set += 1;
747
748 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
749 /* Echo data back */
750 n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
751 ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
752 mem->sock[i].n_sent += n_sent;
753
754 if ( mem->sock[i].n_sent == n_expected ) {
755 FD_CLR ( mem->sock[i].s, &fds_opensend );
756 }
757
758 ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
759 }
760 }
761 }
762
763 /* check that select returned the correct number of ready sockets */
764 ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
765
766 /* check if all clients are done */
767 if ( ( fds_opensend.fd_count == 0 )
768 && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
769 && ( n_connections == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
770 break;
771 }
772 }
773
774 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
775 {
776 /* cleanup */
777 read_zero_bytes ( mem->sock[i].s );
778 wsa_ok ( closesocket ( mem->sock[i].s ), 0 ==, "select_server (%x): closesocket error: %d\n" );
779 mem->sock[i].s = INVALID_SOCKET;
780 }
781
782 trace ( "select_server (%x) exiting\n", id );
783 server_stop ();
784 }
785
786 /**************** Clients ***************/
787
788 /*
789 * simple_client: A very basic client doing synchronous IO.
790 */
791 static VOID WINAPI simple_client ( client_params *par )
792 {
793 test_params *gen = par->general;
794 client_memory *mem;
795 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
796
797 id = GetCurrentThreadId();
798 trace ( "simple_client (%x): starting\n", id );
799 /* wait here because we want to call set_so_opentype before creating a socket */
800 WaitForSingleObject ( server_ready, INFINITE );
801 trace ( "simple_client (%x): server ready\n", id );
802
803 check_so_opentype ();
804 set_so_opentype ( FALSE ); /* non-overlapped */
805 client_start ( par );
806 mem = TlsGetValue ( tls );
807
808 /* Connect */
809 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
810 0 ==, "simple_client (%x): connect error: %d\n" );
811 ok ( set_blocking ( mem->s, TRUE ) == 0,
812 "simple_client (%x): failed to set blocking mode\n", id );
813 trace ( "simple_client (%x) connected\n", id );
814
815 /* send data to server */
816 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
817 ok ( n_sent == n_expected,
818 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
819
820 /* shutdown send direction */
821 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
822
823 /* Receive data echoed back & check it */
824 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
825 ok ( n_recvd == n_expected,
826 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
827
828 /* check data */
829 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
830 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
831
832 /* cleanup */
833 read_zero_bytes ( mem->s );
834 trace ( "simple_client (%x) exiting\n", id );
835 client_stop ();
836 }
837
838 /*
839 * oob_client: A very basic client sending out-of-band data.
840 */
841 static VOID WINAPI oob_client ( client_params *par )
842 {
843 test_params *gen = par->general;
844 client_memory *mem;
845 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
846
847 id = GetCurrentThreadId();
848 trace ( "oob_client (%x): starting\n", id );
849 /* wait here because we want to call set_so_opentype before creating a socket */
850 WaitForSingleObject ( server_ready, INFINITE );
851 trace ( "oob_client (%x): server ready\n", id );
852
853 check_so_opentype ();
854 set_so_opentype ( FALSE ); /* non-overlapped */
855 client_start ( par );
856 mem = TlsGetValue ( tls );
857
858 /* Connect */
859 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
860 0 ==, "oob_client (%x): connect error: %d\n" );
861 ok ( set_blocking ( mem->s, TRUE ) == 0,
862 "oob_client (%x): failed to set blocking mode\n", id );
863 trace ( "oob_client (%x) connected\n", id );
864
865 /* send data to server */
866 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
867 ok ( n_sent == n_expected,
868 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
869
870 /* Receive data echoed back & check it */
871 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
872 ok ( n_recvd == n_expected,
873 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
874 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
875 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
876
877 /* send out-of-band data to server */
878 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, MSG_OOB, par->buflen );
879 ok ( n_sent == n_expected,
880 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
881
882 /* shutdown send direction */
883 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
884
885 /* cleanup */
886 read_zero_bytes ( mem->s );
887 trace ( "oob_client (%x) exiting\n", id );
888 client_stop ();
889 }
890
891 /*
892 * simple_mixed_client: mixing send and recvfrom
893 */
894 static VOID WINAPI simple_mixed_client ( client_params *par )
895 {
896 test_params *gen = par->general;
897 client_memory *mem;
898 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
899 int fromLen = sizeof(mem->addr);
900 struct sockaddr test;
901
902 id = GetCurrentThreadId();
903 trace ( "simple_client (%x): starting\n", id );
904 /* wait here because we want to call set_so_opentype before creating a socket */
905 WaitForSingleObject ( server_ready, INFINITE );
906 trace ( "simple_client (%x): server ready\n", id );
907
908 check_so_opentype ();
909 set_so_opentype ( FALSE ); /* non-overlapped */
910 client_start ( par );
911 mem = TlsGetValue ( tls );
912
913 /* Connect */
914 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
915 0 ==, "simple_client (%x): connect error: %d\n" );
916 ok ( set_blocking ( mem->s, TRUE ) == 0,
917 "simple_client (%x): failed to set blocking mode\n", id );
918 trace ( "simple_client (%x) connected\n", id );
919
920 /* send data to server */
921 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
922 ok ( n_sent == n_expected,
923 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
924
925 /* shutdown send direction */
926 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
927
928 /* this shouldn't change, since lpFrom, is not updated on
929 connection oriented sockets - exposed by bug 11640
930 */
931 ((struct sockaddr_in*)&test)->sin_addr.s_addr = inet_addr("0.0.0.0");
932
933 /* Receive data echoed back & check it */
934 n_recvd = do_synchronous_recvfrom ( mem->s,
935 mem->recv_buf,
936 n_expected,
937 0,
938 (struct sockaddr *)&test,
939 &fromLen,
940 par->buflen );
941 ok ( n_recvd == n_expected,
942 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
943
944 /* check that lpFrom was not updated */
945 ok(0 ==
946 strcmp(
947 inet_ntoa(((struct sockaddr_in*)&test)->sin_addr),
948 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
949
950 /* check data */
951 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
952 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
953
954 /* cleanup */
955 read_zero_bytes ( mem->s );
956 trace ( "simple_client (%x) exiting\n", id );
957 client_stop ();
958 }
959
960 /*
961 * event_client: An event-driven client
962 */
963 static void WINAPI event_client ( client_params *par )
964 {
965 test_params *gen = par->general;
966 client_memory *mem;
967 int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
968 tmp, err, n;
969 HANDLE event;
970 WSANETWORKEVENTS wsa_events;
971 char *send_last, *recv_last, *send_p, *recv_p;
972 LONG mask = FD_READ | FD_WRITE | FD_CLOSE;
973
974 trace ( "event_client (%x): starting\n", id );
975 client_start ( par );
976 trace ( "event_client (%x): server ready\n", id );
977
978 mem = TlsGetValue ( tls );
979
980 /* Prepare event notification for connect, makes socket nonblocking */
981 event = WSACreateEvent ();
982 WSAEventSelect ( mem->s, event, FD_CONNECT );
983 tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
984 if ( tmp != 0 ) {
985 err = WSAGetLastError ();
986 ok ( err == WSAEWOULDBLOCK, "event_client (%x): connect error: %d\n", id, err );
987 tmp = WaitForSingleObject ( event, INFINITE );
988 ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
989 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
990 ok ( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
991 err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
992 ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
993 if ( err ) goto out;
994 }
995
996 trace ( "event_client (%x) connected\n", id );
997
998 WSAEventSelect ( mem->s, event, mask );
999
1000 recv_p = mem->recv_buf;
1001 recv_last = mem->recv_buf + n_expected;
1002 send_p = mem->send_buf;
1003 send_last = mem->send_buf + n_expected;
1004
1005 while ( TRUE )
1006 {
1007 err = WaitForSingleObject ( event, INFINITE );
1008 ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
1009
1010 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
1011 ok( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
1012
1013 if ( wsa_events.lNetworkEvents & FD_WRITE )
1014 {
1015 err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
1016 ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
1017
1018 if ( err== 0 )
1019 do
1020 {
1021 n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
1022 if ( n < 0 )
1023 {
1024 err = WSAGetLastError ();
1025 ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
1026 }
1027 else
1028 send_p += n;
1029 }
1030 while ( n >= 0 && send_p < send_last );
1031
1032 if ( send_p == send_last )
1033 {
1034 trace ( "event_client (%x): all data sent - shutdown\n", id );
1035 shutdown ( mem->s, SD_SEND );
1036 mask &= ~FD_WRITE;
1037 WSAEventSelect ( mem->s, event, mask );
1038 }
1039 }
1040 if ( wsa_events.lNetworkEvents & FD_READ )
1041 {
1042 err = wsa_events.iErrorCode[ FD_READ_BIT ];
1043 ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
1044 if ( err != 0 ) break;
1045
1046 /* First read must succeed */
1047 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
1048 wsa_ok ( n, 0 <=, "event_client (%x): recv error: %d\n" );
1049
1050 while ( n >= 0 ) {
1051 recv_p += n;
1052 if ( recv_p == recv_last )
1053 {
1054 mask &= ~FD_READ;
1055 trace ( "event_client (%x): all data received\n", id );
1056 WSAEventSelect ( mem->s, event, mask );
1057 break;
1058 }
1059 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
1060 if ( n < 0 && ( err = WSAGetLastError()) != WSAEWOULDBLOCK )
1061 ok ( 0, "event_client (%x): read error: %d\n", id, err );
1062
1063 }
1064 }
1065 if ( wsa_events.lNetworkEvents & FD_CLOSE )
1066 {
1067 trace ( "event_client (%x): close event\n", id );
1068 err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
1069 ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
1070 break;
1071 }
1072 }
1073
1074 n = send_p - mem->send_buf;
1075 ok ( send_p == send_last,
1076 "simple_client (%x): sent less data than expected: %d of %d\n", id, n, n_expected );
1077 n = recv_p - mem->recv_buf;
1078 ok ( recv_p == recv_last,
1079 "simple_client (%x): received less data than expected: %d of %d\n", id, n, n_expected );
1080 n = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
1081 ok ( n == -1, "event_client (%x): test pattern error: %d\n", id, n);
1082
1083 out:
1084 WSACloseEvent ( event );
1085 trace ( "event_client (%x) exiting\n", id );
1086 client_stop ();
1087 }
1088
1089 /* Tests for WSAStartup */
1090 static void test_WithoutWSAStartup(void)
1091 {
1092 DWORD err;
1093
1094 WSASetLastError(0xdeadbeef);
1095 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET, "WSASocketA should have failed\n");
1096 err = WSAGetLastError();
1097 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
1098
1099 WSASetLastError(0xdeadbeef);
1100 ok(gethostbyname("localhost") == NULL, "gethostbyname() succeeded unexpectedly\n");
1101 err = WSAGetLastError();
1102 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
1103 }
1104
1105 static void test_WithWSAStartup(void)
1106 {
1107 WSADATA data;
1108 WORD version = MAKEWORD( 2, 2 );
1109 INT res, socks, i, j;
1110 SOCKET sock;
1111 LPVOID ptr;
1112 struct
1113 {
1114 SOCKET src, dst, dup_src, dup_dst;
1115 } pairs[128];
1116 DWORD error;
1117
1118 res = WSAStartup( version, &data );
1119 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1120
1121 ptr = gethostbyname("localhost");
1122 ok(ptr != NULL, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1123
1124 /* Alloc some sockets to check if they are destroyed on WSACleanup */
1125 for (socks = 0; socks < sizeof(pairs) / sizeof(pairs[0]); socks++)
1126 {
1127 WSAPROTOCOL_INFOA info;
1128 if (tcp_socketpair(&pairs[socks].src, &pairs[socks].dst)) break;
1129
1130 memset(&info, 0, sizeof(info));
1131 ok(!WSADuplicateSocketA(pairs[socks].src, GetCurrentProcessId(), &info),
1132 "WSADuplicateSocketA should have worked\n");
1133 pairs[socks].dup_src = WSASocketA(0, 0, 0, &info, 0, 0);
1134 ok(pairs[socks].dup_src != SOCKET_ERROR, "expected != -1\n");
1135
1136 memset(&info, 0, sizeof(info));
1137 ok(!WSADuplicateSocketA(pairs[socks].dst, GetCurrentProcessId(), &info),
1138 "WSADuplicateSocketA should have worked\n");
1139 pairs[socks].dup_dst = WSASocketA(0, 0, 0, &info, 0, 0);
1140 ok(pairs[socks].dup_dst != SOCKET_ERROR, "expected != -1\n");
1141 }
1142
1143 res = send(pairs[0].src, "TEST", 4, 0);
1144 ok(res == 4, "send failed with error %d\n", WSAGetLastError());
1145
1146 WSACleanup();
1147
1148 res = WSAStartup( version, &data );
1149 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1150
1151 /* show that sockets are destroyed automatically after WSACleanup */
1152 todo_wine {
1153 SetLastError(0xdeadbeef);
1154 res = send(pairs[0].src, "TEST", 4, 0);
1155 error = WSAGetLastError();
1156 ok(res == SOCKET_ERROR, "send should have failed\n");
1157 ok(error == WSAENOTSOCK, "expected 10038, got %d\n", error);
1158
1159 SetLastError(0xdeadbeef);
1160 res = send(pairs[0].dst, "TEST", 4, 0);
1161 error = WSAGetLastError();
1162 ok(res == SOCKET_ERROR, "send should have failed\n");
1163 ok(error == WSAENOTSOCK, "expected 10038, got %d\n", error);
1164
1165 /* Check that all sockets were destroyed */
1166 for (i = 0; i < socks; i++)
1167 {
1168 for (j = 0; j < 4; j++)
1169 {
1170 struct sockaddr_in saddr;
1171 int size = sizeof(saddr);
1172 switch(j)
1173 {
1174 case 0: sock = pairs[i].src; break;
1175 case 1: sock = pairs[i].dup_src; break;
1176 case 2: sock = pairs[i].dst; break;
1177 case 3: sock = pairs[i].dup_dst; break;
1178 }
1179
1180 SetLastError(0xdeadbeef);
1181 res = getsockname(sock, (struct sockaddr *)&saddr, &size);
1182 error = WSAGetLastError();
1183 ok(res == SOCKET_ERROR, "Test[%d]: getsockname should have failed\n", i);
1184 ok(error == WSAENOTSOCK, "Test[%d]: expected 10038, got %d\n", i, error);
1185 }
1186 }
1187
1188 }
1189
1190 /* While wine is not fixed, close all sockets manually */
1191 for (i = 0; i < socks; i++)
1192 {
1193 closesocket(pairs[i].src);
1194 closesocket(pairs[i].dst);
1195 closesocket(pairs[i].dup_src);
1196 closesocket(pairs[i].dup_dst);
1197 }
1198
1199 res = WSACleanup();
1200 ok(res == 0, "expected 0, got %d\n", res);
1201 WSASetLastError(0xdeadbeef);
1202 res = WSACleanup();
1203 error = WSAGetLastError();
1204 ok ( (res == SOCKET_ERROR && error == WSANOTINITIALISED) ||
1205 broken(res == 0), /* WinME */
1206 "WSACleanup returned %d WSAGetLastError is %d\n", res, error);
1207 }
1208
1209 /**************** Main program utility functions ***************/
1210
1211 static void Init (void)
1212 {
1213 WORD ver = MAKEWORD (2, 2);
1214 WSADATA data;
1215 HMODULE hws2_32 = GetModuleHandleA("ws2_32.dll"), hiphlpapi;
1216
1217 pfreeaddrinfo = (void *)GetProcAddress(hws2_32, "freeaddrinfo");
1218 pgetaddrinfo = (void *)GetProcAddress(hws2_32, "getaddrinfo");
1219 pFreeAddrInfoW = (void *)GetProcAddress(hws2_32, "FreeAddrInfoW");
1220 pGetAddrInfoW = (void *)GetProcAddress(hws2_32, "GetAddrInfoW");
1221 pInetNtop = (void *)GetProcAddress(hws2_32, "inet_ntop");
1222 pInetPtonA = (void *)GetProcAddress(hws2_32, "inet_pton");
1223 pInetPtonW = (void *)GetProcAddress(hws2_32, "InetPtonW");
1224 pWSALookupServiceBeginW = (void *)GetProcAddress(hws2_32, "WSALookupServiceBeginW");
1225 pWSALookupServiceEnd = (void *)GetProcAddress(hws2_32, "WSALookupServiceEnd");
1226 pWSALookupServiceNextW = (void *)GetProcAddress(hws2_32, "WSALookupServiceNextW");
1227 pWSAEnumNameSpaceProvidersA = (void *)GetProcAddress(hws2_32, "WSAEnumNameSpaceProvidersA");
1228 pWSAEnumNameSpaceProvidersW = (void *)GetProcAddress(hws2_32, "WSAEnumNameSpaceProvidersW");
1229 pWSAPoll = (void *)GetProcAddress(hws2_32, "WSAPoll");
1230
1231 hiphlpapi = LoadLibraryA("iphlpapi.dll");
1232 if (hiphlpapi)
1233 {
1234 pGetIpForwardTable = (void *)GetProcAddress(hiphlpapi, "GetIpForwardTable");
1235 pGetAdaptersInfo = (void *)GetProcAddress(hiphlpapi, "GetAdaptersInfo");
1236 }
1237
1238 ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
1239 tls = TlsAlloc();
1240 }
1241
1242 static void Exit (void)
1243 {
1244 INT ret, err;
1245 TlsFree ( tls );
1246 ret = WSACleanup();
1247 err = WSAGetLastError();
1248 ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
1249 }
1250
1251 static void StartServer (LPTHREAD_START_ROUTINE routine,
1252 test_params *general, server_params *par)
1253 {
1254 par->general = general;
1255 thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
1256 ok ( thread[0] != NULL, "Failed to create server thread\n" );
1257 }
1258
1259 static void StartClients (LPTHREAD_START_ROUTINE routine,
1260 test_params *general, client_params *par)
1261 {
1262 int i;
1263 par->general = general;
1264 for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
1265 {
1266 client_id = i - 1;
1267 thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
1268 ok ( thread[i] != NULL, "Failed to create client thread\n" );
1269 /* Make sure the client is up and running */
1270 WaitForSingleObject ( client_ready[client_id], INFINITE );
1271 };
1272 }
1273
1274 static void do_test( test_setup *test )
1275 {
1276 DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
1277 DWORD wait;
1278
1279 server_ready = CreateEventA ( NULL, TRUE, FALSE, NULL );
1280 for (i = 0; i <= n; i++)
1281 client_ready[i] = CreateEventA ( NULL, TRUE, FALSE, NULL );
1282
1283 StartServer ( test->srv, &test->general, &test->srv_params );
1284 StartClients ( test->clt, &test->general, &test->clt_params );
1285 WaitForSingleObject ( server_ready, INFINITE );
1286
1287 wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
1288 ok ( wait <= WAIT_OBJECT_0 + n ,
1289 "some threads have not completed: %x\n", wait );
1290
1291 if ( ! ( wait <= WAIT_OBJECT_0 + n ) )
1292 {
1293 for (i = 0; i <= n; i++)
1294 {
1295 if ( WaitForSingleObject ( thread[i], 0 ) != WAIT_OBJECT_0 )
1296 {
1297 trace ("terminating thread %08x\n", thread_id[i]);
1298 TerminateThread ( thread [i], 0 );
1299 }
1300 }
1301 }
1302 CloseHandle ( server_ready );
1303 for (i = 0; i <= n; i++)
1304 CloseHandle ( client_ready[i] );
1305 }
1306
1307 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1308 /* optname = SO_LINGER */
1309 static const LINGER linger_testvals[] = {
1310 {0,0},
1311 {0,73},
1312 {1,0},
1313 {5,189}
1314 };
1315
1316 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1317 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1318 bug in the linux kernel (fixed in 2.6.8) */
1319 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1320
1321 static void test_set_getsockopt(void)
1322 {
1323 SOCKET s, s2;
1324 int i, err, lasterr;
1325 int timeout;
1326 LINGER lingval;
1327 int size;
1328 WSAPROTOCOL_INFOA infoA;
1329 WSAPROTOCOL_INFOW infoW;
1330 char providername[WSAPROTOCOL_LEN + 1];
1331 struct _prottest
1332 {
1333 int family, type, proto;
1334 } prottest[] = {
1335 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
1336 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
1337 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
1338 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP}
1339 };
1340 union _csspace
1341 {
1342 CSADDR_INFO cs;
1343 char space[128];
1344 } csinfoA, csinfoB;
1345
1346 s = socket(AF_INET, SOCK_STREAM, 0);
1347 ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1348 if( s == INVALID_SOCKET) return;
1349 /* SO_RCVTIMEO */
1350 timeout = SOCKTIMEOUT1;
1351 size = sizeof(timeout);
1352 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1353 if( !err)
1354 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1355 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1356 ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1357
1358 timeout = 0;
1359 size = sizeof(timeout);
1360 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1361 if( !err)
1362 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1363 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1364 ok( timeout == 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1365
1366 /* SO_SNDTIMEO */
1367 timeout = SOCKTIMEOUT2; /* 997 seconds. See remark above */
1368 size = sizeof(timeout);
1369 err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
1370 if( !err)
1371 err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
1372 ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1373 ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
1374 /* SO_LINGER */
1375 for( i = 0; i < sizeof(linger_testvals)/sizeof(LINGER);i++) {
1376 size = sizeof(lingval);
1377 lingval = linger_testvals[i];
1378 err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, size);
1379 if( !err)
1380 err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, &size);
1381 ok( !err, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1382 ok( !lingval.l_onoff == !linger_testvals[i].l_onoff &&
1383 (lingval.l_linger == linger_testvals[i].l_linger ||
1384 (!lingval.l_linger && !linger_testvals[i].l_onoff))
1385 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i,
1386 lingval.l_onoff, lingval.l_linger,
1387 linger_testvals[i].l_onoff, linger_testvals[i].l_linger);
1388 }
1389
1390 size = sizeof(lingval);
1391 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, size);
1392 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1393 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1394 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, 0);
1395 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1396 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1397
1398 size = sizeof(BOOL);
1399 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, size);
1400 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1401 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1402 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, 0);
1403 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1404 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1405
1406 /* Test for erroneously passing a value instead of a pointer as optval */
1407 size = sizeof(char);
1408 err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
1409 ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
1410 "instead of failing.\n");
1411 lasterr = WSAGetLastError();
1412 ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
1413 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1414 lasterr, WSAEFAULT);
1415
1416 /* SO_RCVTIMEO with invalid values for level */
1417 size = sizeof(timeout);
1418 timeout = SOCKTIMEOUT1;
1419 SetLastError(0xdeadbeef);
1420 err = setsockopt(s, 0xffffffff, SO_RCVTIMEO, (char *) &timeout, size);
1421 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1422 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1423 err, WSAGetLastError());
1424
1425 timeout = SOCKTIMEOUT1;
1426 SetLastError(0xdeadbeef);
1427 err = setsockopt(s, 0x00008000, SO_RCVTIMEO, (char *) &timeout, size);
1428 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1429 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1430 err, WSAGetLastError());
1431
1432 /* Test SO_ERROR set/get */
1433 SetLastError(0xdeadbeef);
1434 i = 1234;
1435 err = setsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, size);
1436 todo_wine
1437 ok( !err && !WSAGetLastError(),
1438 "got %d with %d (expected 0 with 0)\n",
1439 err, WSAGetLastError());
1440
1441 SetLastError(0xdeadbeef);
1442 i = 4321;
1443 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1444 todo_wine
1445 ok( !err && !WSAGetLastError(),
1446 "got %d with %d (expected 0 with 0)\n",
1447 err, WSAGetLastError());
1448 todo_wine
1449 ok (i == 1234, "got %d (expected 1234)\n", i);
1450
1451 /* Test invalid optlen */
1452 SetLastError(0xdeadbeef);
1453 size = 1;
1454 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1455 todo_wine
1456 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEFAULT),
1457 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1458 err, WSAGetLastError());
1459
1460 closesocket(s);
1461 /* Test with the closed socket */
1462 SetLastError(0xdeadbeef);
1463 size = sizeof(i);
1464 i = 1234;
1465 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1466 todo_wine
1467 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAENOTSOCK),
1468 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1469 err, WSAGetLastError());
1470 ok (i == 1234, "expected 1234, got %d\n", i);
1471
1472 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1473 s = socket(AF_INET, SOCK_DGRAM, 0);
1474 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1475 size = sizeof(i);
1476 i = 0x0000000a;
1477 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &i, size);
1478 if (!err)
1479 {
1480 for (i = 0; i < 4; i++)
1481 {
1482 int k, j;
1483 const int tests[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1484 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &tests[i], i + 1);
1485 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1486 err = getsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &k, &size);
1487 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1488 j = i != 3 ? tests[i] & ((1 << (i + 1) * 8) - 1) : tests[i];
1489 ok(k == j, "Test [%d] Expected 0x%x, got 0x%x\n", i, j, k);
1490 }
1491 }
1492 else
1493 win_skip("IP_MULTICAST_TTL is unsupported\n");
1494 closesocket(s);
1495
1496 /* test SO_PROTOCOL_INFOA invalid parameters */
1497 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1498 "getsockopt should have failed\n");
1499 err = WSAGetLastError();
1500 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1501 size = sizeof(WSAPROTOCOL_INFOA);
1502 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1503 "getsockopt should have failed\n");
1504 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1505 err = WSAGetLastError();
1506 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1507 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1508 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1509 "getsockopt should have failed\n");
1510 err = WSAGetLastError();
1511 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1512 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, NULL),
1513 "getsockopt should have failed\n");
1514 err = WSAGetLastError();
1515 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1516 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, &size),
1517 "getsockopt should have failed\n");
1518 err = WSAGetLastError();
1519 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1520 size = sizeof(WSAPROTOCOL_INFOA) / 2;
1521 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1522 "getsockopt should have failed\n");
1523 err = WSAGetLastError();
1524 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1525 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1526 size = sizeof(WSAPROTOCOL_INFOA) * 2;
1527 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1528 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1529 ok(size == sizeof(WSAPROTOCOL_INFOA) * 2, "got size %d\n", size);
1530
1531 closesocket(s);
1532
1533 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1534 for (i = 0; i < sizeof(prottest) / sizeof(prottest[0]); i++)
1535 {
1536 s = socket(prottest[i].family, prottest[i].type, prottest[i].proto);
1537 if (s == INVALID_SOCKET && prottest[i].family == AF_INET6) continue;
1538
1539 ok(s != INVALID_SOCKET, "Failed to create socket: %d\n",
1540 WSAGetLastError());
1541
1542 /* compare both A and W version */
1543 infoA.szProtocol[0] = 0;
1544 size = sizeof(WSAPROTOCOL_INFOA);
1545 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1546 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1547 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1548
1549 infoW.szProtocol[0] = 0;
1550 size = sizeof(WSAPROTOCOL_INFOW);
1551 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &infoW, &size);
1552 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1553 ok(size == sizeof(WSAPROTOCOL_INFOW), "got size %d\n", size);
1554
1555 trace("provider name '%s', family %d, type %d, proto %d\n",
1556 infoA.szProtocol, prottest[i].family, prottest[i].type, prottest[i].proto);
1557
1558 ok(infoA.szProtocol[0] || broken(!infoA.szProtocol[0]) /* NT4 */,
1559 "WSAPROTOCOL_INFOA was not filled\n");
1560 ok(infoW.szProtocol[0] || broken(!infoA.szProtocol[0]) /* NT4 */,
1561 "WSAPROTOCOL_INFOW was not filled\n");
1562
1563 WideCharToMultiByte(CP_ACP, 0, infoW.szProtocol, -1,
1564 providername, sizeof(providername), NULL, NULL);
1565 ok(!strcmp(infoA.szProtocol,providername),
1566 "different provider names '%s' != '%s'\n", infoA.szProtocol, providername);
1567
1568 ok(!memcmp(&infoA, &infoW, FIELD_OFFSET(WSAPROTOCOL_INFOA, szProtocol)),
1569 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1570
1571 /* Remove IF when WSAEnumProtocols support IPV6 data */
1572 if (prottest[i].family == AF_INET6)
1573 {
1574 todo_wine
1575 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1576 prottest[i].family, infoA.iAddressFamily);
1577 }
1578 else
1579 {
1580 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1581 prottest[i].family, infoA.iAddressFamily);
1582 } ok(infoA.iSocketType == prottest[i].type, "socket type invalid, expected %d received %d\n",
1583 prottest[i].type, infoA.iSocketType);
1584 ok(infoA.iProtocol == prottest[i].proto, "socket protocol invalid, expected %d received %d\n",
1585 prottest[i].proto, infoA.iProtocol);
1586
1587 closesocket(s);
1588 }
1589
1590 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1591 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1592 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1593 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1594 ok(s2 != INVALID_SOCKET, "Failed to create socket\n");
1595
1596 SetLastError(0xdeadbeef);
1597 size = sizeof(csinfoA);
1598 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1599 if (!err)
1600 {
1601 struct sockaddr_in saddr;
1602 memset(&saddr, 0, sizeof(saddr));
1603 saddr.sin_family = AF_INET;
1604 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1605
1606 /* Socket is not bound, no information provided */
1607 ok(!csinfoA.cs.LocalAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1608 ok(csinfoA.cs.LocalAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1609 /* Socket is not connected, no information provided */
1610 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1611 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1612
1613 err = bind(s, (struct sockaddr*)&saddr, sizeof(saddr));
1614 ok(!err, "Expected 0, got %d\n", err);
1615 size = sizeof(csinfoA);
1616 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1617 ok(!err, "Expected 0, got %d\n", err);
1618
1619 /* Socket is bound */
1620 ok(csinfoA.cs.LocalAddr.iSockaddrLength, "Expected non-zero\n");
1621 ok(csinfoA.cs.LocalAddr.lpSockaddr != NULL, "Expected non-null\n");
1622 /* Socket is not connected, no information provided */
1623 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1624 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1625
1626 err = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1627 ok(!err, "Expected 0, got %d\n", err);
1628 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1629 ok(!err, "Expected 0, got %d\n", err);
1630 err = listen(s2, 1);
1631 ok(!err, "Expected 0, got %d\n", err);
1632 err = connect(s, (struct sockaddr*)&saddr, sizeof(saddr));
1633 ok(!err, "Expected 0, got %d\n", err);
1634 size = sizeof(saddr);
1635 err = accept(s2, (struct sockaddr*)&saddr, &size);
1636 ok(err != INVALID_SOCKET, "Failed to accept socket\n");
1637 closesocket(s2);
1638 s2 = err;
1639
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 err = getsockopt(s2, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoB, &size);
1644 ok(!err, "Expected 0, got %d\n", err);
1645 ok(size == sizeof(csinfoA), "Got %d\n", size);
1646 size = sizeof(saddr);
1647 ok(size == csinfoA.cs.LocalAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1648 csinfoA.cs.LocalAddr.iSockaddrLength);
1649 ok(size == csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1650 csinfoA.cs.RemoteAddr.iSockaddrLength);
1651 ok(!memcmp(csinfoA.cs.LocalAddr.lpSockaddr, csinfoB.cs.RemoteAddr.lpSockaddr, size),
1652 "Expected matching addresses\n");
1653 ok(!memcmp(csinfoB.cs.LocalAddr.lpSockaddr, csinfoA.cs.RemoteAddr.lpSockaddr, size),
1654 "Expected matching addresses\n");
1655 ok(csinfoA.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1656 ok(csinfoB.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1657 ok(csinfoA.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1658 ok(csinfoB.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1659
1660 err = getpeername(s, (struct sockaddr *)&saddr, &size);
1661 ok(!err, "Expected 0, got %d\n", err);
1662 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1663 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1664 err = getpeername(s2, (struct sockaddr *)&saddr, &size);
1665 ok(!err, "Expected 0, got %d\n", err);
1666 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1667 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1668 err = getsockname(s, (struct sockaddr *)&saddr, &size);
1669 ok(!err, "Expected 0, got %d\n", err);
1670 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1671 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1672 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1673 ok(!err, "Expected 0, got %d\n", err);
1674 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1675 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1676
1677 SetLastError(0xdeadbeef);
1678 size = sizeof(CSADDR_INFO);
1679 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1680 ok(err, "Expected non-zero\n");
1681 ok(size == sizeof(CSADDR_INFO), "Got %d\n", size);
1682 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %d\n", GetLastError());
1683
1684 /* At least for IPv4 the size is exactly 56 bytes */
1685 size = sizeof(*csinfoA.cs.LocalAddr.lpSockaddr) * 2 + sizeof(csinfoA.cs);
1686 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1687 ok(!err, "Expected 0, got %d\n", err);
1688 size--;
1689 SetLastError(0xdeadbeef);
1690 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1691 ok(err, "Expected non-zero\n");
1692 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %d\n", GetLastError());
1693 }
1694 else
1695 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %d\n", GetLastError());
1696
1697 closesocket(s);
1698 closesocket(s2);
1699 }
1700
1701 static void test_so_reuseaddr(void)
1702 {
1703 struct sockaddr_in saddr;
1704 SOCKET s1,s2;
1705 unsigned int rc,reuse;
1706 int size;
1707 DWORD err;
1708
1709 saddr.sin_family = AF_INET;
1710 saddr.sin_port = htons(9375);
1711 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1712
1713 s1=socket(AF_INET, SOCK_STREAM, 0);
1714 ok(s1!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1715 rc = bind(s1, (struct sockaddr*)&saddr, sizeof(saddr));
1716 ok(rc!=SOCKET_ERROR, "bind(s1) failed error: %d\n", WSAGetLastError());
1717
1718 s2=socket(AF_INET, SOCK_STREAM, 0);
1719 ok(s2!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1720
1721 reuse=0x1234;
1722 size=sizeof(reuse);
1723 rc=getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size );
1724 ok(rc==0 && reuse==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc,reuse);
1725
1726 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1727 ok(rc==SOCKET_ERROR, "bind() succeeded\n");
1728
1729 reuse = 1;
1730 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
1731 ok(rc==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1732
1733 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1734 * a port immediately after closing another socket on that port, so
1735 * basically following the BSD socket semantics here. */
1736 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1737 if(rc==0)
1738 {
1739 int s3=socket(AF_INET, SOCK_STREAM, 0), s4;
1740 trace("<= Win XP behavior of SO_REUSEADDR\n");
1741
1742 /* If we could bind again in the same port this is Windows version <= XP.
1743 * Lets test if we can really connect to one of them. */
1744 set_blocking(s1, FALSE);
1745 set_blocking(s2, FALSE);
1746 rc = listen(s1, 1);
1747 ok(!rc, "listen() failed with error: %d\n", WSAGetLastError());
1748 rc = listen(s2, 1);
1749 ok(!rc, "listen() failed with error: %d\n", WSAGetLastError());
1750 rc = connect(s3, (struct sockaddr*)&saddr, sizeof(saddr));
1751 ok(!rc, "connecting to accepting socket failed %d\n", WSAGetLastError());
1752
1753 /* the delivery of the connection is random so we need to try on both sockets */
1754 size = sizeof(saddr);
1755 s4 = accept(s1, (struct sockaddr*)&saddr, &size);
1756 if(s4 == INVALID_SOCKET)
1757 s4 = accept(s2, (struct sockaddr*)&saddr, &size);
1758 ok(s4 != INVALID_SOCKET, "none of the listening sockets could get the connection\n");
1759
1760 closesocket(s1);
1761 closesocket(s3);
1762 closesocket(s4);
1763 }
1764 else
1765 {
1766 trace(">= Win 2003 behavior of SO_REUSEADDR\n");
1767 err = WSAGetLastError();
1768 ok(err==WSAEACCES, "expected 10013, got %d\n", err);
1769
1770 closesocket(s1);
1771 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1772 ok(rc==0, "bind() failed error: %d\n", WSAGetLastError());
1773 }
1774
1775 closesocket(s2);
1776 }
1777
1778 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1779
1780 static void test_ip_pktinfo(void)
1781 {
1782 ULONG addresses[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY)};
1783 char recvbuf[10], pktbuf[512], msg[] = "HELLO";
1784 struct sockaddr_in s1addr, s2addr, s3addr;
1785 GUID WSARecvMsg_GUID = WSAID_WSARECVMSG;
1786 LPFN_WSARECVMSG pWSARecvMsg = NULL;
1787 unsigned int rc, yes = 1;
1788 BOOL foundhdr;
1789 DWORD dwBytes, dwSize, dwFlags;
1790 socklen_t addrlen;
1791 WSACMSGHDR *cmsg;
1792 WSAOVERLAPPED ov;
1793 WSABUF iovec[1];
1794 SOCKET s1, s2;
1795 WSAMSG hdr;
1796 int i, err;
1797
1798 memset(&ov, 0, sizeof(ov));
1799 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1800 if (ov.hEvent == INVALID_HANDLE_VALUE)
1801 {
1802 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
1803 return;
1804 }
1805
1806 memset(&hdr, 0x00, sizeof(hdr));
1807 s1addr.sin_family = AF_INET;
1808 s1addr.sin_port = htons(0);
1809 /* Note: s1addr.sin_addr is set below */
1810 iovec[0].buf = recvbuf;
1811 iovec[0].len = sizeof(recvbuf);
1812 hdr.name = (struct sockaddr*)&s3addr;
1813 hdr.namelen = sizeof(s3addr);
1814 hdr.lpBuffers = &iovec[0];
1815 hdr.dwBufferCount = 1;
1816 hdr.Control.buf = pktbuf;
1817 /* Note: hdr.Control.len is set below */
1818 hdr.dwFlags = 0;
1819
1820 for (i=0;i<sizeof(addresses)/sizeof(UINT32);i++)
1821 {
1822 s1addr.sin_addr.s_addr = addresses[i];
1823
1824 /* Build "server" side socket */
1825 s1=socket(AF_INET, SOCK_DGRAM, 0);
1826 if (s1 == INVALID_SOCKET)
1827 {
1828 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1829 goto cleanup;
1830 }
1831
1832 /* Obtain the WSARecvMsg function */
1833 WSAIoctl(s1, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
1834 &pWSARecvMsg, sizeof(pWSARecvMsg), &dwBytes, NULL, NULL);
1835 if (!pWSARecvMsg)
1836 {
1837 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
1838 closesocket(s1);
1839 goto cleanup;
1840 }
1841
1842 /* Setup the server side socket */
1843 rc=bind(s1, (struct sockaddr*)&s1addr, sizeof(s1addr));
1844 ok(rc != SOCKET_ERROR, "bind() failed error: %d\n", WSAGetLastError());
1845 rc=setsockopt(s1, IPPROTO_IP, IP_PKTINFO, (const char*)&yes, sizeof(yes));
1846 ok(rc == 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1847
1848 /* Build "client" side socket */
1849 addrlen = sizeof(s2addr);
1850 if (getsockname(s1, (struct sockaddr *) &s2addr, &addrlen) != 0)
1851 {
1852 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
1853 closesocket(s1);
1854 goto cleanup;
1855 }
1856 s2addr.sin_addr.s_addr = addresses[0]; /* Always target the local adapter address */
1857 s2=socket(AF_INET, SOCK_DGRAM, 0);
1858 if (s2 == INVALID_SOCKET)
1859 {
1860 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1861 closesocket(s1);
1862 goto cleanup;
1863 }
1864
1865 /* Test an empty message header */
1866 rc=pWSARecvMsg(s1, NULL, NULL, NULL, NULL);
1867 err=WSAGetLastError();
1868 ok(rc == SOCKET_ERROR && err == WSAEFAULT, "WSARecvMsg() failed error: %d (ret = %d)\n", err, rc);
1869
1870 /*
1871 * Send a packet from the client to the server and test for specifying
1872 * a short control header.
1873 */
1874 SetLastError(0xdeadbeef);
1875 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1876 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1877 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
1878 hdr.Control.len = 1;
1879 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
1880 err=WSAGetLastError();
1881 ok(rc == SOCKET_ERROR && err == WSAEMSGSIZE && (hdr.dwFlags & MSG_CTRUNC),
1882 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err, rc, hdr.dwFlags);
1883 hdr.dwFlags = 0; /* Reset flags */
1884
1885 /* Perform another short control header test, this time with an overlapped receive */
1886 hdr.Control.len = 1;
1887 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
1888 err=WSAGetLastError();
1889 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
1890 SetLastError(0xdeadbeef);
1891 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1892 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1893 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
1894 if (WaitForSingleObject(ov.hEvent, 100) != WAIT_OBJECT_0)
1895 {
1896 skip("Server side did not receive packet, some tests skipped.\n");
1897 closesocket(s2);
1898 closesocket(s1);
1899 continue;
1900 }
1901 dwFlags = 0;
1902 WSAGetOverlappedResult(s1, &ov, NULL, FALSE, &dwFlags);
1903 ok(dwFlags == 0,
1904 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags);
1905 ok(hdr.dwFlags == MSG_CTRUNC,
1906 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr.dwFlags);
1907 hdr.dwFlags = 0; /* Reset flags */
1908
1909 /*
1910 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1911 * on the server end and check that the returned packet matches what was sent.
1912 */
1913 hdr.Control.len = sizeof(pktbuf);
1914 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
1915 err=WSAGetLastError();
1916 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
1917 ok(hdr.Control.len == sizeof(pktbuf),
1918 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr.Control.len);
1919 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1920 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1921 if (WaitForSingleObject(ov.hEvent, 100) != WAIT_OBJECT_0)
1922 {
1923 skip("Server side did not receive packet, some tests skipped.\n");
1924 closesocket(s2);
1925 closesocket(s1);
1926 continue;
1927 }
1928 dwSize = 0;
1929 WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, NULL);
1930 ok(dwSize == sizeof(msg),
1931 "WSARecvMsg() buffer length does not match transmitted data!\n");
1932 ok(strncmp(iovec[0].buf, msg, sizeof(msg)) == 0,
1933 "WSARecvMsg() buffer does not match transmitted data!\n");
1934 ok(hdr.Control.len == IP_PKTINFO_LEN,
1935 "WSARecvMsg() control length mismatch (%d).\n", hdr.Control.len);
1936
1937 /* Test for the expected IP_PKTINFO return information. */
1938 foundhdr = FALSE;
1939 for (cmsg = WSA_CMSG_FIRSTHDR(&hdr); cmsg != NULL; cmsg = WSA_CMSG_NXTHDR(&hdr, cmsg))
1940 {
1941 if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
1942 {
1943 struct in_pktinfo *pi = (struct in_pktinfo *)WSA_CMSG_DATA(cmsg);
1944
1945 ok(pi->ipi_addr.s_addr == s2addr.sin_addr.s_addr, "destination ip mismatch!\n");
1946 foundhdr = TRUE;
1947 }
1948 }
1949 ok(foundhdr, "IP_PKTINFO header information was not returned!\n");
1950
1951 closesocket(s2);
1952 closesocket(s1);
1953 }
1954
1955 cleanup:
1956 CloseHandle(ov.hEvent);
1957 }
1958
1959 /************* Array containing the tests to run **********/
1960
1961 #define STD_STREAM_SOCKET \
1962 SOCK_STREAM, \
1963 0, \
1964 SERVERIP, \
1965 SERVERPORT
1966
1967 static test_setup tests [] =
1968 {
1969 /* Test 0: synchronous client and server */
1970 {
1971 {
1972 STD_STREAM_SOCKET,
1973 2048,
1974 16,
1975 2
1976 },
1977 simple_server,
1978 {
1979 NULL,
1980 0,
1981 64
1982 },
1983 simple_client,
1984 {
1985 NULL,
1986 0,
1987 128
1988 }
1989 },
1990 /* Test 1: event-driven client, synchronous server */
1991 {
1992 {
1993 STD_STREAM_SOCKET,
1994 2048,
1995 16,
1996 2
1997 },
1998 simple_server,
1999 {
2000 NULL,
2001 0,
2002 64
2003 },
2004 event_client,
2005 {
2006 NULL,
2007 WSA_FLAG_OVERLAPPED,
2008 128
2009 }
2010 },
2011 /* Test 2: synchronous client, non-blocking server via select() */
2012 {
2013 {
2014 STD_STREAM_SOCKET,
2015 2048,
2016 16,
2017 2
2018 },
2019 select_server,
2020 {
2021 NULL,
2022 0,
2023 64
2024 },
2025 simple_client,
2026 {
2027 NULL,
2028 0,
2029 128
2030 }
2031 },
2032 /* Test 3: OOB client, OOB server */
2033 {
2034 {
2035 STD_STREAM_SOCKET,
2036 128,
2037 16,
2038 1
2039 },
2040 oob_server,
2041 {
2042 NULL,
2043 0,
2044 128
2045 },
2046 oob_client,
2047 {
2048 NULL,
2049 0,
2050 128
2051 }
2052 },
2053 /* Test 4: synchronous mixed client and server */
2054 {
2055 {
2056 STD_STREAM_SOCKET,
2057 2048,
2058 16,
2059 2
2060 },
2061 simple_server,
2062 {
2063 NULL,
2064 0,
2065 64
2066 },
2067 simple_mixed_client,
2068 {
2069 NULL,
2070 0,
2071 128
2072 }
2073 }
2074 };
2075
2076 static void test_UDP(void)
2077 {
2078 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2079 possible that this test fails due to dropped packets. */
2080
2081 /* peer 0 receives data from all other peers */
2082 struct sock_info peer[NUM_UDP_PEERS];
2083 char buf[16];
2084 int ss, i, n_recv, n_sent;
2085
2086 memset (buf,0,sizeof(buf));
2087 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
2088 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
2089
2090 peer[i].addr.sin_family = AF_INET;
2091 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
2092
2093 if ( i == 0 ) {
2094 peer[i].addr.sin_port = htons ( SERVERPORT );
2095 } else {
2096 peer[i].addr.sin_port = htons ( 0 );
2097 }
2098
2099 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
2100
2101 /* test getsockname() to get peer's port */
2102 ss = sizeof ( peer[i].addr );
2103 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
2104 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
2105 }
2106
2107 /* test getsockname() */
2108 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
2109
2110 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2111 /* send client's ip */
2112 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
2113 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
2114 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
2115 }
2116
2117 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2118 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
2119 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
2120 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
2121 }
2122 }
2123
2124 static DWORD WINAPI do_getservbyname( void *param )
2125 {
2126 struct {
2127 const char *name;
2128 const char *proto;
2129 int port;
2130 } serv[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
2131
2132 HANDLE *starttest = param;
2133 int i, j;
2134 struct servent *pserv[2];
2135
2136 ok ( WaitForSingleObject ( *starttest, TEST_TIMEOUT * 1000 ) != WAIT_TIMEOUT,
2137 "test_getservbyname: timeout waiting for start signal\n" );
2138
2139 /* ensure that necessary buffer resizes are completed */
2140 for ( j = 0; j < 2; j++) {
2141 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
2142 }
2143
2144 for ( i = 0; i < NUM_QUERIES / 2; i++ ) {
2145 for ( j = 0; j < 2; j++ ) {
2146 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
2147 ok ( pserv[j] != NULL || broken(pserv[j] == NULL) /* win8, fixed in win81 */,
2148 "getservbyname could not retrieve information for %s: %d\n", serv[j].name, WSAGetLastError() );
2149 if ( !pserv[j] ) continue;
2150 ok ( pserv[j]->s_port == htons(serv[j].port),
2151 "getservbyname returned the wrong port for %s: %d\n", serv[j].name, ntohs(pserv[j]->s_port) );
2152 ok ( !strcmp ( pserv[j]->s_proto, serv[j].proto ),
2153 "getservbyname returned the wrong protocol for %s: %s\n", serv[j].name, pserv[j]->s_proto );
2154 ok ( !strcmp ( pserv[j]->s_name, serv[j].name ),
2155 "getservbyname returned the wrong name for %s: %s\n", serv[j].name, pserv[j]->s_name );
2156 }
2157
2158 ok ( pserv[0] == pserv[1] || broken(pserv[0] != pserv[1]) /* win8, fixed in win81 */,
2159 "getservbyname: winsock resized servent buffer when not necessary\n" );
2160 }
2161
2162 return 0;
2163 }
2164
2165 static void test_getservbyname(void)
2166 {
2167 int i;
2168 HANDLE starttest, thread[NUM_THREADS];
2169 DWORD thread_id[NUM_THREADS];
2170
2171 starttest = CreateEventA ( NULL, 1, 0, "test_getservbyname_starttest" );
2172
2173 /* create threads */
2174 for ( i = 0; i < NUM_THREADS; i++ ) {
2175 thread[i] = CreateThread ( NULL, 0, do_getservbyname, &starttest, 0, &thread_id[i] );
2176 }
2177
2178 /* signal threads to start */
2179 SetEvent ( starttest );
2180
2181 for ( i = 0; i < NUM_THREADS; i++) {
2182 WaitForSingleObject ( thread[i], TEST_TIMEOUT * 1000 );
2183 }
2184 }
2185
2186 static void test_WSASocket(void)
2187 {
2188 SOCKET sock = INVALID_SOCKET;
2189 WSAPROTOCOL_INFOA *pi;
2190 int wsaproviders[] = {IPPROTO_TCP, IPPROTO_IP};
2191 int autoprotocols[] = {IPPROTO_TCP, IPPROTO_UDP};
2192 int items, err, size, socktype, i, j;
2193 UINT pi_size;
2194
2195 SetLastError(0xdeadbeef);
2196 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET,
2197 "WSASocketA should have failed\n");
2198 err = WSAGetLastError();
2199 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2200
2201 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
2202 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2203 closesocket(sock);
2204
2205 sock = WSASocketA(AF_INET, SOCK_STREAM, 0, NULL, 0, 0);
2206 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2207 closesocket(sock);
2208
2209 SetLastError(0xdeadbeef);
2210 ok(WSASocketA(0, SOCK_STREAM, -1, NULL, 0, 0) == INVALID_SOCKET,
2211 "WSASocketA should have failed\n");
2212 err = WSAGetLastError();
2213 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2214
2215 SetLastError(0xdeadbeef);
2216 ok(WSASocketA(0, -1, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2217 "WSASocketA should have failed\n");
2218 err = WSAGetLastError();
2219 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2220
2221 SetLastError(0xdeadbeef);
2222 ok(WSASocketA(0, -1, 0, NULL, 0, 0) == INVALID_SOCKET,
2223 "WSASocketA should have failed\n");
2224 err = WSAGetLastError();
2225 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2226
2227 SetLastError(0xdeadbeef);
2228 ok(WSASocketA(AF_INET, -1, 0, NULL, 0, 0) == INVALID_SOCKET,
2229 "WSASocketA should have failed\n");
2230 err = WSAGetLastError();
2231 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2232
2233 SetLastError(0xdeadbeef);
2234 ok(WSASocketA(AF_INET, 0, -1, NULL, 0, 0) == INVALID_SOCKET,
2235 "WSASocketA should have failed\n");
2236 err = WSAGetLastError();
2237 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2238
2239 SetLastError(0xdeadbeef);
2240 ok(WSASocketA(0, -1, -1, NULL, 0, 0) == INVALID_SOCKET,
2241 "WSASocketA should have failed\n");
2242 err = WSAGetLastError();
2243 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2244
2245 SetLastError(0xdeadbeef);
2246 ok(WSASocketA(-1, SOCK_STREAM, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2247 "WSASocketA should have failed\n");
2248 err = WSAGetLastError();
2249 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2250
2251 sock = WSASocketA(AF_INET, 0, IPPROTO_TCP, NULL, 0, 0);
2252 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2253 closesocket(sock);
2254
2255 SetLastError(0xdeadbeef);
2256 ok(WSASocketA(0, SOCK_STREAM, 0, NULL, 0, 0) == INVALID_SOCKET,
2257 "WSASocketA should have failed\n");
2258 err = WSAGetLastError();
2259 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2260
2261 SetLastError(0xdeadbeef);
2262 ok(WSASocketA(0, 0, 0xdead, NULL, 0, 0) == INVALID_SOCKET,
2263 "WSASocketA should have failed\n");
2264 err = WSAGetLastError();
2265 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2266
2267 SetLastError(0xdeadbeef);
2268 ok(WSASocketA(AF_INET, 0xdead, 0, NULL, 0, 0) == INVALID_SOCKET,
2269 "WSASocketA should have failed\n");
2270 err = WSAGetLastError();
2271 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2272
2273 SetLastError(0xdeadbeef);
2274 ok(WSASocketA(0, 0xdead, 0, NULL, 0, 0) == INVALID_SOCKET,
2275 "WSASocketA should have failed\n");
2276 err = WSAGetLastError();
2277 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2278
2279 sock = WSASocketA(0, 0, IPPROTO_TCP, NULL, 0, 0);
2280 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2281 closesocket(sock);
2282
2283 /* SOCK_STREAM does not support IPPROTO_UDP */
2284 SetLastError(0xdeadbeef);
2285 ok(WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2286 "WSASocketA should have failed\n");
2287 err = WSAGetLastError();
2288 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2289
2290 /* SOCK_DGRAM does not support IPPROTO_TCP */
2291 SetLastError(0xdeadbeef);
2292 ok(WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_TCP, NULL, 0, 0) == INVALID_SOCKET,
2293 "WSASocketA should have failed\n");
2294 err = WSAGetLastError();
2295 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2296
2297 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2298 * to avoid a crash on win98.
2299 */
2300 pi_size = 0;
2301 items = WSAEnumProtocolsA(wsaproviders, NULL, &pi_size);
2302 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2303 items);
2304 err = WSAGetLastError();
2305 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2306 err, WSAENOBUFS);
2307
2308 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
2309 ok(pi != NULL, "Failed to allocate memory\n");
2310 if (pi == NULL) {
2311 skip("Can't continue without memory.\n");
2312 return;
2313 }
2314
2315 items = WSAEnumProtocolsA(wsaproviders, pi, &pi_size);
2316 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
2317 WSAGetLastError());
2318
2319 if (items == 0) {
2320 skip("No protocols enumerated.\n");
2321 HeapFree(GetProcessHeap(), 0, pi);
2322 return;
2323 }
2324
2325 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
2326 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
2327 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2328 WSAGetLastError());
2329 closesocket(sock);
2330
2331 /* find what parameters are used first: plain parameters or protocol info struct */
2332 pi[0].iProtocol = -1;
2333 pi[0].iSocketType = -1;
2334 pi[0].iAddressFamily = -1;
2335 ok(WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0) == INVALID_SOCKET,
2336 "WSASocketA should have failed\n");
2337 err = WSAGetLastError();
2338 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2339
2340 pi[0].iProtocol = 0;
2341 pi[0].iSocketType = 0;
2342 pi[0].iAddressFamily = 0;
2343 sock = WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0);
2344 if(sock != INVALID_SOCKET)
2345 {
2346 win_skip("must work only in OS <= 2003\n");
2347 closesocket(sock);
2348 }
2349 else
2350 {
2351 err = WSAGetLastError();
2352 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2353 }
2354
2355 pi[0].iProtocol = IPPROTO_UDP;
2356 pi[0].iSocketType = SOCK_DGRAM;
2357 pi[0].iAddressFamily = AF_INET;
2358 sock = WSASocketA(0, 0, 0, &pi[0], 0, 0);
2359 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2360 WSAGetLastError());
2361 size = sizeof(socktype);
2362 socktype = 0xdead;
2363 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2364 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2365 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2366 SOCK_DGRAM, socktype);
2367 closesocket(sock);
2368
2369 sock = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, &pi[0], 0, 0);
2370 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2371 WSAGetLastError());
2372 size = sizeof(socktype);
2373 socktype = 0xdead;
2374 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2375 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2376 ok(socktype == SOCK_STREAM, "Wrong socket type, expected %d received %d\n",
2377 SOCK_STREAM, socktype);
2378 closesocket(sock);
2379
2380 HeapFree(GetProcessHeap(), 0, pi);
2381
2382 pi_size = 0;
2383 items = WSAEnumProtocolsA(NULL, NULL, &pi_size);
2384 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2385 items);
2386 err = WSAGetLastError();
2387 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2388 err, WSAENOBUFS);
2389
2390 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
2391 ok(pi != NULL, "Failed to allocate memory\n");
2392 if (pi == NULL) {
2393 skip("Can't continue without memory.\n");
2394 return;
2395 }
2396
2397 items = WSAEnumProtocolsA(NULL, pi, &pi_size);
2398 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
2399 WSAGetLastError());
2400
2401 /* when no protocol and socket type are specified the first entry
2402 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2403 * is returned */
2404 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
2405 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2406 WSAGetLastError());
2407
2408 size = sizeof(socktype);
2409 socktype = 0xdead;
2410 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2411 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2412 for(i = 0; i < items; i++)
2413 {
2414 if(pi[i].dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)
2415 {
2416 ok(socktype == pi[i].iSocketType, "Wrong socket type, expected %d received %d\n",
2417 pi[i].iSocketType, socktype);
2418 break;
2419 }
2420 }
2421 ok(i != items, "Creating a socket without protocol and socket type didn't work\n");
2422 closesocket(sock);
2423
2424 /* when no socket type is specified the first entry from WSAEnumProtocols
2425 * that matches the protocol is returned */
2426 for (i = 0; i < sizeof(autoprotocols) / sizeof(autoprotocols[0]); i++)
2427 {
2428 sock = WSASocketA(0, 0, autoprotocols[i], NULL, 0, 0);
2429 ok(sock != INVALID_SOCKET, "Failed to create socket for protocol %d, received %d\n",
2430 autoprotocols[i], WSAGetLastError());
2431
2432 size = sizeof(socktype);
2433 socktype = 0xdead;
2434 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2435 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2436
2437 for (err = 1, j = 0; j < items; j++)
2438 {
2439 if (pi[j].iProtocol == autoprotocols[i])
2440 {
2441 if (socktype == pi[j].iSocketType)
2442 err = 0;
2443 else
2444 ok(0, "Wrong socket type, expected %d received %d\n",
2445 pi[j].iSocketType, socktype);
2446 break;
2447 }
2448 }
2449 ok(!err, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols[i]);
2450
2451 closesocket(sock);
2452 }
2453
2454 HeapFree(GetProcessHeap(), 0, pi);
2455
2456 SetLastError(0xdeadbeef);
2457 /* starting on vista the socket function returns error during the socket
2458 creation and no longer in the socket operations (sendto, readfrom) */
2459 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
2460 if (sock == INVALID_SOCKET)
2461 {
2462 err = WSAGetLastError();
2463 ok(err == WSAEACCES, "Expected 10013, received %d\n", err);
2464 skip("SOCK_RAW is not supported\n");
2465 }
2466 else
2467 {
2468 trace("SOCK_RAW is supported\n");
2469
2470 size = sizeof(socktype);
2471 socktype = 0xdead;
2472 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2473 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2474 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2475 SOCK_RAW, socktype);
2476 closesocket(sock);
2477
2478 todo_wine {
2479 sock = WSASocketA(0, 0, IPPROTO_RAW, NULL, 0, 0);
2480 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2481 WSAGetLastError());
2482 size = sizeof(socktype);
2483 socktype = 0xdead;
2484 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2485 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2486 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2487 SOCK_RAW, socktype);
2488 closesocket(sock);
2489 }
2490
2491 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_TCP, NULL, 0, 0);
2492 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2493 WSAGetLastError());
2494 size = sizeof(socktype);
2495 socktype = 0xdead;
2496 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2497 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2498 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2499 SOCK_RAW, socktype);
2500 closesocket(sock);
2501 }
2502
2503 /* IPX socket tests */
2504
2505 SetLastError(0xdeadbeef);
2506 sock = WSASocketA(AF_IPX, SOCK_DGRAM, NSPROTO_IPX, NULL, 0, 0);
2507 if (sock == INVALID_SOCKET)
2508 {
2509 err = WSAGetLastError();
2510 ok(err == WSAEAFNOSUPPORT || broken(err == WSAEPROTONOSUPPORT), "Expected 10047, received %d\n", err);
2511 skip("IPX is not supported\n");
2512 }
2513 else
2514 {
2515 WSAPROTOCOL_INFOA info;
2516 closesocket(sock);
2517
2518 trace("IPX is supported\n");
2519
2520 sock = WSASocketA(0, 0, NSPROTO_IPX, NULL, 0, 0);
2521 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2522 WSAGetLastError());
2523
2524 size = sizeof(socktype);
2525 socktype = 0xdead;
2526 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2527 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2528 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2529 SOCK_DGRAM, socktype);
2530
2531 /* check socket family, type and protocol */
2532 size = sizeof(WSAPROTOCOL_INFOA);
2533 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &info, &size);
2534 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2535 ok(info.iProtocol == NSPROTO_IPX, "expected protocol %d, received %d\n",
2536 NSPROTO_IPX, info.iProtocol);
2537 ok(info.iAddressFamily == AF_IPX, "expected family %d, received %d\n",
2538 AF_IPX, info.iProtocol);
2539 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2540 SOCK_DGRAM, info.iSocketType);
2541 closesocket(sock);
2542
2543 /* SOCK_STREAM does not support NSPROTO_IPX */
2544 SetLastError(0xdeadbeef);
2545 ok(WSASocketA(AF_IPX, SOCK_STREAM, NSPROTO_IPX, NULL, 0, 0) == INVALID_SOCKET,
2546 "WSASocketA should have failed\n");
2547 err = WSAGetLastError();
2548 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2549
2550 /* test extended IPX support - that is adding any number between 0 and 255
2551 * to the IPX protocol value will make it be used as IPX packet type */
2552 for(i = 0;i <= 255;i += 17)
2553 {
2554 SetLastError(0xdeadbeef);
2555 sock = WSASocketA(0, 0, NSPROTO_IPX + i, NULL, 0, 0);
2556 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2557 WSAGetLastError());
2558
2559 size = sizeof(int);
2560 socktype = -1;
2561 err = getsockopt(sock, NSPROTO_IPX, IPX_PTYPE, (char *) &socktype, &size);
2562 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2563 ok(socktype == i, "Wrong IPX packet type, expected %d received %d\n",
2564 i, socktype);
2565
2566 closesocket(sock);
2567 }
2568 }
2569 }
2570
2571 static void test_WSADuplicateSocket(void)
2572 {
2573 SOCKET source, dupsock;
2574 WSAPROTOCOL_INFOA info;
2575 DWORD err;
2576 struct sockaddr_in addr;
2577 int socktype, size, addrsize, ret;
2578 char teststr[] = "TEST", buffer[16];
2579
2580 source = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
2581 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2582
2583 /* test invalid parameters */
2584 SetLastError(0xdeadbeef);
2585 ok(WSADuplicateSocketA(0, 0, NULL), "WSADuplicateSocketA should have failed\n");
2586 err = WSAGetLastError();
2587 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2588
2589 SetLastError(0xdeadbeef);
2590 ok(WSADuplicateSocketA(source, 0, NULL),
2591 "WSADuplicateSocketA should have failed\n");
2592 err = WSAGetLastError();
2593 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2594
2595 SetLastError(0xdeadbeef);
2596 ok(WSADuplicateSocketA(source, ~0, &info),
2597 "WSADuplicateSocketA should have failed\n");
2598 err = WSAGetLastError();
2599 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2600
2601 SetLastError(0xdeadbeef);
2602 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info),
2603 "WSADuplicateSocketA should have failed\n");
2604 err = WSAGetLastError();
2605 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2606
2607 SetLastError(0xdeadbeef);
2608 ok(WSADuplicateSocketA(source, GetCurrentProcessId(), NULL),
2609 "WSADuplicateSocketA should have failed\n");
2610 err = WSAGetLastError();
2611 ok(err == WSAEFAULT, "expected 10014, received %d\n", err);
2612
2613 /* test returned structure */
2614 memset(&info, 0, sizeof(info));
2615 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2616 "WSADuplicateSocketA should have worked\n");
2617
2618 ok(info.iProtocol == IPPROTO_TCP, "expected protocol %d, received %d\n",
2619 IPPROTO_TCP, info.iProtocol);
2620 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2621 AF_INET, info.iProtocol);
2622 ok(info.iSocketType == SOCK_STREAM, "expected type %d, received %d\n",
2623 SOCK_STREAM, info.iSocketType);
2624
2625 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2626 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2627
2628 closesocket(dupsock);
2629 closesocket(source);
2630
2631 /* create a socket, bind it, duplicate it then send data on source and
2632 * receve in the duplicated socket */
2633 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2634 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2635
2636 memset(&info, 0, sizeof(info));
2637 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2638 "WSADuplicateSocketA should have worked\n");
2639
2640 ok(info.iProtocol == IPPROTO_UDP, "expected protocol %d, received %d\n",
2641 IPPROTO_UDP, info.iProtocol);
2642 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2643 AF_INET, info.iProtocol);
2644 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2645 SOCK_DGRAM, info.iSocketType);
2646
2647 memset(&addr, 0, sizeof(addr));
2648 addr.sin_family = AF_INET;
2649 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2650 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2651 "bind should have worked\n");
2652
2653 /* read address to find out the port number to be used in sendto */
2654 memset(&addr, 0, sizeof(addr));
2655 addrsize = sizeof(addr);
2656 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2657 "getsockname should have worked\n");
2658 ok(addr.sin_port, "socket port should be != 0\n");
2659
2660 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2661 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2662
2663 size = sizeof(int);
2664 ret = getsockopt(dupsock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2665 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
2666 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2667 SOCK_DGRAM, socktype);
2668
2669 set_blocking(source, TRUE);
2670
2671 /* send data on source socket */
2672 addrsize = sizeof(addr);
2673 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2674 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2675
2676 /* receive on duplicated socket */
2677 addrsize = sizeof(addr);
2678 memset(buffer, 0, sizeof(buffer));
2679 size = recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize);
2680 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2681 buffer[sizeof(teststr) - 1] = 0;
2682 ok(!strcmp(buffer, teststr), "expected '%s', received '%s'\n", teststr, buffer);
2683
2684 closesocket(dupsock);
2685 closesocket(source);
2686
2687 /* show that the source socket need to be bound before the duplicated
2688 * socket is created */
2689 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2690 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2691
2692 memset(&info, 0, sizeof(info));
2693 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2694 "WSADuplicateSocketA should have worked\n");
2695
2696 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2697 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2698
2699 memset(&addr, 0, sizeof(addr));
2700 addr.sin_family = AF_INET;
2701 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2702 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2703 "bind should have worked\n");
2704
2705 /* read address to find out the port number to be used in sendto */
2706 memset(&addr, 0, sizeof(addr));
2707 addrsize = sizeof(addr);
2708 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2709 "getsockname should have worked\n");
2710 ok(addr.sin_port, "socket port should be != 0\n");
2711
2712 set_blocking(source, TRUE);
2713
2714 addrsize = sizeof(addr);
2715 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2716 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2717
2718 SetLastError(0xdeadbeef);
2719 addrsize = sizeof(addr);
2720 memset(buffer, 0, sizeof(buffer));
2721 todo_wine {
2722 ok(recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize) == -1,
2723 "recvfrom should have failed\n");
2724 err = WSAGetLastError();
2725 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2726 }
2727
2728 closesocket(dupsock);
2729 closesocket(source);
2730 }
2731
2732 static void test_WSAEnumNetworkEvents(void)
2733 {
2734 SOCKET s, s2;
2735 int sock_type[] = {SOCK_STREAM, SOCK_DGRAM, SOCK_STREAM}, i, j, k, l;
2736 struct sockaddr_in address;
2737 HANDLE event;
2738 WSANETWORKEVENTS net_events;
2739 /* Windows 2000 Pro without SP installed (testbot) will crash if
2740 * WSAEnumNetworkEvents have a NULL event, so skip this test in <= 2000 */
2741 DWORD ver = GetVersion() & 0xFFFF;
2742 BOOL supports_null = ((ver & 0xFF) << 8 | (ver >> 8)) > 0x0500;
2743
2744 memset(&address, 0, sizeof(address));
2745 address.sin_addr.s_addr = htonl(INADDR_ANY);
2746 address.sin_family = AF_INET;
2747
2748 /* This test follows the steps from bugs 10204 and 24946 */
2749 for (l = 0; l < 2; l++)
2750 {
2751 if (l == 1 && !supports_null && broken(1)) continue;
2752
2753 for (i = 0; i < sizeof(sock_type) / sizeof(sock_type[0]); i++)
2754 {
2755 if (i == 2)
2756 ok(!tcp_socketpair(&s, &s2), "Test[%d]: creating socket pair failed\n", i);
2757 else
2758 {
2759 s = socket(AF_INET, sock_type[i], 0);
2760 ok (s != SOCKET_ERROR, "Test[%d]: failed to create socket\n", i);
2761 ok (!bind(s, (struct sockaddr*) &address, sizeof(address)), "Test[%d]: bind failed\n", i);
2762 }
2763 event = WSACreateEvent();
2764 ok (event != NULL, "Test[%d]: failed to create event\n", i);
2765 for (j = 0; j < 5; j++) /* Repeat sometimes and the result must be the same */
2766 {
2767 /* When the TCP socket is not connected NO events will be returned.
2768 * When connected and no data pending it will get the write event.
2769 * UDP sockets don't have connections so as soon as they are bound
2770 * they can read/write data. Since nobody is sendind us data only
2771 * the write event will be returned and ONLY once.
2772 */
2773 ok (!WSAEventSelect(s, event, FD_READ | FD_WRITE), "Test[%d]: WSAEventSelect failed\n", i);
2774 memset(&net_events, 0xAB, sizeof(net_events));
2775 ok (!WSAEnumNetworkEvents(s, l == 0 ? event : NULL, &net_events),
2776 "Test[%d]: WSAEnumNetworkEvents failed\n", i);
2777 if (i >= 1 && j == 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
2778 {
2779 if (i == 0) /* Remove when fixed */
2780 {
2781 todo_wine
2782 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %d\n",
2783 i, net_events.lNetworkEvents);
2784 }
2785 else
2786 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %d\n",
2787 i, net_events.lNetworkEvents);
2788 }
2789 else
2790 {
2791 if (i != 0) /* Remove when fixed */
2792 {
2793 todo_wine
2794 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %d\n",
2795 i, net_events.lNetworkEvents);
2796 }
2797 else
2798 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %d\n",
2799 i, net_events.lNetworkEvents);
2800 }
2801 for (k = 0; k < FD_MAX_EVENTS; k++)
2802 {
2803 if (i >= 1 && j == 0 && k == 1) /* first UDP and connected TCP test, FD_WRITE bit no error*/
2804 {
2805 ok (net_events.iErrorCode[k] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
2806 i, k, net_events.iErrorCode[k]);
2807 }
2808 else
2809 {
2810 /* Bits that are not set in lNetworkEvents MUST not be changed */
2811 todo_wine
2812 ok (net_events.iErrorCode[k] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
2813 i, k, net_events.iErrorCode[k]);
2814 }
2815 }
2816 }
2817 closesocket(s);
2818 WSACloseEvent(event);
2819 if (i == 2) closesocket(s2);
2820 }
2821 }
2822 }
2823
2824 static void test_WSAAddressToStringA(void)
2825 {
2826 SOCKET v6 = INVALID_SOCKET;
2827 INT ret;
2828 DWORD len;
2829 int GLE;
2830 SOCKADDR_IN sockaddr;
2831 CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2832
2833 CHAR expect1[] = "0.0.0.0";
2834 CHAR expect2[] = "255.255.255.255";
2835 CHAR expect3[] = "0.0.0.0:65535";
2836 CHAR expect4[] = "255.255.255.255:65535";
2837
2838 SOCKADDR_IN6 sockaddr6;
2839 CHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2840
2841 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2842 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2843 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2844
2845 CHAR expect6_1[] = "::1";
2846 CHAR expect6_2[] = "20ab::1";
2847 CHAR expect6_3[] = "[20ab::2001]:33274";
2848 CHAR expect6_3_nt[] = "20ab::2001@33274";
2849 CHAR expect6_3_w2k[] = "20ab::2001";
2850 CHAR expect6_3_2[] = "[20ab::2001%4660]:33274";
2851 CHAR expect6_3_2_nt[] = "4660/20ab::2001@33274";
2852 CHAR expect6_3_2_w2k[] = "20ab::2001%4660";
2853 CHAR expect6_3_3[] = "20ab::2001%4660";
2854 CHAR expect6_3_3_nt[] = "4660/20ab::2001";
2855
2856 len = 0;
2857
2858 sockaddr.sin_family = AF_INET;
2859 sockaddr.sin_port = 0;
2860 sockaddr.sin_addr.s_addr = 0;
2861
2862 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2863 GLE = WSAGetLastError();
2864 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
2865 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2866 GLE, ret );
2867
2868 len = sizeof(address);
2869
2870 sockaddr.sin_family = AF_INET;
2871 sockaddr.sin_port = 0;
2872 sockaddr.sin_addr.s_addr = 0;
2873
2874 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2875 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2876
2877 ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
2878 ok( len == sizeof( expect1 ), "Got size %d\n", len);
2879
2880 len = sizeof(address);
2881
2882 sockaddr.sin_family = AF_INET;
2883 sockaddr.sin_port = 0;
2884 sockaddr.sin_addr.s_addr = 0xffffffff;
2885
2886 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2887 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2888
2889 ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
2890
2891 len = sizeof(address);
2892
2893 sockaddr.sin_family = AF_INET;
2894 sockaddr.sin_port = 0xffff;
2895 sockaddr.sin_addr.s_addr = 0;
2896
2897 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2898 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2899
2900 ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
2901
2902 len = sizeof(address);
2903
2904 sockaddr.sin_family = AF_INET;
2905 sockaddr.sin_port = 0xffff;
2906 sockaddr.sin_addr.s_addr = 0xffffffff;
2907
2908 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2909 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2910
2911 ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
2912 ok( len == sizeof( expect4 ), "Got size %d\n", len);
2913
2914 /*check to see it IPv6 is available */
2915 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
2916 if (v6 == INVALID_SOCKET) {
2917 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2918 WSAGetLastError(), WSAEAFNOSUPPORT);
2919 goto end;
2920 }
2921 /* Test a short IPv6 address */
2922 len = sizeof(address6);
2923
2924 sockaddr6.sin6_family = AF_INET6;
2925 sockaddr6.sin6_port = 0x0000;
2926 sockaddr6.sin6_scope_id = 0;
2927 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
2928
2929 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2930 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2931 ok( !strcmp( address6, expect6_1 ), "Expected: %s, got: %s\n", expect6_1, address6 );
2932 ok( len == sizeof(expect6_1), "Got size %d\n", len);
2933
2934 /* Test a longer 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_2, sizeof(addr6_2));
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_2 ), "Expected: %s, got: %s\n", expect6_2, address6 );
2945 ok( len == sizeof(expect6_2), "Got size %d\n", len);
2946
2947 /* Test IPv6 address and port number */
2948 len = sizeof(address6);
2949
2950 sockaddr6.sin6_family = AF_INET6;
2951 sockaddr6.sin6_port = 0xfa81;
2952 sockaddr6.sin6_scope_id = 0;
2953 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
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_3 ) ||
2958 broken( !strcmp( address6, expect6_3_nt ) ) || /* NT4 */
2959 broken( !strcmp( address6, expect6_3_w2k ) ), /* Win2000 */
2960 "Expected: %s, got: %s\n", expect6_3, address6 );
2961 ok( len == sizeof(expect6_3) ||
2962 broken( len == sizeof(expect6_3_nt) ) || /* NT4 */
2963 broken( len == sizeof(expect6_3_w2k) ), /* Win2000 */
2964 "Got size %d\n", len);
2965
2966 /* Test IPv6 address, port number and scope_id */
2967 len = sizeof(address6);
2968
2969 sockaddr6.sin6_family = AF_INET6;
2970 sockaddr6.sin6_port = 0xfa81;
2971 sockaddr6.sin6_scope_id = 0x1234;
2972 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2973
2974 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2975 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2976 ok( !strcmp( address6, expect6_3_2 ) ||
2977 broken( !strcmp( address6, expect6_3_2_nt ) ) || /* NT4 */
2978 broken( !strcmp( address6, expect6_3_2_w2k ) ), /* Win2000 */
2979 "Expected: %s, got: %s\n", expect6_3_2, address6 );
2980 ok( len == sizeof(expect6_3_2) ||
2981 broken( len == sizeof(expect6_3_2_nt) ) || /* NT4 */
2982 broken( len == sizeof(expect6_3_2_w2k) ), /* Win2000 */
2983 "Got size %d\n", len);
2984
2985 /* Test IPv6 address and scope_id */
2986 len = sizeof(address6);
2987
2988 sockaddr6.sin6_family = AF_INET6;
2989 sockaddr6.sin6_port = 0x0000;
2990 sockaddr6.sin6_scope_id = 0x1234;
2991 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2992
2993 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2994 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2995 ok( !strcmp( address6, expect6_3_3 ) ||
2996 broken( !strcmp( address6, expect6_3_3_nt ) ), /* NT4 */
2997 "Expected: %s, got: %s\n", expect6_3_3, address6 );
2998 ok( len == sizeof(expect6_3_3) ||
2999 broken( len == sizeof(expect6_3_3_nt) ), /* NT4 */
3000 "Got size %d\n", len);
3001
3002 end:
3003 if (v6 != INVALID_SOCKET)
3004 closesocket(v6);
3005 }
3006
3007 static void test_WSAAddressToStringW(void)
3008 {
3009 SOCKET v6 = INVALID_SOCKET;
3010 INT ret;
3011 DWORD len;
3012 int GLE;
3013 SOCKADDR_IN sockaddr;
3014 WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
3015
3016 WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
3017 WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3018 WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
3019 WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3020 '6', '5', '5', '3', '5', 0 };
3021
3022 SOCKADDR_IN6 sockaddr6;
3023 WCHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
3024
3025 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3026 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3027 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
3028
3029 WCHAR expect6_1[] = {':',':','1',0};
3030 WCHAR expect6_2[] = {'2','0','a','b',':',':','1',0};
3031 WCHAR expect6_3[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
3032 WCHAR expect6_3_nt[] = {'2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
3033 WCHAR expect6_3_w2k[] = {'2','0','a','b',':',':','2','0','0','1',0};
3034 WCHAR expect6_3_2[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
3035 WCHAR expect6_3_2_nt[] = {'4','6','6','0','/','2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
3036 WCHAR expect6_3_2_w2k[] = {'2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',0};
3037 WCHAR expect6_3_3[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
3038 WCHAR expect6_3_3_nt[] = {'6','5','5','3','4','/','2','0','a','b',':',':','2','0','0','1',0};
3039
3040 len = 0;
3041
3042 sockaddr.sin_family = AF_INET;
3043 sockaddr.sin_port = 0;
3044 sockaddr.sin_addr.s_addr = 0;
3045
3046 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3047 GLE = WSAGetLastError();
3048 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
3049 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
3050 GLE, ret );
3051
3052 len = sizeof(address);
3053
3054 sockaddr.sin_family = AF_INET;
3055 sockaddr.sin_port = 0;
3056 sockaddr.sin_addr.s_addr = 0;
3057
3058 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3059 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3060
3061 ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
3062 ok( len == sizeof( expect1 )/sizeof( WCHAR ), "Got size %d\n", len);
3063
3064 len = sizeof(address);
3065
3066 sockaddr.sin_family = AF_INET;
3067 sockaddr.sin_port = 0;
3068 sockaddr.sin_addr.s_addr = 0xffffffff;
3069
3070 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3071 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3072
3073 ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
3074
3075 len = sizeof(address);
3076
3077 sockaddr.sin_family = AF_INET;
3078 sockaddr.sin_port = 0xffff;
3079 sockaddr.sin_addr.s_addr = 0;
3080
3081 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3082 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3083
3084 ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
3085
3086 len = sizeof(address);
3087
3088 sockaddr.sin_family = AF_INET;
3089 sockaddr.sin_port = 0xffff;
3090 sockaddr.sin_addr.s_addr = 0xffffffff;
3091
3092 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3093 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3094
3095 ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
3096 ok( len == sizeof( expect4 )/sizeof( WCHAR ), "Got %d\n", len);
3097
3098 /*check to see it IPv6 is available */
3099 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
3100 if (v6 == INVALID_SOCKET) {
3101 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3102 WSAGetLastError(), WSAEAFNOSUPPORT);
3103 goto end;
3104 }
3105
3106 /* Test a short IPv6 address */
3107 len = sizeof(address6)/sizeof(WCHAR);
3108
3109 sockaddr6.sin6_family = AF_INET6;
3110 sockaddr6.sin6_port = 0x0000;
3111 sockaddr6.sin6_scope_id = 0;
3112 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
3113
3114 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3115 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3116 ok( !lstrcmpW( address6, expect6_1 ), "Wrong string returned\n" );
3117 ok( len == sizeof(expect6_1)/sizeof(WCHAR), "Got %d\n", len);
3118
3119 /* Test a longer 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_2, sizeof(addr6_2));
3126
3127 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3128 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3129
3130 ok( !lstrcmpW( address6, expect6_2 ), "Wrong string returned\n" );
3131 ok( len == sizeof(expect6_2)/sizeof(WCHAR), "Got %d\n", len);
3132
3133 /* Test IPv6 address and port number */
3134 len = sizeof(address6)/sizeof(WCHAR);
3135
3136 sockaddr6.sin6_family = AF_INET6;
3137 sockaddr6.sin6_port = 0xfa81;
3138 sockaddr6.sin6_scope_id = 0;
3139 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3140
3141 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3142 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3143 ok( !lstrcmpW( address6, expect6_3 ) ||
3144 broken( !lstrcmpW( address6, expect6_3_nt ) ) || /* NT4 */
3145 broken( !lstrcmpW( address6, expect6_3_w2k ) ), /* Win2000 */
3146 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3),
3147 wine_dbgstr_w(address6) );
3148 ok( len == sizeof(expect6_3)/sizeof(WCHAR) ||
3149 broken(len == sizeof(expect6_3_nt)/sizeof(WCHAR) ) || /* NT4 */
3150 broken(len == sizeof(expect6_3_w2k)/sizeof(WCHAR) ), /* Win2000 */
3151 "Got %d\n", len);
3152
3153 /* Test IPv6 address, port number and scope_id */
3154 len = sizeof(address6)/sizeof(WCHAR);
3155
3156 sockaddr6.sin6_family = AF_INET6;
3157 sockaddr6.sin6_port = 0xfa81;
3158 sockaddr6.sin6_scope_id = 0x1234;
3159 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3160
3161 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3162 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3163 ok( !lstrcmpW( address6, expect6_3_2 ) ||
3164 broken( !lstrcmpW( address6, expect6_3_2_nt ) ) || /* NT4 */
3165 broken( !lstrcmpW( address6, expect6_3_2_w2k ) ), /* Win2000 */
3166 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2),
3167 wine_dbgstr_w(address6) );
3168 ok( len == sizeof(expect6_3_2)/sizeof(WCHAR) ||
3169 broken( len == sizeof(expect6_3_2_nt)/sizeof(WCHAR) ) || /* NT4 */
3170 broken( len == sizeof(expect6_3_2_w2k)/sizeof(WCHAR) ), /* Win2000 */
3171 "Got %d\n", len);
3172
3173 /* Test IPv6 address and scope_id */
3174 len = sizeof(address6)/sizeof(WCHAR);
3175
3176 sockaddr6.sin6_family = AF_INET6;
3177 sockaddr6.sin6_port = 0x0000;
3178 sockaddr6.sin6_scope_id = 0xfffe;
3179 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3180
3181 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3182 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3183 ok( !lstrcmpW( address6, expect6_3_3 ) ||
3184 broken( !lstrcmpW( address6, expect6_3_3_nt ) ), /* NT4 */
3185 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3),
3186 wine_dbgstr_w(address6) );
3187 ok( len == sizeof(expect6_3_3)/sizeof(WCHAR) ||
3188 broken( len == sizeof(expect6_3_3_nt)/sizeof(WCHAR) ), /* NT4 */
3189 "Got %d\n", len);
3190
3191 end:
3192 if (v6 != INVALID_SOCKET)
3193 closesocket(v6);
3194 }
3195
3196 static void test_WSAStringToAddressA(void)
3197 {
3198 INT ret, len;
3199 SOCKADDR_IN sockaddr;
3200 SOCKADDR_IN6 sockaddr6;
3201 int GLE;
3202
3203 CHAR address1[] = "0.0.0.0";
3204 CHAR address2[] = "127.127.127.127";
3205 CHAR address3[] = "255.255.255.255";
3206 CHAR address4[] = "127.127.127.127:65535";
3207 CHAR address5[] = "255.255.255.255:65535";
3208 CHAR address6[] = "::1";
3209 CHAR address7[] = "[::1]";
3210 CHAR address8[] = "[::1]:65535";
3211 CHAR address9[] = "2001::1";
3212
3213 len = 0;
3214 sockaddr.sin_family = AF_INET;
3215
3216 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3217 ok( ret == SOCKET_ERROR, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
3218 WSAGetLastError() );
3219
3220 len = sizeof(sockaddr);
3221 sockaddr.sin_port = 0;
3222 sockaddr.sin_addr.s_addr = 0;
3223
3224 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3225 ok( !ret && sockaddr.sin_addr.s_addr == 0,
3226 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3227
3228 len = sizeof(sockaddr);
3229 sockaddr.sin_port = 0;
3230 sockaddr.sin_addr.s_addr = 0;
3231
3232 ret = WSAStringToAddressA( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3233 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
3234 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3235
3236 len = sizeof(sockaddr);
3237 sockaddr.sin_port = 0;
3238 sockaddr.sin_addr.s_addr = 0;
3239
3240 ret = WSAStringToAddressA( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3241 GLE = WSAGetLastError();
3242 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
3243 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3244 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
3245
3246 len = sizeof(sockaddr);
3247 sockaddr.sin_port = 0;
3248 sockaddr.sin_addr.s_addr = 0;
3249
3250 ret = WSAStringToAddressA( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3251 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
3252 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3253
3254 len = sizeof(sockaddr);
3255 sockaddr.sin_port = 0;
3256 sockaddr.sin_addr.s_addr = 0;
3257
3258 ret = WSAStringToAddressA( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3259 GLE = WSAGetLastError();
3260 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
3261 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3262 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
3263
3264 len = sizeof(sockaddr6);
3265 memset(&sockaddr6, 0, len);
3266 sockaddr6.sin6_family = AF_INET6;
3267
3268 ret = WSAStringToAddressA( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3269 &len );
3270 GLE = WSAGetLastError();
3271 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3272 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3273
3274 len = sizeof(sockaddr6);
3275 memset(&sockaddr6, 0, len);
3276 sockaddr6.sin6_family = AF_INET6;
3277
3278 ret = WSAStringToAddressA( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3279 &len );
3280 GLE = WSAGetLastError();
3281 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3282 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3283
3284 len = sizeof(sockaddr6);
3285 memset(&sockaddr6, 0, len);
3286 sockaddr6.sin6_family = AF_INET6;
3287
3288 ret = WSAStringToAddressA( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3289 &len );
3290 GLE = WSAGetLastError();
3291 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
3292 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3293 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3294
3295 len = sizeof(sockaddr);
3296
3297 ret = WSAStringToAddressA( address9, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3298 GLE = WSAGetLastError();
3299 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3300 "WSAStringToAddressA() should have failed with %d\n", GLE );
3301 }
3302
3303 static void test_WSAStringToAddressW(void)
3304 {
3305 INT ret, len;
3306 SOCKADDR_IN sockaddr, *sin;
3307 SOCKADDR_IN6 sockaddr6;
3308 SOCKADDR_STORAGE sockaddr_storage;
3309 int GLE;
3310
3311 WCHAR address1[] = { '0','.','0','.','0','.','0', 0 };
3312 WCHAR address2[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
3313 WCHAR address3[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3314 WCHAR address4[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
3315 ':', '6', '5', '5', '3', '5', 0 };
3316 WCHAR address5[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3317 '6', '5', '5', '3', '5', 0 };
3318 WCHAR address6[] = {':',':','1','\0'};
3319 WCHAR address7[] = {'[',':',':','1',']','\0'};
3320 WCHAR address8[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
3321 WCHAR address9[] = {'2','0','0','1',':',':','1','\0'};
3322
3323 len = 0;
3324 sockaddr.sin_family = AF_INET;
3325
3326 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3327 ok( ret == SOCKET_ERROR, "WSAStringToAddressW() failed unexpectedly: %d\n",
3328 WSAGetLastError() );
3329
3330 len = sizeof(sockaddr);
3331 sockaddr.sin_port = 0;
3332 sockaddr.sin_addr.s_addr = 0;
3333
3334 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3335 ok( !ret && sockaddr.sin_addr.s_addr == 0,
3336 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3337
3338 len = sizeof(sockaddr);
3339 sockaddr.sin_port = 0;
3340 sockaddr.sin_addr.s_addr = 0;
3341
3342 ret = WSAStringToAddressW( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3343 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
3344 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3345
3346 len = sizeof(sockaddr);
3347 sockaddr.sin_port = 0;
3348 sockaddr.sin_addr.s_addr = 0;
3349
3350 ret = WSAStringToAddressW( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3351 GLE = WSAGetLastError();
3352 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
3353 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3354 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3355
3356 len = sizeof(sockaddr);
3357 sockaddr.sin_port = 0;
3358 sockaddr.sin_addr.s_addr = 0;
3359
3360 ret = WSAStringToAddressW( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3361 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
3362 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3363
3364 len = sizeof(sockaddr);
3365 sockaddr.sin_port = 0;
3366 sockaddr.sin_addr.s_addr = 0;
3367
3368 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3369 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
3370 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3371 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3372
3373 /* Test with a larger buffer than necessary */
3374 len = sizeof(sockaddr_storage);
3375 sin = (SOCKADDR_IN *)&sockaddr_storage;
3376 sin->sin_port = 0;
3377 sin->sin_addr.s_addr = 0;
3378
3379 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)sin, &len );
3380 ok( (ret == 0 && sin->sin_addr.s_addr == 0xffffffff && sin->sin_port == 0xffff) ||
3381 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3382 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3383 ok( len == sizeof(SOCKADDR_IN) ||
3384 broken(len == sizeof(SOCKADDR_STORAGE)) /* NT4/2k */,
3385 "unexpected length %d\n", len );
3386
3387 len = sizeof(sockaddr6);
3388 memset(&sockaddr6, 0, len);
3389 sockaddr6.sin6_family = AF_INET6;
3390
3391 ret = WSAStringToAddressW( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3392 &len );
3393 GLE = WSAGetLastError();
3394 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3395 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3396
3397 len = sizeof(sockaddr6);
3398 memset(&sockaddr6, 0, len);
3399 sockaddr6.sin6_family = AF_INET6;
3400
3401 ret = WSAStringToAddressW( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3402 &len );
3403 GLE = WSAGetLastError();
3404 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3405 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3406
3407 len = sizeof(sockaddr6);
3408 memset(&sockaddr6, 0, len);
3409 sockaddr6.sin6_family = AF_INET6;
3410
3411 ret = WSAStringToAddressW( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3412 &len );
3413 GLE = WSAGetLastError();
3414 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
3415 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3416 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3417
3418 len = sizeof(sockaddr);
3419
3420 ret = WSAStringToAddressW( address9, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3421 GLE = WSAGetLastError();
3422 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3423 "WSAStringToAddressW() should have failed with %d\n", GLE );
3424 }
3425
3426 static DWORD WINAPI SelectReadThread(void *param)
3427 {
3428 select_thread_params *par = param;
3429 fd_set readfds;
3430 int ret;
3431 struct sockaddr_in addr;
3432 struct timeval select_timeout;
3433
3434 FD_ZERO(&readfds);
3435 FD_SET(par->s, &readfds);
3436 select_timeout.tv_sec=5;
3437 select_timeout.tv_usec=0;
3438 addr.sin_family = AF_INET;
3439 addr.sin_addr.s_addr = inet_addr(SERVERIP);
3440 addr.sin_port = htons(SERVERPORT);
3441
3442 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
3443 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
3444
3445 SetEvent(server_ready);
3446 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
3447 par->ReadKilled = (ret == 1);
3448
3449 return 0;
3450 }
3451
3452 static DWORD WINAPI SelectCloseThread(void *param)
3453 {
3454 SOCKET s = *(SOCKET*)param;
3455 Sleep(500);
3456 closesocket(s);
3457 return 0;
3458 }
3459
3460 static void test_errors(void)
3461 {
3462 SOCKET sock;
3463 SOCKADDR_IN SockAddr;
3464 int ret, err;
3465
3466 WSASetLastError(NO_ERROR);
3467 sock = socket(PF_INET, SOCK_STREAM, 0);
3468 ok( (sock != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3469 memset(&SockAddr, 0, sizeof(SockAddr));
3470 SockAddr.sin_family = AF_INET;
3471 SockAddr.sin_port = htons(6924);
3472 SockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
3473
3474 ret = connect(sock, (PSOCKADDR)&SockAddr, sizeof(SockAddr));
3475 ok( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got: %d\n", ret );
3476 if (ret == SOCKET_ERROR)
3477 {
3478 err = WSAGetLastError();
3479 ok( (err == WSAECONNREFUSED), "expected WSAECONNREFUSED, got: %d\n", err );
3480 }
3481
3482 {
3483 TIMEVAL timeval;
3484 fd_set set = {1, {sock}};
3485
3486 timeval.tv_sec = 0;
3487 timeval.tv_usec = 50000;
3488
3489 ret = select(1, NULL, &set, NULL, &timeval);
3490 ok( (ret == 0), "expected 0 (timeout), got: %d\n", ret );
3491 }
3492
3493 ret = closesocket(sock);
3494 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3495 }
3496
3497 static void test_listen(void)
3498 {
3499 SOCKET fdA, fdB;
3500 int ret, acceptc, olen = sizeof(acceptc);
3501 struct sockaddr_in address;
3502
3503 memset(&address, 0, sizeof(address));
3504 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3505 address.sin_family = AF_INET;
3506 address.sin_port = htons(SERVERPORT);
3507
3508 /* invalid socket tests */
3509 SetLastError(0xdeadbeef);
3510 ok ((listen(0, 0) == SOCKET_ERROR), "listen did not fail\n");
3511 ret = WSAGetLastError();
3512 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3513
3514 SetLastError(0xdeadbeef);
3515 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR), "listen did not fail\n");
3516 ret = WSAGetLastError();
3517 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3518
3519 /* tcp tests */
3520 fdA = socket(AF_INET, SOCK_STREAM, 0);
3521 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3522
3523 fdB = socket(AF_INET, SOCK_STREAM, 0);
3524 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3525
3526 SetLastError(0xdeadbeef);
3527 ok ((listen(fdA, -2) == SOCKET_ERROR), "listen did not fail\n");
3528 ret = WSAGetLastError();
3529 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3530
3531 SetLastError(0xdeadbeef);
3532 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
3533 ret = WSAGetLastError();
3534 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3535
3536 SetLastError(0xdeadbeef);
3537 ok ((listen(fdA, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3538 ret = WSAGetLastError();
3539 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3540
3541 ok (!bind(fdA, (struct sockaddr*) &address, sizeof(address)), "bind failed\n");
3542
3543 SetLastError(0xdeadbeef);
3544 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3545 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3546
3547 acceptc = 0xdead;
3548 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3549 ok (!ret, "getsockopt failed\n");
3550 ok (acceptc == 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc);
3551
3552 ok (!listen(fdA, 0), "listen failed\n");
3553 ok (!listen(fdA, SOMAXCONN), "double listen failed\n");
3554
3555 acceptc = 0xdead;
3556 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3557 ok (!ret, "getsockopt failed\n");
3558 ok (acceptc == 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc);
3559
3560 SetLastError(0xdeadbeef);
3561 ok ((listen(fdB, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3562 ret = WSAGetLastError();
3563 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3564
3565 ret = closesocket(fdB);
3566 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3567
3568 fdB = socket(AF_INET, SOCK_STREAM, 0);
3569 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3570
3571 SetLastError(0xdeadbeef);
3572 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3573 ret = WSAGetLastError();
3574 ok (ret == WSAEADDRINUSE, "expected 10048, received %d\n", ret);
3575
3576 ret = closesocket(fdA);
3577 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3578 ret = closesocket(fdB);
3579 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3580 }
3581
3582 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
3583 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
3584 static void test_select(void)
3585 {
3586 static char tmp_buf[1024];
3587
3588 SOCKET fdListen, fdRead, fdWrite;
3589 fd_set readfds, writefds, exceptfds;
3590 unsigned int maxfd;
3591 int ret, len;
3592 char buffer;
3593 struct timeval select_timeout;
3594 struct sockaddr_in address;
3595 select_thread_params thread_params;
3596 HANDLE thread_handle;
3597 DWORD ticks, id;
3598
3599 fdRead = socket(AF_INET, SOCK_STREAM, 0);
3600 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3601 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
3602 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3603
3604 maxfd = fdRead;
3605 if (fdWrite > maxfd)
3606 maxfd = fdWrite;
3607
3608 FD_ZERO_ALL();
3609 FD_SET_ALL(fdRead);
3610 FD_SET_ALL(fdWrite);
3611 select_timeout.tv_sec=0;
3612 select_timeout.tv_usec=0;
3613
3614 ticks = GetTickCount();
3615 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3616 ticks = GetTickCount() - ticks;
3617 ok(ret == 0, "select should not return any socket handles\n");
3618 ok(ticks < 10, "select was blocking for %u ms, expected < 10 ms\n", ticks);
3619 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3620 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3621 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3622 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3623
3624 FD_ZERO_ALL();
3625 FD_SET_ALL(fdRead);
3626 FD_SET_ALL(fdWrite);
3627 select_timeout.tv_sec=0;
3628 select_timeout.tv_usec=500;
3629
3630 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3631 ok(ret == 0, "select should not return any socket handles\n");
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 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3638 ret = closesocket(fdWrite);
3639 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3640
3641 thread_params.s = fdRead;
3642 thread_params.ReadKilled = FALSE;
3643 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
3644 thread_handle = CreateThread (NULL, 0, SelectReadThread, &thread_params, 0, &id );
3645 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
3646
3647 WaitForSingleObject (server_ready, INFINITE);
3648 Sleep(200);
3649 ret = closesocket(fdRead);
3650 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3651
3652 WaitForSingleObject (thread_handle, 1000);
3653 ok ( (thread_params.ReadKilled) ||
3654 broken(thread_params.ReadKilled == 0), /*Win98*/
3655 "closesocket did not wakeup select\n");
3656 ret = recv(fdRead, &buffer, 1, MSG_PEEK);
3657 ok( (ret == -1), "peek at closed socket expected -1 got %d\n", ret);
3658
3659 /* Test selecting invalid handles */
3660 FD_ZERO_ALL();
3661
3662 SetLastError(0);
3663 ret = select(maxfd+1, 0, 0, 0, &select_timeout);
3664 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3665 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3666
3667 SetLastError(0);
3668 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3669 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3670 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3671
3672 FD_SET(INVALID_SOCKET, &readfds);
3673 SetLastError(0);
3674 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3675 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3676 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3677 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3678
3679 FD_ZERO(&readfds);
3680 FD_SET(INVALID_SOCKET, &writefds);
3681 SetLastError(0);
3682 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3683 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3684 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3685 ok ( !FD_ISSET(fdRead, &writefds), "FD should not be set\n");
3686
3687 FD_ZERO(&writefds);
3688 FD_SET(INVALID_SOCKET, &exceptfds);
3689 SetLastError(0);
3690 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3691 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3692 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3693 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3694
3695 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3696 maxfd = fdRead;
3697 if(fdWrite > maxfd) maxfd = fdWrite;
3698
3699 FD_ZERO(&readfds);
3700 FD_SET(fdRead, &readfds);
3701 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3702 ok(!ret, "select returned %d\n", ret);
3703
3704 FD_ZERO(&writefds);
3705 FD_SET(fdWrite, &writefds);
3706 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3707 ok(ret == 1, "select returned %d\n", ret);
3708 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3709
3710 /* tests for overlapping fd_set pointers */
3711 FD_ZERO(&readfds);
3712 FD_SET(fdWrite, &readfds);
3713 ret = select(fdWrite+1, &readfds, &readfds, NULL, &select_timeout);
3714 ok(ret == 1, "select returned %d\n", ret);
3715 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3716
3717 FD_ZERO(&readfds);
3718 FD_SET(fdWrite, &readfds);
3719 FD_SET(fdRead, &readfds);
3720 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3721 ok(ret == 2, "select returned %d\n", ret);
3722 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3723 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3724
3725 ok(send(fdWrite, "test", 4, 0) == 4, "failed to send data\n");
3726 FD_ZERO(&readfds);
3727 FD_SET(fdRead, &readfds);
3728 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3729 ok(ret == 1, "select returned %d\n", ret);
3730 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3731
3732 FD_ZERO(&readfds);
3733 FD_SET(fdWrite, &readfds);
3734 FD_SET(fdRead, &readfds);
3735 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3736 ok(ret == 2, "select returned %d\n", ret);
3737 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3738 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3739
3740 while(1) {
3741 FD_ZERO(&writefds);
3742 FD_SET(fdWrite, &writefds);
3743 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3744 if(!ret) break;
3745 ok(send(fdWrite, tmp_buf, sizeof(tmp_buf), 0) > 0, "failed to send data\n");
3746 }
3747 FD_ZERO(&readfds);
3748 FD_SET(fdWrite, &readfds);
3749 FD_SET(fdRead, &readfds);
3750 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3751 ok(ret == 1, "select returned %d\n", ret);
3752 ok(!FD_ISSET(fdWrite, &readfds), "fdWrite socket is in the set\n");
3753 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3754
3755 ok(send(fdRead, "test", 4, 0) == 4, "failed to send data\n");
3756 Sleep(100);
3757 FD_ZERO(&readfds);
3758 FD_SET(fdWrite, &readfds);
3759 FD_SET(fdRead, &readfds);
3760 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3761 ok(ret == 2, "select returned %d\n", ret);
3762 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3763 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3764
3765 closesocket(fdRead);
3766 closesocket(fdWrite);
3767
3768 /* select() works in 3 distinct states:
3769 * - to check if a connection attempt ended with success or error;
3770 * - to check if a pending connection is waiting for acceptance;
3771 * - to check for data to read, availability for write and OOB data
3772 *
3773 * The tests below ensure that all conditions are tested.
3774 */
3775 memset(&address, 0, sizeof(address));
3776 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3777 address.sin_family = AF_INET;
3778 len = sizeof(address);
3779 fdListen = setup_server_socket(&address, &len);
3780 select_timeout.tv_sec = 1;
3781 select_timeout.tv_usec = 250000;
3782
3783 /* When no events are pending select returns 0 with no error */
3784 FD_ZERO_ALL();
3785 FD_SET_ALL(fdListen);
3786 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3787 ok(ret == 0, "expected 0, got %d\n", ret);
3788
3789 /* When a socket is attempting to connect the listening socket receives the read descriptor */
3790 fdWrite = setup_connector_socket(&address, len, TRUE);
3791 FD_ZERO_ALL();
3792 FD_SET_ALL(fdListen);
3793 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3794 ok(ret == 1, "expected 1, got %d\n", ret);
3795 ok(FD_ISSET(fdListen, &readfds), "fdListen socket is not in the set\n");
3796 len = sizeof(address);
3797 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
3798 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
3799
3800 /* The connector is signaled through the write descriptor */
3801 FD_ZERO_ALL();
3802 FD_SET_ALL(fdListen);
3803 FD_SET_ALL(fdRead);
3804 FD_SET_ALL(fdWrite);
3805 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3806 ok(ret == 2, "expected 2, got %d\n", ret);
3807 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3808 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
3809 len = sizeof(id);
3810 id = 0xdeadbeef;
3811 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
3812 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3813 ok(id == 0, "expected 0, got %d\n", id);
3814
3815 /* When data is received the receiver gets the read descriptor */
3816 ret = send(fdWrite, "1234", 4, 0);
3817 ok(ret == 4, "expected 4, got %d\n", ret);
3818 FD_ZERO_ALL();
3819 FD_SET_ALL(fdListen);
3820 FD_SET(fdRead, &readfds);
3821 FD_SET(fdRead, &exceptfds);
3822 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3823 ok(ret == 1, "expected 1, got %d\n", ret);
3824 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3825 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
3826 ok(ret == 4, "expected 4, got %d\n", ret);
3827 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
3828
3829 /* When OOB data is received the socket is set in the except descriptor */
3830 ret = send(fdWrite, "A", 1, MSG_OOB);
3831 ok(ret == 1, "expected 1, got %d\n", ret);
3832 FD_ZERO_ALL();
3833 FD_SET_ALL(fdListen);
3834 FD_SET(fdRead, &readfds);
3835 FD_SET(fdRead, &exceptfds);
3836 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3837 ok(ret == 1, "expected 1, got %d\n", ret);
3838 ok(FD_ISSET(fdRead, &exceptfds), "fdRead socket is not in the set\n");
3839 tmp_buf[0] = 0xAF;
3840 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
3841 ok(ret == 1, "expected 1, got %d\n", ret);
3842 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
3843
3844 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
3845 ret = 1;
3846 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
3847 ok(ret == 0, "expected 0, got %d\n", ret);
3848 ret = send(fdWrite, "A", 1, MSG_OOB);
3849 ok(ret == 1, "expected 1, got %d\n", ret);
3850 FD_ZERO_ALL();
3851 FD_SET_ALL(fdListen);
3852 FD_SET(fdRead, &readfds);
3853 FD_SET(fdRead, &exceptfds);
3854 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3855 ok(ret == 1, "expected 1, got %d\n", ret);
3856 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3857 tmp_buf[0] = 0xAF;
3858 SetLastError(0xdeadbeef);
3859 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
3860 if (ret == SOCKET_ERROR) /* can't recv with MSG_OOB if OOBINLINED */
3861 {
3862 ok(GetLastError() == WSAEINVAL, "expected 10022, got %d\n", GetLastError());
3863 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
3864 ok(ret == 1, "expected 1, got %d\n", ret);
3865 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
3866 }
3867 else ok(broken(ret == 1) /* <= NT4 */, "expected error, got 1\n");
3868
3869 /* When the connection is closed the socket is set in the read descriptor */
3870 ret = closesocket(fdRead);
3871 ok(ret == 0, "expected 0, got %d\n", ret);
3872 FD_ZERO_ALL();
3873 FD_SET_ALL(fdListen);
3874 FD_SET(fdWrite, &readfds);
3875 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3876 ok(ret == 1, "expected 1, got %d\n", ret);
3877 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3878 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
3879 ok(ret == 0, "expected 0, got %d\n", ret);
3880
3881 /* When a connection is attempted to a non-listening socket it will get to the except descriptor */
3882 ret = closesocket(fdWrite);
3883 ok(ret == 0, "expected 0, got %d\n", ret);
3884 ret = closesocket(fdListen);
3885 ok(ret == 0, "expected 0, got %d\n", ret);
3886 len = sizeof(address);
3887 fdWrite = setup_connector_socket(&address, len, TRUE);
3888 FD_ZERO_ALL();
3889 FD_SET(fdWrite, &writefds);
3890 FD_SET(fdWrite, &exceptfds);
3891 select_timeout.tv_sec = 2; /* requires more time to realize it will not connect */
3892 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3893 ok(ret == 1, "expected 1, got %d\n", ret);
3894 len = sizeof(id);
3895 id = 0xdeadbeef;
3896 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
3897 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3898 ok(id == WSAECONNREFUSED, "expected 10061, got %d\n", id);
3899 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
3900 ok(select_timeout.tv_usec == 250000, "select timeout should not have changed\n");
3901 closesocket(fdWrite);
3902
3903 /* Try select() on a closed socket after connection */
3904 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3905 closesocket(fdRead);
3906 FD_ZERO_ALL();
3907 FD_SET_ALL(fdWrite);
3908 FD_SET_ALL(fdRead);
3909 SetLastError(0xdeadbeef);
3910 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
3911 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
3912 todo_wine
3913 ok(GetLastError() == WSAENOTSOCK, "expected 10038, got %d\n", GetLastError());
3914 /* descriptor sets are unchanged */
3915 ok(readfds.fd_count == 2, "expected 2, got %d\n", readfds.fd_count);
3916 ok(exceptfds.fd_count == 2, "expected 2, got %d\n", exceptfds.fd_count);
3917 closesocket(fdWrite);
3918
3919 /* Close the socket currently being selected in a thread - bug 38399 */
3920 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3921 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
3922 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
3923 FD_ZERO_ALL();
3924 FD_SET_ALL(fdWrite);
3925 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
3926 ok(ret == 1, "expected 1, got %d\n", ret);
3927 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3928 WaitForSingleObject (thread_handle, 1000);
3929 closesocket(fdRead);
3930 /* test again with only the except descriptor */
3931 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3932 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
3933 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
3934 FD_ZERO_ALL();
3935 FD_SET(fdWrite, &exceptfds);
3936 SetLastError(0xdeadbeef);
3937 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
3938 todo_wine
3939 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
3940 todo_wine
3941 ok(GetLastError() == WSAENOTSOCK, "expected 10038, got %d\n", GetLastError());
3942 WaitForSingleObject (thread_handle, 1000);
3943 closesocket(fdRead);
3944
3945 /* test UDP behavior of unbound sockets */
3946 select_timeout.tv_sec = 0;
3947 select_timeout.tv_usec = 250000;
3948 fdWrite = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
3949 ok(fdWrite != INVALID_SOCKET, "socket call failed\n");
3950 FD_ZERO_ALL();
3951 FD_SET_ALL(fdWrite);
3952 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3953 ok(ret == 1, "expected 1, got %d\n", ret);
3954 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3955 closesocket(fdWrite);
3956 }
3957 #undef FD_SET_ALL
3958 #undef FD_ZERO_ALL
3959
3960 static DWORD WINAPI AcceptKillThread(void *param)
3961 {
3962 select_thread_params *par = param;
3963 struct sockaddr_in address;
3964 int len = sizeof(address);
3965 SOCKET client_socket;
3966
3967 SetEvent(server_ready);
3968 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
3969 if (client_socket != INVALID_SOCKET)
3970 closesocket(client_socket);
3971 par->ReadKilled = (client_socket == INVALID_SOCKET);
3972 return 0;
3973 }
3974
3975
3976 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
3977 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
3978 GROUP *g, DWORD_PTR dwCallbackData)
3979 {
3980 return CF_DEFER;
3981 }
3982
3983 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len)
3984 {
3985 int ret, val;
3986 SOCKET server_socket;
3987
3988 server_socket = socket(AF_INET, SOCK_STREAM, 0);
3989 if (server_socket == INVALID_SOCKET)
3990 {
3991 trace("error creating server socket: %d\n", WSAGetLastError());
3992 return INVALID_SOCKET;
3993 }
3994
3995 val = 1;
3996 ret = setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
3997 if (ret)
3998 {
3999 trace("error setting SO_REUSEADDR: %d\n", WSAGetLastError());
4000 closesocket(server_socket);
4001 return INVALID_SOCKET;
4002 }
4003
4004 ret = bind(server_socket, (struct sockaddr *)addr, *len);
4005 if (ret)
4006 {
4007 trace("error binding server socket: %d\n", WSAGetLastError());
4008 }
4009
4010 ret = getsockname(server_socket, (struct sockaddr *)addr, len);
4011 if (ret)
4012 {
4013 skip("failed to lookup bind address: %d\n", WSAGetLastError());
4014 closesocket(server_socket);
4015 return INVALID_SOCKET;
4016 }
4017
4018 ret = listen(server_socket, 5);
4019 if (ret)
4020 {
4021 trace("error making server socket listen: %d\n", WSAGetLastError());
4022 closesocket(server_socket);
4023 return INVALID_SOCKET;
4024 }
4025
4026 return server_socket;
4027 }
4028
4029 static SOCKET setup_connector_socket(struct sockaddr_in *addr, int len, BOOL nonblock)
4030 {
4031 int ret;
4032 SOCKET connector;
4033
4034 connector = socket(AF_INET, SOCK_STREAM, 0);
4035 ok(connector != INVALID_SOCKET, "failed to create connector socket %d\n", WSAGetLastError());
4036
4037 if (nonblock)
4038 set_blocking(connector, !nonblock);
4039
4040 ret = connect(connector, (struct sockaddr *)addr, len);
4041 if (!nonblock)
4042 ok(!ret, "connecting to accepting socket failed %d\n", WSAGetLastError());
4043 else if (ret == SOCKET_ERROR)
4044 {
4045 DWORD error = WSAGetLastError();
4046 ok(error == WSAEWOULDBLOCK || error == WSAEINPROGRESS,
4047 "expected 10035 or 10036, got %d\n", error);
4048 }
4049
4050 return connector;
4051 }
4052
4053 static void test_accept(void)
4054 {
4055 int ret;
4056 SOCKET server_socket, accepted = INVALID_SOCKET, connector;
4057 struct sockaddr_in address;
4058 SOCKADDR_STORAGE ss;
4059 int socklen;
4060 select_thread_params thread_params;
4061 HANDLE thread_handle = NULL;
4062 DWORD id;
4063
4064 memset(&address, 0, sizeof(address));
4065 address.sin_addr.s_addr = inet_addr("127.0.0.1");
4066 address.sin_family = AF_INET;
4067
4068 socklen = sizeof(address);
4069 server_socket = setup_server_socket(&address, &socklen);
4070 if (server_socket == INVALID_SOCKET)
4071 {
4072 trace("error creating server socket: %d\n", WSAGetLastError());
4073 return;
4074 }
4075
4076 connector = setup_connector_socket(&address, socklen, FALSE);
4077 if (connector == INVALID_SOCKET) goto done;
4078
4079 trace("Blocking accept next\n");
4080
4081 accepted = WSAAccept(server_socket, NULL, NULL, AlwaysDeferConditionFunc, 0);
4082 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
4083
4084 accepted = accept(server_socket, NULL, 0);
4085 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
4086
4087 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
4088 if (server_ready == INVALID_HANDLE_VALUE)
4089 {
4090 trace("error creating event: %d\n", GetLastError());
4091 goto done;
4092 }
4093
4094 thread_params.s = server_socket;
4095 thread_params.ReadKilled = FALSE;
4096 thread_handle = CreateThread(NULL, 0, AcceptKillThread, &thread_params, 0, &id);
4097 if (thread_handle == NULL)
4098 {
4099 trace("error creating thread: %d\n", GetLastError());
4100 goto done;
4101 }
4102
4103 WaitForSingleObject(server_ready, INFINITE);
4104 Sleep(200);
4105 ret = closesocket(server_socket);
4106 if (ret != 0)
4107 {
4108 trace("closesocket failed: %d\n", WSAGetLastError());
4109 goto done;
4110 }
4111
4112 WaitForSingleObject(thread_handle, 1000);
4113 ok(thread_params.ReadKilled || broken(!thread_params.ReadKilled) /* Win98/ME, after accept */,
4114 "closesocket did not wakeup accept\n");
4115
4116 closesocket(accepted);
4117 closesocket(connector);
4118 accepted = connector = INVALID_SOCKET;
4119
4120 socklen = sizeof(address);
4121 server_socket = setup_server_socket(&address, &socklen);
4122 if (server_socket == INVALID_SOCKET) goto done;
4123
4124 connector = setup_connector_socket(&address, socklen, FALSE);
4125 if (connector == INVALID_SOCKET) goto done;
4126
4127 socklen = 0;
4128 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4129 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4130 ok(!socklen, "got %d\n", socklen);
4131 closesocket(connector);
4132 connector = INVALID_SOCKET;
4133
4134 socklen = sizeof(address);
4135 connector = setup_connector_socket(&address, socklen, FALSE);
4136 if (connector == INVALID_SOCKET) goto done;
4137
4138 accepted = WSAAccept(server_socket, NULL, NULL, NULL, 0);
4139 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4140 closesocket(accepted);
4141 closesocket(connector);
4142 accepted = connector = INVALID_SOCKET;
4143
4144 socklen = sizeof(address);
4145 connector = setup_connector_socket(&address, socklen, FALSE);
4146 if (connector == INVALID_SOCKET) goto done;
4147
4148 socklen = sizeof(ss);
4149 memset(&ss, 0, sizeof(ss));
4150 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4151 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4152 ok(socklen != sizeof(ss), "unexpected length\n");
4153 ok(ss.ss_family, "family not set\n");
4154 closesocket(accepted);
4155 closesocket(connector);
4156 accepted = connector = INVALID_SOCKET;
4157
4158 socklen = sizeof(address);
4159 connector = setup_connector_socket(&address, socklen, FALSE);
4160 if (connector == INVALID_SOCKET) goto done;
4161
4162 socklen = 0;
4163 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4164 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4165 ok(!socklen, "got %d\n", socklen);
4166 closesocket(connector);
4167 accepted = connector = INVALID_SOCKET;
4168
4169 socklen = sizeof(address);
4170 connector = setup_connector_socket(&address, socklen, FALSE);
4171 if (connector == INVALID_SOCKET) goto done;
4172
4173 accepted = accept(server_socket, NULL, NULL);
4174 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4175 closesocket(accepted);
4176 closesocket(connector);
4177 accepted = connector = INVALID_SOCKET;
4178
4179 socklen = sizeof(address);
4180 connector = setup_connector_socket(&address, socklen, FALSE);
4181 if (connector == INVALID_SOCKET) goto done;
4182
4183 socklen = sizeof(ss);
4184 memset(&ss, 0, sizeof(ss));
4185 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4186 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4187 ok(socklen != sizeof(ss), "unexpected length\n");
4188 ok(ss.ss_family, "family not set\n");
4189
4190 done:
4191 if (accepted != INVALID_SOCKET)
4192 closesocket(accepted);
4193 if (connector != INVALID_SOCKET)
4194 closesocket(connector);
4195 if (thread_handle != NULL)
4196 CloseHandle(thread_handle);
4197 if (server_ready != INVALID_HANDLE_VALUE)
4198 CloseHandle(server_ready);
4199 if (server_socket != INVALID_SOCKET)
4200 closesocket(server_socket);
4201 }
4202
4203 static void test_extendedSocketOptions(void)
4204 {
4205 WSADATA wsa;
4206 SOCKET sock;
4207 struct sockaddr_in sa;
4208 int sa_len = sizeof(struct sockaddr_in);
4209 int optval, optlen = sizeof(int), ret;
4210 BOOL bool_opt_val;
4211 LINGER linger_val;
4212
4213 if(WSAStartup(MAKEWORD(2,0), &wsa)){
4214 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4215 return;
4216 }
4217
4218 memset(&sa, 0, sa_len);
4219
4220 sa.sin_family = AF_INET;
4221 sa.sin_port = htons(0);
4222 sa.sin_addr.s_addr = htonl(INADDR_ANY);
4223
4224 if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) == INVALID_SOCKET) {
4225 trace("Creating the socket failed: %d\n", WSAGetLastError());
4226 WSACleanup();
4227 return;
4228 }
4229
4230 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
4231 trace("Failed to bind socket: %d\n", WSAGetLastError());
4232 closesocket(sock);
4233 WSACleanup();
4234 return;
4235 }
4236
4237 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4238
4239 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
4240 ok((optval == 65507) || (optval == 65527),
4241 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
4242
4243 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
4244 SetLastError(0xdeadbeef);
4245 optval = 0xdeadbeef;
4246 optlen = sizeof(int);
4247 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4248 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4249 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4250 ret, WSAGetLastError(), optval, optval);
4251
4252 /* more invalid values for level */
4253 SetLastError(0xdeadbeef);
4254 optval = 0xdeadbeef;
4255 optlen = sizeof(int);
4256 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4257 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4258 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4259 ret, WSAGetLastError(), optval, optval);
4260
4261 SetLastError(0xdeadbeef);
4262 optval = 0xdeadbeef;
4263 optlen = sizeof(int);
4264 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4265 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4266 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4267 ret, WSAGetLastError(), optval, optval);
4268
4269 SetLastError(0xdeadbeef);
4270 optval = 0xdeadbeef;
4271 optlen = sizeof(int);
4272 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4273 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4274 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4275 ret, WSAGetLastError(), optval, optval);
4276
4277 SetLastError(0xdeadbeef);
4278 optval = 0xdeadbeef;
4279 optlen = sizeof(int);
4280 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4281 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4282 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4283 ret, WSAGetLastError(), optval, optval);
4284
4285 SetLastError(0xdeadbeef);
4286 optlen = sizeof(LINGER);
4287 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4288 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAENOPROTOOPT),
4289 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
4290 ret, WSAGetLastError());
4291 closesocket(sock);
4292
4293 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
4294 trace("Creating the socket failed: %d\n", WSAGetLastError());
4295 WSACleanup();
4296 return;
4297 }
4298
4299 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
4300 trace("Failed to bind socket: %d\n", WSAGetLastError());
4301 closesocket(sock);
4302 WSACleanup();
4303 return;
4304 }
4305
4306 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4307 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
4308
4309 optlen = sizeof(BOOL);
4310 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
4311 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
4312 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
4313 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
4314 bool_opt_val, linger_val.l_onoff);
4315
4316 closesocket(sock);
4317 WSACleanup();
4318 }
4319
4320 static void test_getsockname(void)
4321 {
4322 WSADATA wsa;
4323 SOCKET sock;
4324 struct sockaddr_in sa_set, sa_get;
4325 int sa_set_len = sizeof(struct sockaddr_in);
4326 int sa_get_len = sa_set_len;
4327 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
4328 int ret;
4329 struct hostent *h;
4330
4331 if(WSAStartup(MAKEWORD(2,0), &wsa)){
4332 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4333 return;
4334 }
4335
4336 memset(&sa_set, 0, sa_set_len);
4337
4338 sa_set.sin_family = AF_INET;
4339 sa_set.sin_port = htons(0);
4340 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
4341
4342 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
4343 trace("Creating the socket failed: %d\n", WSAGetLastError());
4344 WSACleanup();
4345 return;
4346 }
4347
4348 sa_get = sa_set;
4349 if (getsockname(sock, (struct sockaddr*) &sa_get, &sa_get_len) == 0)
4350 ok(0, "getsockname on unbound socket should fail\n");
4351 else {
4352 ok(WSAGetLastError() == WSAEINVAL, "getsockname on unbound socket "
4353 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL);
4354 ok(memcmp(&sa_get, &sa_set, sizeof(sa_get)) == 0,
4355 "failed getsockname modified sockaddr when it shouldn't\n");
4356 }
4357
4358 if(bind(sock, (struct sockaddr *) &sa_set, sa_set_len) < 0){
4359 trace("Failed to bind socket: %d\n", WSAGetLastError());
4360 closesocket(sock);
4361 WSACleanup();
4362 return;
4363 }
4364
4365 if(getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len) != 0){
4366 trace("Failed to call getsockname: %d\n", WSAGetLastError());
4367 closesocket(sock);
4368 WSACleanup();
4369 return;
4370 }
4371
4372 ret = memcmp(sa_get.sin_zero, null_padding, 8);
4373 ok(ret == 0 || broken(ret != 0), /* NT4 */
4374 "getsockname did not zero the sockaddr_in structure\n");
4375
4376 closesocket(sock);
4377
4378 h = gethostbyname("");
4379 if (h && h->h_length == 4) /* this test is only meaningful in IPv4 */
4380 {
4381 int i;
4382 for (i = 0; h->h_addr_list[i]; i++)
4383 {
4384 char ipstr[32];
4385 struct in_addr ip;
4386 ip.s_addr = *(ULONG *) h->h_addr_list[i];
4387
4388 sock = socket(AF_INET, SOCK_DGRAM, 0);
4389 ok(sock != INVALID_SOCKET, "socket failed with %d\n", GetLastError());
4390
4391 memset(&sa_set, 0, sizeof(sa_set));
4392 sa_set.sin_family = AF_INET;
4393 sa_set.sin_addr.s_addr = ip.s_addr;
4394 /* The same address we bind must be the same address we get */
4395 ret = bind(sock, (struct sockaddr*)&sa_set, sizeof(sa_set));
4396 ok(ret == 0, "bind failed with %d\n", GetLastError());
4397 sa_get_len = sizeof(sa_get);
4398 ret = getsockname(sock, (struct sockaddr*)&sa_get, &sa_get_len);
4399 ok(ret == 0, "getsockname failed with %d\n", GetLastError());
4400 strcpy(ipstr, inet_ntoa(sa_get.sin_addr));
4401 trace("testing bind on interface %s\n", ipstr);
4402 ok(sa_get.sin_addr.s_addr == sa_set.sin_addr.s_addr,
4403 "address does not match: %s != %s\n", ipstr, inet_ntoa(sa_set.sin_addr));
4404
4405 closesocket(sock);
4406 }
4407 }
4408
4409 WSACleanup();
4410 }
4411
4412 static void test_dns(void)
4413 {
4414 struct hostent *h;
4415 union memaddress
4416 {
4417 char *chr;
4418 void *mem;
4419 } addr;
4420 char **ptr;
4421 int acount;
4422
4423 h = gethostbyname("");
4424 ok(h != NULL, "gethostbyname(\"\") failed with %d\n", h_errno);
4425
4426 /* Use an address with valid alias names if possible */
4427 h = gethostbyname("source.winehq.org");
4428 if(!h)
4429 {
4430 skip("Can't test the hostent structure because gethostbyname failed\n");
4431 return;
4432 }
4433
4434 /* The returned struct must be allocated in a very strict way. First we need to
4435 * count how many aliases there are because they must be located right after
4436 * the struct hostent size. Knowing the amount of aliases we know the exact
4437 * location of the first IP returned. Rule valid for >= XP, for older OS's
4438 * it's somewhat the opposite. */
4439 addr.mem = h + 1;
4440 if(h->h_addr_list == addr.mem) /* <= W2K */
4441 {
4442 win_skip("Skipping hostent tests since this OS is unsupported\n");
4443 return;
4444 }
4445
4446 ok(h->h_aliases == addr.mem,
4447 "hostent->h_aliases should be in %p, it is in %p\n", addr.mem, h->h_aliases);
4448
4449 for(ptr = h->h_aliases, acount = 1; *ptr; ptr++) acount++;
4450 addr.chr += sizeof(*ptr) * acount;
4451 ok(h->h_addr_list == addr.mem,
4452 "hostent->h_addr_list should be in %p, it is in %p\n", addr.mem, h->h_addr_list);
4453
4454 for(ptr = h->h_addr_list, acount = 1; *ptr; ptr++) acount++;
4455
4456 addr.chr += sizeof(*ptr) * acount;
4457 ok(h->h_addr_list[0] == addr.mem,
4458 "hostent->h_addr_list[0] should be in %p, it is in %p\n", addr.mem, h->h_addr_list[0]);
4459 }
4460
4461 /* Our winsock headers don't define gethostname because it conflicts with the
4462 * definition in unistd.h. Define it here to get rid of the warning. */
4463
4464 int WINAPI gethostname(char *name, int namelen);
4465
4466 static void test_gethostbyname(void)
4467 {
4468 struct hostent *he;
4469 struct in_addr **addr_list;
4470 char name[256], first_ip[16];
4471 int ret, i, count;
4472 PMIB_IPFORWARDTABLE routes = NULL;
4473 PIP_ADAPTER_INFO adapters = NULL, k;
4474 DWORD adap_size = 0, route_size = 0;
4475 BOOL found_default = FALSE;
4476 BOOL local_ip = FALSE;
4477
4478 ret = gethostname(name, sizeof(name));
4479 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4480
4481 he = gethostbyname(name);
4482 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4483 addr_list = (struct in_addr **)he->h_addr_list;
4484 strcpy(first_ip, inet_ntoa(*addr_list[0]));
4485
4486 trace("List of local IPs:\n");
4487 for(count = 0; addr_list[count] != NULL; count++)
4488 {
4489 char *ip = inet_ntoa(*addr_list[count]);
4490 if (!strcmp(ip, "127.0.0.1"))
4491 local_ip = TRUE;
4492 trace("%s\n", ip);
4493 }
4494
4495 if (local_ip)
4496 {
4497 ok (count == 1, "expected 127.0.0.1 to be the only IP returned\n");
4498 skip("Only the loopback address is present, skipping tests\n");
4499 return;
4500 }
4501
4502 if (!pGetAdaptersInfo || !pGetIpForwardTable)
4503 {
4504 win_skip("GetAdaptersInfo and/or GetIpForwardTable not found, skipping tests\n");
4505 return;
4506 }
4507
4508 ret = pGetAdaptersInfo(NULL, &adap_size);
4509 ok (ret == ERROR_BUFFER_OVERFLOW, "GetAdaptersInfo failed with a different error: %d\n", ret);
4510 ret = pGetIpForwardTable(NULL, &route_size, FALSE);
4511 ok (ret == ERROR_INSUFFICIENT_BUFFER, "GetIpForwardTable failed with a different error: %d\n", ret);
4512
4513 adapters = HeapAlloc(GetProcessHeap(), 0, adap_size);
4514 routes = HeapAlloc(GetProcessHeap(), 0, route_size);
4515
4516 ret = pGetAdaptersInfo(adapters, &adap_size);
4517 ok (ret == NO_ERROR, "GetAdaptersInfo failed, error: %d\n", ret);
4518 ret = pGetIpForwardTable(routes, &route_size, FALSE);
4519 ok (ret == NO_ERROR, "GetIpForwardTable failed, error: %d\n", ret);
4520
4521 /* This test only has meaning if there is more than one IP configured */
4522 if (adapters->Next == NULL && count == 1)
4523 {
4524 skip("Only one IP is present, skipping tests\n");
4525 goto cleanup;
4526 }
4527
4528 for (i = 0; !found_default && i < routes->dwNumEntries; i++)
4529 {
4530 /* default route (ip 0.0.0.0) ? */
4531 if (routes->table[i].dwForwardDest) continue;
4532
4533 for (k = adapters; k != NULL; k = k->Next)
4534 {
4535 char *ip;
4536
4537 if (k->Index != routes->table[i].dwForwardIfIndex) continue;
4538
4539 /* the first IP returned from gethostbyname must be a default route */
4540 ip = k->IpAddressList.IpAddress.String;
4541 if (!strcmp(first_ip, ip))
4542 {
4543 found_default = TRUE;
4544 break;
4545 }
4546 }
4547 }
4548 todo_wine
4549 ok (found_default, "failed to find the first IP from gethostbyname!\n");
4550
4551 cleanup:
4552 HeapFree(GetProcessHeap(), 0, adapters);
4553 HeapFree(GetProcessHeap(), 0, routes);
4554 }
4555
4556 static void test_gethostbyname_hack(void)
4557 {
4558 struct hostent *he;
4559 char name[256];
4560 static BYTE loopback[] = {127, 0, 0, 1};
4561 static BYTE magic_loopback[] = {127, 12, 34, 56};
4562 int ret;
4563
4564 ret = gethostname(name, 256);
4565 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4566
4567 he = gethostbyname("localhost");
4568 ok(he != NULL, "gethostbyname(\"localhost\") failed: %d\n", h_errno);
4569 if(he)
4570 {
4571 if(he->h_length != 4)
4572 {
4573 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
4574 return;
4575 }
4576
4577 ok(memcmp(he->h_addr_list[0], loopback, he->h_length) == 0,
4578 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
4579 he->h_addr_list[0][0], he->h_addr_list[0][1], he->h_addr_list[0][2],
4580 he->h_addr_list[0][3]);
4581 }
4582
4583 if(strcmp(name, "localhost") == 0)
4584 {
4585 skip("hostname seems to be \"localhost\", skipping test.\n");
4586 return;
4587 }
4588
4589 he = gethostbyname(name);
4590 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, h_errno);
4591 if(he)
4592 {
4593 if(he->h_length != 4)
4594 {
4595 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
4596 return;
4597 }
4598
4599 if (he->h_addr_list[0][0] == 127)
4600 {
4601 ok(memcmp(he->h_addr_list[0], magic_loopback, he->h_length) == 0,
4602 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
4603 name, he->h_addr_list[0][0], he->h_addr_list[0][1],
4604 he->h_addr_list[0][2], he->h_addr_list[0][3]);
4605 }
4606 }
4607
4608 gethostbyname("nonexistent.winehq.org");
4609 /* Don't check for the return value, as some braindead ISPs will kindly
4610 * resolve nonexistent host names to addresses of the ISP's spam pages. */
4611 }
4612
4613 static void test_gethostname(void)
4614 {
4615 struct hostent *he;
4616 char name[256];
4617 int ret, len;
4618
4619 WSASetLastError(0xdeadbeef);
4620 ret = gethostname(NULL, 256);
4621 ok(ret == -1, "gethostname() returned %d\n", ret);
4622 ok(WSAGetLastError() == WSAEFAULT, "gethostname with null buffer "
4623 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT);
4624
4625 ret = gethostname(name, sizeof(name));
4626 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4627 he = gethostbyname(name);
4628 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4629
4630 len = strlen(name);
4631 WSASetLastError(0xdeadbeef);
4632 strcpy(name, "deadbeef");
4633 ret = gethostname(name, len);
4634 ok(ret == -1, "gethostname() returned %d\n", ret);
4635 ok(!strcmp(name, "deadbeef"), "name changed unexpected!\n");
4636 ok(WSAGetLastError() == WSAEFAULT, "gethostname with insufficient length "
4637 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT);
4638
4639 len++;
4640 ret = gethostname(name, len);
4641 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4642 he = gethostbyname(name);
4643 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4644 }
4645
4646 static void test_inet_addr(void)
4647 {
4648 u_long addr;
4649
4650 addr = inet_addr(NULL);
4651 ok(addr == INADDR_NONE, "inet_addr succeeded unexpectedly\n");
4652 }
4653
4654 static void test_addr_to_print(void)
4655 {
4656 char dst[16];
4657 char dst6[64];
4658 const char * pdst;
4659 struct in_addr in;
4660 struct in6_addr in6;
4661
4662 u_long addr0_Num = 0x00000000;
4663 PCSTR addr0_Str = "0.0.0.0";
4664 u_long addr1_Num = 0x20201015;
4665 PCSTR addr1_Str = "21.16.32.32";
4666 u_char addr2_Num[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
4667 PCSTR addr2_Str = "::fffe:cc98:bd74";
4668 u_char addr3_Num[16] = {0x20,0x30,0xa4,0xb1};
4669 PCSTR addr3_Str = "2030:a4b1::";
4670 u_char addr4_Num[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
4671 PCSTR addr4_Str = "::204.152.189.116";
4672
4673 /* Test IPv4 addresses */
4674 in.s_addr = addr0_Num;
4675
4676 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
4677 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
4678 ok(!strcmp(pdst, addr0_Str),"Address %s != %s\n", pdst, addr0_Str);
4679
4680 /* Test that inet_ntoa and inet_ntop return the same value */
4681 in.S_un.S_addr = addr1_Num;
4682 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
4683 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
4684 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4685
4686 /* InetNtop became available in Vista and Win2008 */
4687 if (!pInetNtop)
4688 {
4689 win_skip("InetNtop not present, not executing tests\n");
4690 return;
4691 }
4692
4693 /* Second part of test */
4694 pdst = pInetNtop(AF_INET,(void*)&in.s_addr, dst, sizeof(dst));
4695 ok(pdst != NULL, "InetNtop failed %s\n", dst);
4696 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4697
4698 /* Test invalid parm conditions */
4699 pdst = pInetNtop(1, (void*)&in.s_addr, dst, sizeof(dst));
4700 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4701 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "Should be WSAEAFNOSUPPORT\n");
4702
4703 /* Test Null destination */
4704 pdst = NULL;
4705 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, NULL, sizeof(dst));
4706 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4707 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4708 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4709
4710 /* Test zero length passed */
4711 WSASetLastError(0);
4712 pdst = NULL;
4713 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 0);
4714 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4715 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4716 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4717
4718 /* Test length one shorter than the address length */
4719 WSASetLastError(0);
4720 pdst = NULL;
4721 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 6);
4722 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4723 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4724 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4725
4726 /* Test longer length is ok */
4727 WSASetLastError(0);
4728 pdst = NULL;
4729 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, sizeof(dst)+1);
4730 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
4731 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4732
4733 /* Test the IPv6 addresses */
4734
4735 /* Test an zero prefixed IPV6 address */
4736 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
4737 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
4738 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4739 ok(!strcmp(pdst, addr2_Str),"Address %s != %s\n", pdst, addr2_Str);
4740
4741 /* Test an zero suffixed IPV6 address */
4742 memcpy(in6.s6_addr, addr3_Num, sizeof(addr3_Num));
4743 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
4744 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4745 ok(!strcmp(pdst, addr3_Str),"Address %s != %s\n", pdst, addr3_Str);
4746
4747 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
4748 memcpy(in6.s6_addr, addr4_Num, sizeof(addr4_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, addr4_Str),"Address %s != %s\n", pdst, addr4_Str);
4752
4753 /* Test invalid parm conditions */
4754 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
4755
4756 /* Test Null destination */
4757 pdst = NULL;
4758 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, NULL, sizeof(dst6));
4759 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4760 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4761 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4762
4763 /* Test zero length passed */
4764 WSASetLastError(0);
4765 pdst = NULL;
4766 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 0);
4767 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4768 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4769 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4770
4771 /* Test length one shorter than the address length */
4772 WSASetLastError(0);
4773 pdst = NULL;
4774 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 16);
4775 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4776 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4777 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4778
4779 /* Test longer length is ok */
4780 WSASetLastError(0);
4781 pdst = NULL;
4782 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 18);
4783 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
4784 }
4785 static void test_inet_pton(void)
4786 {
4787 struct TEST_DATA
4788 {
4789 int family, ret;
4790 DWORD err;
4791 const char *printable, *collapsed, *raw_data;
4792 } tests[] = {
4793 {AF_UNSPEC, -1, WSAEFAULT, /* Test 0 */
4794 NULL, NULL, NULL},
4795 {AF_INET, -1, WSAEFAULT,
4796 NULL, NULL, NULL},
4797 {AF_INET6, -1, WSAEFAULT,
4798 NULL, NULL, NULL},
4799 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4800 "127.0.0.1", NULL, NULL},
4801 {AF_INET, 1, 0,
4802 "127.0.0.1", "127.0.0.1",
4803 "\x7f\x00\x00\x01"},
4804 {AF_INET6, 0, 0,
4805 "127.0.0.1", "127.0.0.1", NULL},
4806 {AF_INET, 0, 0,
4807 "::1/128", NULL, NULL},
4808 {AF_INET6, 0, 0,
4809 "::1/128", NULL, NULL},
4810 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4811 "broken", NULL, NULL},
4812 {AF_INET, 0, 0,
4813 "broken", NULL, NULL},
4814 {AF_INET6, 0, 0, /* Test 10 */
4815 "broken", NULL, NULL},
4816 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4817 "177.32.45.20", NULL, NULL},
4818 {AF_INET, 1, 0,
4819 "177.32.45.20", "177.32.45.20",
4820 "\xb1\x20\x2d\x14"},
4821 {AF_INET6, 0, 0,
4822 "177.32.45.20", NULL, NULL},
4823 {AF_INET, 0, 0,
4824 "2607:f0d0:1002:51::4", NULL, NULL},
4825 {AF_INET6, 1, 0,
4826 "2607:f0d0:1002:51::4", "2607:f0d0:1002:51::4",
4827 "\x26\x07\xf0\xd0\x10\x02\x00\x51\x00\x00\x00\x00\x00\x00\x00\x04"},
4828 {AF_INET, 0, 0,
4829 "::177.32.45.20", NULL, NULL},
4830 {AF_INET6, 1, 0,
4831 "::177.32.45.20", "::177.32.45.20",
4832 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x20\x2d\x14"},
4833 {AF_INET, 0, 0,
4834 "fe80::0202:b3ff:fe1e:8329", NULL, NULL},
4835 {AF_INET6, 1, 0,
4836 "fe80::0202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
4837 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
4838 {AF_INET6, 1, 0, /* Test 20 */
4839 "fe80::202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
4840 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
4841 {AF_INET, 0, 0,
4842 "a", NULL, NULL},
4843 {AF_INET, 0, 0,
4844 "a.b", NULL, NULL},
4845 {AF_INET, 0, 0,
4846 "a.b.c", NULL, NULL},
4847 {AF_INET, 0, 0,
4848 "a.b.c.d", NULL, NULL},
4849 {AF_INET6, 1, 0,
4850 "2001:cdba:0000:0000:0000:0000:3257:9652", "2001:cdba::3257:9652",
4851 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
4852 {AF_INET6, 1, 0,
4853 "2001:cdba::3257:9652", "2001:cdba::3257:9652",
4854 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
4855 {AF_INET6, 1, 0,
4856 "2001:cdba:0:0:0:0:3257:9652", "2001:cdba::3257:9652",
4857 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"}
4858 };
4859 int i, ret;
4860 DWORD err;
4861 char buffer[64],str[64];
4862 WCHAR printableW[64];
4863 const char *ptr;
4864
4865 /* InetNtop and InetPton became available in Vista and Win2008 */
4866 if (!pInetNtop || !pInetPtonA || !pInetPtonW)
4867 {
4868 win_skip("InetNtop and/or InetPton not present, not executing tests\n");
4869 return;
4870 }
4871
4872 for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
4873 {
4874 WSASetLastError(0xdeadbeef);
4875 ret = pInetPtonA(tests[i].family, tests[i].printable, buffer);
4876 ok (ret == tests[i].ret, "Test [%d]: Expected %d, got %d\n", i, tests[i].ret, ret);
4877 if (tests[i].ret == -1)
4878 {
4879 err = WSAGetLastError();
4880 ok (tests[i].err == err, "Test [%d]: Expected 0x%x, got 0x%x\n", i, tests[i].err, err);
4881 }
4882 if (tests[i].ret != 1) continue;
4883 ok (memcmp(buffer, tests[i].raw_data,
4884 tests[i].family == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr)) == 0,
4885 "Test [%d]: Expected binary data differs\n", i);
4886
4887 /* Test the result from Pton with Ntop */
4888 strcpy (str, "deadbeef");
4889 ptr = pInetNtop(tests[i].family, buffer, str, sizeof(str));
4890 ok (ptr != NULL, "Test [%d]: Failed with NULL\n", i);
4891 ok (ptr == str, "Test [%d]: Pointers differ (%p != %p)\n", i, ptr, str);
4892 if (!ptr) continue;
4893 ok (strcmp(ptr, tests[i].collapsed) == 0, "Test [%d]: Expected '%s', got '%s'\n",
4894 i, tests[i].collapsed, ptr);
4895 }
4896
4897 for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
4898 {
4899 if (tests[i].printable)
4900 MultiByteToWideChar(CP_ACP, 0, tests[i].printable, -1, printableW,
4901 sizeof(printableW) / sizeof(printableW[0]));
4902 WSASetLastError(0xdeadbeef);
4903 ret = pInetPtonW(tests[i].family, tests[i].printable ? printableW : NULL, buffer);
4904 ok(ret == tests[i].ret, "Test [%d]: Expected %d, got %d\n", i, tests[i].ret, ret);
4905 if (tests[i].ret == -1)
4906 {
4907 err = WSAGetLastError();
4908 ok(tests[i].err == err, "Test [%d]: Expected 0x%x, got 0x%x\n", i, tests[i].err, err);
4909 }
4910 if (tests[i].ret != 1) continue;
4911 ok(memcmp(buffer, tests[i].raw_data,
4912 tests[i].family == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr)) == 0,
4913 "Test [%d]: Expected binary data differs\n", i);
4914 }
4915 }
4916
4917 static void test_ioctlsocket(void)
4918 {
4919 SOCKET sock, src, dst;
4920 struct tcp_keepalive kalive;
4921 int ret, optval;
4922 static const LONG cmds[] = {FIONBIO, FIONREAD, SIOCATMARK};
4923 UINT i, bytes_rec;
4924 char data;
4925 WSABUF bufs;
4926 u_long arg = 0;
4927
4928 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4929 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
4930 if(sock == INVALID_SOCKET)
4931 {
4932 skip("Can't continue without a socket.\n");
4933 return;
4934 }
4935
4936 for(i = 0; i < sizeof(cmds)/sizeof(cmds[0]); i++)
4937 {
4938 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
4939 ret = ioctlsocket(sock, cmds[i], (u_long *)1);
4940 ok(ret == SOCKET_ERROR, "ioctlsocket succeeded unexpectedly\n");
4941 ret = WSAGetLastError();
4942 ok(ret == WSAEFAULT, "expected WSAEFAULT, got %d instead\n", ret);
4943 }
4944
4945 /* A fresh and not connected socket has no urgent data, this test shows
4946 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
4947
4948 ret = ioctlsocket(sock, SIOCATMARK, &arg);
4949 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
4950 ok(arg, "SIOCATMARK expected a non-zero value\n");
4951
4952 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
4953 optval = 1;
4954 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
4955 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
4956 arg = 0;
4957 ret = ioctlsocket(sock, SIOCATMARK, &arg);
4958 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
4959 ok(arg, "SIOCATMARK expected a non-zero value\n");
4960
4961 /* disable SO_OOBINLINE and get the same old behavior */
4962 optval = 0;
4963 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
4964 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
4965 arg = 0;
4966 ret = ioctlsocket(sock, SIOCATMARK, &arg);
4967 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
4968 ok(arg, "SIOCATMARK expected a non-zero value\n");
4969
4970 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &arg, 0, NULL, 0, &arg, NULL, NULL);
4971 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4972 ret = WSAGetLastError();
4973 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
4974
4975 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, NULL, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4976 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4977 ret = WSAGetLastError();
4978 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
4979
4980 /* broken used to catch W95, W98, NT4 */
4981 make_keepalive(kalive, 0, 0, 0);
4982 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4983 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4984
4985 make_keepalive(kalive, 1, 0, 0);
4986 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4987 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4988
4989 make_keepalive(kalive, 1, 1000, 1000);
4990 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4991 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4992
4993 make_keepalive(kalive, 1, 10000, 10000);
4994 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4995 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4996
4997 make_keepalive(kalive, 1, 100, 100);
4998 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4999 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
5000
5001 make_keepalive(kalive, 0, 100, 100);
5002 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
5003 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
5004
5005 closesocket(sock);
5006
5007 if (tcp_socketpair(&src, &dst) != 0)
5008 {
5009 ok(0, "creating socket pair failed, skipping test\n");
5010 return;
5011 }
5012
5013 /* test FIONREAD on TCP sockets */
5014 optval = 0xdeadbeef;
5015 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
5016 ok(ret == 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5017 ok(optval == 0, "FIONREAD should have returned 0 bytes, got %d instead\n", optval);
5018
5019 optval = 0xdeadbeef;
5020 ok(send(src, "TEST", 4, 0) == 4, "failed to send test data\n");
5021 Sleep(100);
5022 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
5023 ok(ret == 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5024 ok(optval == 4, "FIONREAD should have returned 4 bytes, got %d instead\n", optval);
5025
5026 /* trying to read from an OOB inlined socket with MSG_OOB results in WSAEINVAL */
5027 set_blocking(dst, FALSE);
5028 i = MSG_OOB;
5029 SetLastError(0xdeadbeef);
5030 ret = recv(dst, &data, 1, i);
5031 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5032 ret = GetLastError();
5033 ok(ret == WSAEWOULDBLOCK, "expected 10035, got %d\n", ret);
5034 bufs.len = sizeof(char);
5035 bufs.buf = &data;
5036 ret = WSARecv(dst, &bufs, 1, &bytes_rec, &i, NULL, NULL);
5037 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5038 ret = GetLastError();
5039 ok(ret == WSAEWOULDBLOCK, "expected 10035, got %d\n", ret);
5040 optval = 1;
5041 ret = setsockopt(dst, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
5042 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
5043 i = MSG_OOB;
5044 SetLastError(0xdeadbeef);
5045 ret = recv(dst, &data, 1, i);
5046 if (ret == SOCKET_ERROR)
5047 {
5048 ret = GetLastError();
5049 ok(ret == WSAEINVAL, "expected 10022, got %d\n", ret);
5050 bufs.len = sizeof(char);
5051 bufs.buf = &data;
5052 ret = WSARecv(dst, &bufs, 1, &bytes_rec, &i, NULL, NULL);
5053 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
5054 ret = GetLastError();
5055 ok(ret == WSAEINVAL, "expected 10022, got %d\n", ret);
5056 }
5057 else ok(broken(ret == 1) /* <= NT4 */, "expected error, got 1\n");
5058
5059 closesocket(dst);
5060 optval = 0xdeadbeef;
5061 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
5062 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
5063 ok(optval == 0xdeadbeef, "FIONREAD should not have changed last error, got %d instead\n", optval);
5064 closesocket(src);
5065 }
5066
5067 static BOOL drain_pause = FALSE;
5068 static DWORD WINAPI drain_socket_thread(LPVOID arg)
5069 {
5070 char buffer[1024];
5071 SOCKET sock = *(SOCKET*)arg;
5072 int ret;
5073
5074 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
5075 {
5076 if (ret < 0)
5077 {
5078 if (WSAGetLastError() == WSAEWOULDBLOCK)
5079 {
5080 fd_set readset;
5081 FD_ZERO(&readset);
5082 FD_SET(sock, &readset);
5083 select(sock+1, &readset, NULL, NULL, NULL);
5084 while (drain_pause)
5085 Sleep(100);
5086 }
5087 else
5088 break;
5089 }
5090 }
5091 return 0;
5092 }
5093
5094 static void test_send(void)
5095 {
5096 SOCKET src = INVALID_SOCKET;
5097 SOCKET dst = INVALID_SOCKET;
5098 HANDLE hThread = NULL;
5099 const int buflen = 1024*1024;
5100 char *buffer = NULL;
5101 int ret, i, zero = 0;
5102 WSABUF buf;
5103 OVERLAPPED ov;
5104 BOOL bret;
5105 DWORD id, bytes_sent, dwRet;
5106
5107 memset(&ov, 0, sizeof(ov));
5108
5109 if (tcp_socketpair(&src, &dst) != 0)
5110 {
5111 ok(0, "creating socket pair failed, skipping test\n");
5112 return;
5113 }
5114
5115 set_blocking(dst, FALSE);
5116 /* force disable buffering so we can get a pending overlapped request */
5117 ret = setsockopt(dst, SOL_SOCKET, SO_SNDBUF, (char *) &zero, sizeof(zero));
5118 ok(!ret, "setsockopt SO_SNDBUF failed: %d - %d\n", ret, GetLastError());
5119
5120 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
5121 if (hThread == NULL)
5122 {
5123 ok(0, "CreateThread failed, error %d\n", GetLastError());
5124 goto end;
5125 }
5126
5127 buffer = HeapAlloc(GetProcessHeap(), 0, buflen);
5128 if (buffer == NULL)
5129 {
5130 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
5131 goto end;
5132 }
5133
5134 /* fill the buffer with some nonsense */
5135 for (i = 0; i < buflen; ++i)
5136 {
5137 buffer[i] = (char) i;
5138 }
5139
5140 ret = send(src, buffer, buflen, 0);
5141 if (ret >= 0)
5142 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
5143 else
5144 ok(0, "send failed, error %d\n", WSAGetLastError());
5145
5146 buf.buf = buffer;
5147 buf.len = buflen;
5148
5149 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5150 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
5151 if (!ov.hEvent)
5152 goto end;
5153
5154 bytes_sent = 0;
5155 WSASetLastError(12345);
5156 ret = WSASend(dst, &buf, 1, &bytes_sent, 0, &ov, NULL);
5157 ok((ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING) || broken(bytes_sent == buflen),
5158 "Failed to start overlapped send %d - %d - %d/%d\n", ret, WSAGetLastError(), bytes_sent, buflen);
5159
5160 /* don't check for completion yet, we may need to drain the buffer while still sending */
5161 set_blocking(src, FALSE);
5162 for (i = 0; i < buflen; ++i)
5163 {
5164 int j = 0;
5165
5166 ret = recv(src, buffer, 1, 0);
5167 while (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK && j < 100)
5168 {
5169 j++;
5170 Sleep(50);
5171 ret = recv(src, buffer, 1, 0);
5172 }
5173
5174 ok(ret == 1, "Failed to receive data %d - %d (got %d/%d)\n", ret, GetLastError(), i, buflen);
5175 if (ret != 1)
5176 break;
5177
5178 ok(buffer[0] == (char) i, "Received bad data at position %d\n", i);
5179 }
5180
5181 dwRet = WaitForSingleObject(ov.hEvent, 1000);
5182 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5183 if (dwRet == WAIT_OBJECT_0)
5184 {
5185 bret = GetOverlappedResult((HANDLE)dst, &ov, &bytes_sent, FALSE);
5186 ok((bret && bytes_sent == buflen) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5187 "Got %d instead of %d (%d - %d)\n", bytes_sent, buflen, bret, GetLastError());
5188 }
5189
5190 WSASetLastError(12345);
5191 ret = WSASend(INVALID_SOCKET, &buf, 1, NULL, 0, &ov, NULL);
5192 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
5193 "WSASend failed %d - %d\n", ret, WSAGetLastError());
5194
5195 WSASetLastError(12345);
5196 ret = WSASend(dst, &buf, 1, NULL, 0, &ov, NULL);
5197 ok(ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING,
5198 "Failed to start overlapped send %d - %d\n", ret, WSAGetLastError());
5199
5200 end:
5201 if (src != INVALID_SOCKET)
5202 closesocket(src);
5203 if (dst != INVALID_SOCKET)
5204 closesocket(dst);
5205 if (hThread != NULL)
5206 {
5207 dwRet = WaitForSingleObject(hThread, 500);
5208 ok(dwRet == WAIT_OBJECT_0, "failed to wait for thread termination: %d\n", GetLastError());
5209 CloseHandle(hThread);
5210 }
5211 if (ov.hEvent)
5212 CloseHandle(ov.hEvent);
5213 HeapFree(GetProcessHeap(), 0, buffer);
5214 }
5215
5216 typedef struct async_message
5217 {
5218 SOCKET socket;
5219 LPARAM lparam;
5220 struct async_message *next;
5221 } async_message;
5222
5223 static struct async_message *messages_received;
5224
5225 #define WM_SOCKET (WM_USER+100)
5226 static LRESULT CALLBACK ws2_test_WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
5227 {
5228 struct async_message *message;
5229
5230 switch (msg)
5231 {
5232 case WM_SOCKET:
5233 message = HeapAlloc(GetProcessHeap(), 0, sizeof(*message));
5234 message->socket = (SOCKET) wparam;
5235 message->lparam = lparam;
5236 message->next = NULL;
5237
5238 if (messages_received)
5239 {
5240 struct async_message *last = messages_received;
5241 while (last->next) last = last->next;
5242 last->next = message;
5243 }
5244 else
5245 messages_received = message;
5246 return 0;
5247 }
5248
5249 return DefWindowProcA(hwnd, msg, wparam, lparam);
5250 }
5251
5252 static void get_event_details(int event, int *bit, char *name)
5253 {
5254 switch (event)
5255 {
5256 case FD_ACCEPT:
5257 if (bit) *bit = FD_ACCEPT_BIT;
5258 if (name) strcpy(name, "FD_ACCEPT");
5259 break;
5260 case FD_CONNECT:
5261 if (bit) *bit = FD_CONNECT_BIT;
5262 if (name) strcpy(name, "FD_CONNECT");
5263 break;
5264 case FD_READ:
5265 if (bit) *bit = FD_READ_BIT;
5266 if (name) strcpy(name, "FD_READ");
5267 break;
5268 case FD_OOB:
5269 if (bit) *bit = FD_OOB_BIT;
5270 if (name) strcpy(name, "FD_OOB");
5271 break;
5272 case FD_WRITE:
5273 if (bit) *bit = FD_WRITE_BIT;
5274 if (name) strcpy(name, "FD_WRITE");
5275 break;
5276 case FD_CLOSE:
5277 if (bit) *bit = FD_CLOSE_BIT;
5278 if (name) strcpy(name, "FD_CLOSE");
5279 break;
5280 default:
5281 if (bit) *bit = -1;
5282 if (name) sprintf(name, "bad%x", event);
5283 }
5284 }
5285
5286 static const char *dbgstr_event_seq(const LPARAM *seq)
5287 {
5288 static char message[1024];
5289 char name[12];
5290 int len = 1;
5291
5292 message[0] = '[';
5293 message[1] = 0;
5294 while (*seq)
5295 {
5296 get_event_details(WSAGETSELECTEVENT(*seq), NULL, name);
5297 len += sprintf(message + len, "%s(%d) ", name, WSAGETSELECTERROR(*seq));
5298 seq++;
5299 }
5300 if (len > 1) len--;
5301 strcpy( message + len, "]" );
5302 return message;
5303 }
5304
5305 static char *dbgstr_event_seq_result(SOCKET s, WSANETWORKEVENTS *netEvents)
5306 {
5307 static char message[1024];
5308 struct async_message *curr = messages_received;
5309 int index, error, bit = 0;
5310 char name[12];
5311 int len = 1;
5312
5313 message[0] = '[';
5314 message[1] = 0;
5315 while (1)
5316 {
5317 if (netEvents)
5318 {
5319 if (bit >= FD_MAX_EVENTS) break;
5320 if ( !(netEvents->lNetworkEvents & (1 << bit)) )
5321 {
5322 bit++;
5323 continue;
5324 }
5325 get_event_details(1 << bit, &index, name);
5326 error = netEvents->iErrorCode[index];
5327 bit++;
5328 }
5329 else
5330 {
5331 if (!curr) break;
5332 if (curr->socket != s)
5333 {
5334 curr = curr->next;
5335 continue;
5336 }
5337 get_event_details(WSAGETSELECTEVENT(curr->lparam), NULL, name);
5338 error = WSAGETSELECTERROR(curr->lparam);
5339 curr = curr->next;
5340 }
5341
5342 len += sprintf(message + len, "%s(%d) ", name, error);
5343 }
5344 if (len > 1) len--;
5345 strcpy( message + len, "]" );
5346 return message;
5347 }
5348
5349 static void flush_events(SOCKET s, HANDLE hEvent)
5350 {
5351 WSANETWORKEVENTS netEvents;
5352 struct async_message *prev = NULL, *curr = messages_received;
5353 int ret;
5354 DWORD dwRet;
5355
5356 if (hEvent != INVALID_HANDLE_VALUE)
5357 {
5358 dwRet = WaitForSingleObject(hEvent, 100);
5359 if (dwRet == WAIT_OBJECT_0)
5360 {
5361 ret = WSAEnumNetworkEvents(s, hEvent, &netEvents);
5362 if (ret)
5363 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
5364 }
5365 }
5366 else
5367 {
5368 while (curr)
5369 {
5370 if (curr->socket == s)
5371 {
5372 if (prev) prev->next = curr->next;
5373 else messages_received = curr->next;
5374
5375 HeapFree(GetProcessHeap(), 0, curr);
5376
5377 if (prev) curr = prev->next;
5378 else curr = messages_received;
5379 }
5380 else
5381 {
5382 prev = curr;
5383 curr = curr->next;
5384 }
5385 }
5386 }
5387 }
5388
5389 static int match_event_sequence(SOCKET s, WSANETWORKEVENTS *netEvents, const LPARAM *seq)
5390 {
5391 int event, index, error, events;
5392 struct async_message *curr;
5393
5394 if (netEvents)
5395 {
5396 events = netEvents->lNetworkEvents;
5397 while (*seq)
5398 {
5399 event = WSAGETSELECTEVENT(*seq);
5400 error = WSAGETSELECTERROR(*seq);
5401 get_event_details(event, &index, NULL);
5402
5403 if (!(events & event) && index != -1)
5404 return 0;
5405 if (events & event && index != -1)
5406 {
5407 if (netEvents->iErrorCode[index] != error)
5408 return 0;
5409 }
5410 events &= ~event;
5411 seq++;
5412 }
5413 if (events)
5414 return 0;
5415 }
5416 else
5417 {
5418 curr = messages_received;
5419 while (curr)
5420 {
5421 if (curr->socket == s)
5422 {
5423 if (!*seq) return 0;
5424 if (*seq != curr->lparam) return 0;
5425 seq++;
5426 }
5427 curr = curr->next;
5428 }
5429 if (*seq)
5430 return 0;
5431 }
5432 return 1;
5433 }
5434
5435 /* checks for a sequence of events, (order only checked if window is used) */
5436 static void ok_event_sequence(SOCKET s, HANDLE hEvent, const LPARAM *seq, const LPARAM **broken_seqs, int completelyBroken)
5437 {
5438 MSG msg;
5439 WSANETWORKEVENTS events, *netEvents = NULL;
5440 int ret;
5441 DWORD dwRet;
5442
5443 if (hEvent != INVALID_HANDLE_VALUE)
5444 {
5445 netEvents = &events;
5446
5447 dwRet = WaitForSingleObject(hEvent, 200);
5448 if (dwRet == WAIT_OBJECT_0)
5449 {
5450 ret = WSAEnumNetworkEvents(s, hEvent, netEvents);
5451 if (ret)
5452 {
5453 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
5454 return;
5455 }
5456 }
5457 else
5458 memset(netEvents, 0, sizeof(*netEvents));
5459 }
5460 else
5461 {
5462 Sleep(200);
5463 /* Run the message loop a little */
5464 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
5465 {
5466 DispatchMessageA(&msg);
5467 }
5468 }
5469
5470 if (match_event_sequence(s, netEvents, seq))
5471 {
5472 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq));
5473 flush_events(s, hEvent);
5474 return;
5475 }
5476
5477 if (broken_seqs)
5478 {
5479 for (; *broken_seqs; broken_seqs++)
5480 {
5481 if (match_event_sequence(s, netEvents, *broken_seqs))
5482 {
5483 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s, netEvents), dbgstr_event_seq(seq));
5484 flush_events(s, hEvent);
5485 return;
5486 }
5487 }
5488 }
5489
5490 winetest_ok(broken(completelyBroken), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq),
5491 dbgstr_event_seq_result(s, netEvents));
5492 flush_events(s, hEvent);
5493 }
5494
5495 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
5496
5497 static void test_events(int useMessages)
5498 {
5499 SOCKET server = INVALID_SOCKET;
5500 SOCKET src = INVALID_SOCKET, src2 = INVALID_SOCKET;
5501 SOCKET dst = INVALID_SOCKET, dst2 = INVALID_SOCKET;
5502 struct sockaddr_in addr;
5503 HANDLE hThread = NULL;
5504 HANDLE hEvent = INVALID_HANDLE_VALUE, hEvent2 = INVALID_HANDLE_VALUE;
5505 WNDCLASSEXA wndclass;
5506 HWND hWnd = NULL;
5507 char *buffer = NULL;
5508 int bufferSize = 1024*1024;
5509 WSABUF bufs;
5510 OVERLAPPED ov, ov2;
5511 DWORD flags = 0;
5512 DWORD bytesReturned;
5513 DWORD id;
5514 int len;
5515 int ret;
5516 DWORD dwRet;
5517 BOOL bret;
5518 static char szClassName[] = "wstestclass";
5519 const LPARAM *broken_seq[3];
5520 static const LPARAM empty_seq[] = { 0 };
5521 static const LPARAM close_seq[] = { WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
5522 static const LPARAM write_seq[] = { WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5523 static const LPARAM read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0), 0 };
5524 static const LPARAM oob_seq[] = { WSAMAKESELECTREPLY(FD_OOB, 0), 0 };
5525 static const LPARAM connect_seq[] = { WSAMAKESELECTREPLY(FD_CONNECT, 0),
5526 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5527 static const LPARAM read_read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5528 WSAMAKESELECTREPLY(FD_READ, 0), 0 };
5529 static const LPARAM read_write_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5530 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5531 static const LPARAM read_close_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5532 WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
5533
5534 memset(&ov, 0, sizeof(ov));
5535 memset(&ov2, 0, sizeof(ov2));
5536
5537 /* don't use socketpair, we want connection event */
5538 src = socket(AF_INET, SOCK_STREAM, 0);
5539 if (src == INVALID_SOCKET)
5540 {
5541 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5542 goto end;
5543 }
5544
5545 ret = set_blocking(src, TRUE);
5546 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5547
5548 src2 = socket(AF_INET, SOCK_STREAM, 0);
5549 if (src2 == INVALID_SOCKET)
5550 {
5551 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5552 goto end;
5553 }
5554
5555 ret = set_blocking(src2, TRUE);
5556 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5557
5558 len = sizeof(BOOL);
5559 if (getsockopt(src, SOL_SOCKET, SO_OOBINLINE, (void *)&bret, &len) == SOCKET_ERROR)
5560 {
5561 ok(0, "failed to get oobinline status, %d\n", GetLastError());
5562 goto end;
5563 }
5564 ok(bret == FALSE, "OOB not inline\n");
5565
5566 if (useMessages)
5567 {
5568 trace("Event test using messages\n");
5569
5570 wndclass.cbSize = sizeof(wndclass);
5571 wndclass.style = CS_HREDRAW | CS_VREDRAW;
5572 wndclass.lpfnWndProc = ws2_test_WndProc;
5573 wndclass.cbClsExtra = 0;
5574 wndclass.cbWndExtra = 0;
5575 wndclass.hInstance = GetModuleHandleA(NULL);
5576 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
5577 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
5578 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
5579 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
5580 wndclass.lpszClassName = szClassName;
5581 wndclass.lpszMenuName = NULL;
5582 RegisterClassExA(&wndclass);
5583
5584 hWnd = CreateWindowA(szClassName, "WS2Test", WS_OVERLAPPEDWINDOW,
5585 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
5586 if (!hWnd)
5587 {
5588 ok(0, "failed to create window: %d\n", GetLastError());
5589 return;
5590 }
5591
5592 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5593 if (ret)
5594 {
5595 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5596 goto end;
5597 }
5598
5599 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5600 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5601
5602 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5603 if (ret)
5604 {
5605 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5606 goto end;
5607 }
5608
5609 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5610 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5611 }
5612 else
5613 {
5614 trace("Event test using events\n");
5615
5616 hEvent = WSACreateEvent();
5617 if (hEvent == INVALID_HANDLE_VALUE)
5618 {
5619 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5620 goto end;
5621 }
5622
5623 hEvent2 = WSACreateEvent();
5624 if (hEvent2 == INVALID_HANDLE_VALUE)
5625 {
5626 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5627 goto end;
5628 }
5629
5630 ret = WSAEventSelect(src, hEvent, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5631 if (ret)
5632 {
5633 ok(0, "WSAEventSelect failed, error %d\n", ret);
5634 goto end;
5635 }
5636
5637 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5638 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5639
5640 ret = WSAEventSelect(src2, hEvent2, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5641 if (ret)
5642 {
5643 ok(0, "WSAEventSelect failed, error %d\n", ret);
5644 goto end;
5645 }
5646
5647 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5648 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5649 }
5650
5651 server = socket(AF_INET, SOCK_STREAM, 0);
5652 if (server == INVALID_SOCKET)
5653 {
5654 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5655 goto end;
5656 }
5657
5658 memset(&addr, 0, sizeof(addr));
5659 addr.sin_family = AF_INET;
5660 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
5661 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
5662 if (ret != 0)
5663 {
5664 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5665 goto end;
5666 }
5667
5668 len = sizeof(addr);
5669 ret = getsockname(server, (struct sockaddr*)&addr, &len);
5670 if (ret != 0)
5671 {
5672 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5673 goto end;
5674 }
5675
5676 ret = listen(server, 2);
5677 if (ret != 0)
5678 {
5679 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5680 goto end;
5681 }
5682
5683 ret = connect(src, (struct sockaddr*)&addr, sizeof(addr));
5684 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
5685 {
5686 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5687 goto end;
5688 }
5689
5690 ret = connect(src2, (struct sockaddr*)&addr, sizeof(addr));
5691 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
5692 {
5693 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5694 goto end;
5695 }
5696
5697 len = sizeof(addr);
5698 dst = accept(server, (struct sockaddr*)&addr, &len);
5699 if (dst == INVALID_SOCKET)
5700 {
5701 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5702 goto end;
5703 }
5704
5705 len = sizeof(addr);
5706 dst2 = accept(server, (struct sockaddr*)&addr, &len);
5707 if (dst2 == INVALID_SOCKET)
5708 {
5709 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5710 goto end;
5711 }
5712
5713 closesocket(server);
5714 server = INVALID_SOCKET;
5715
5716 /* On Windows it seems when a non-blocking socket sends to a
5717 blocking socket on the same host, the send() is BLOCKING,
5718 so make both sockets non-blocking. src is already non-blocking
5719 from the async select */
5720
5721 if (set_blocking(dst, FALSE))
5722 {
5723 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
5724 goto end;
5725 }
5726
5727 buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufferSize);
5728 if (buffer == NULL)
5729 {
5730 ok(0, "could not allocate memory for test\n");
5731 goto end;
5732 }
5733
5734 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5735 if (ov.hEvent == NULL)
5736 {
5737 ok(0, "could not create event object, errno = %d\n", GetLastError());
5738 goto end;
5739 }
5740
5741 ov2.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5742 if (ov2.hEvent == NULL)
5743 {
5744 ok(0, "could not create event object, errno = %d\n", GetLastError());
5745 goto end;
5746 }
5747
5748 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
5749 ok_event_seq(src, hEvent, connect_seq, NULL, 1);
5750 ok_event_seq(src2, hEvent2, connect_seq, NULL, 1);
5751 /* broken on all windows - FD_CONNECT error is garbage */
5752
5753 /* Test simple send/recv */
5754 SetLastError(0xdeadbeef);
5755 ret = send(dst, buffer, 100, 0);
5756 ok(ret == 100, "Failed to send buffer %d err %d\n", ret, GetLastError());
5757 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5758 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5759
5760 SetLastError(0xdeadbeef);
5761 ret = recv(src, buffer, 1, MSG_PEEK);
5762 ok(ret == 1, "Failed to peek at recv buffer %d err %d\n", ret, GetLastError());
5763 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5764 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5765
5766 SetLastError(0xdeadbeef);
5767 ret = recv(src, buffer, 50, 0);
5768 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5769 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5770 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5771
5772 ret = recv(src, buffer, 50, 0);
5773 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5774 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5775
5776 /* fun fact - events are re-enabled even on failure, but only for messages */
5777 ret = send(dst, "1", 1, 0);
5778 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5779 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5780
5781 ret = recv(src, buffer, -1, 0);
5782 ok(ret == SOCKET_ERROR && (GetLastError() == WSAEFAULT || GetLastError() == WSAENOBUFS),
5783 "Failed to recv buffer %d err %d\n", ret, GetLastError());
5784 if (useMessages)
5785 {
5786 broken_seq[0] = empty_seq; /* win9x */
5787 broken_seq[1] = NULL;
5788 todo_wine ok_event_seq(src, hEvent, read_seq, broken_seq, 0);
5789 }
5790 else
5791 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5792
5793 SetLastError(0xdeadbeef);
5794 ret = recv(src, buffer, 1, 0);
5795 ok(ret == 1, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5796 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5797 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5798
5799 /* Interaction with overlapped */
5800 bufs.len = sizeof(char);
5801 bufs.buf = buffer;
5802 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
5803 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
5804 "WSARecv failed - %d error %d\n", ret, GetLastError());
5805
5806 bufs.len = sizeof(char);
5807 bufs.buf = buffer+1;
5808 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov2, NULL);
5809 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
5810 "WSARecv failed - %d error %d\n", ret, GetLastError());
5811
5812 ret = send(dst, "12", 2, 0);
5813 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
5814 broken_seq[0] = read_read_seq; /* win9x */
5815 broken_seq[1] = NULL;
5816 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
5817
5818 dwRet = WaitForSingleObject(ov.hEvent, 100);
5819 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5820 if (dwRet == WAIT_OBJECT_0)
5821 {
5822 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
5823 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5824 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
5825 ok(buffer[0] == '1', "Got %c instead of 1\n", buffer[0]);
5826 }
5827
5828 dwRet = WaitForSingleObject(ov2.hEvent, 100);
5829 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5830 if (dwRet == WAIT_OBJECT_0)
5831 {
5832 bret = GetOverlappedResult((HANDLE)src, &ov2, &bytesReturned, FALSE);
5833 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5834 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
5835 ok(buffer[1] == '2', "Got %c instead of 2\n", buffer[1]);
5836 }
5837
5838 SetLastError(0xdeadbeef);
5839 ret = send(dst, "1", 1, 0);
5840 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5841 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5842 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5843
5844 ret = recv(src, buffer, 1, 0);
5845 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5846 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5847
5848 /* Notifications are delivered as soon as possible, blocked only on
5849 * async requests on the same type */
5850 bufs.len = sizeof(char);
5851 bufs.buf = buffer;
5852 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
5853 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
5854 "WSARecv failed - %d error %d\n", ret, GetLastError());
5855
5856 if (0) {
5857 ret = send(dst, "1", 1, MSG_OOB);
5858 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5859 ok_event_seq(src, hEvent, oob_seq, NULL, 0);
5860 }
5861
5862 dwRet = WaitForSingleObject(ov.hEvent, 100);
5863 ok(dwRet == WAIT_TIMEOUT, "OOB message activated read?: %d - %d\n", dwRet, GetLastError());
5864
5865 ret = send(dst, "2", 1, 0);
5866 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5867 broken_seq[0] = read_seq; /* win98 */
5868 broken_seq[1] = NULL;
5869 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
5870
5871 dwRet = WaitForSingleObject(ov.hEvent, 100);
5872 ok(dwRet == WAIT_OBJECT_0 || broken(dwRet == WAIT_TIMEOUT),
5873 "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5874 if (dwRet == WAIT_OBJECT_0)
5875 {
5876 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
5877 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5878 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
5879 ok(buffer[0] == '2', "Got %c instead of 2\n", buffer[0]);
5880 }
5881 else if (dwRet == WAIT_TIMEOUT)
5882 {
5883 /* this happens on win98. We get an FD_READ later on the next test */
5884 CancelIo((HANDLE) src);
5885 }
5886
5887 if (0) {
5888 ret = recv(src, buffer, 1, MSG_OOB);
5889 todo_wine ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5890 /* We get OOB notification, but no data on wine */
5891 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5892 }
5893
5894 /* Flood the send queue */
5895 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
5896 if (hThread == NULL)
5897 {
5898 ok(0, "CreateThread failed, error %d\n", GetLastError());
5899 goto end;
5900 }
5901
5902 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
5903 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5904
5905 /* Now if we send a ton of data and the 'server' does not drain it fast
5906 * enough (set drain_pause to be sure), the socket send buffer will only
5907 * take some of it, and we will get a short write. This will trigger
5908 * another FD_WRITE event as soon as data is sent and more space becomes
5909 * available, but not any earlier. */
5910 drain_pause = TRUE;
5911 do
5912 {
5913 ret = send(src, buffer, bufferSize, 0);
5914 } while (ret == bufferSize);
5915 drain_pause = FALSE;
5916 if (ret >= 0 || WSAGetLastError() == WSAEWOULDBLOCK)
5917 {
5918 Sleep(400); /* win9x */
5919 broken_seq[0] = read_write_seq;
5920 broken_seq[1] = NULL;
5921 ok_event_seq(src, hEvent, write_seq, broken_seq, 0);
5922 }
5923 else
5924 {
5925 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
5926 }
5927
5928 /* Test how FD_CLOSE is handled */
5929 ret = send(dst, "12", 2, 0);
5930 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
5931
5932 /* Wait a little and let the send complete */
5933 Sleep(100);
5934 closesocket(dst);
5935 dst = INVALID_SOCKET;
5936 Sleep(100);
5937
5938 /* We can never implement this in wine, best we can hope for is
5939 sending FD_CLOSE after the reads complete */
5940 broken_seq[0] = read_seq; /* win9x */
5941 broken_seq[1] = NULL;
5942 todo_wine ok_event_seq(src, hEvent, read_close_seq, broken_seq, 0);
5943
5944 ret = recv(src, buffer, 1, 0);
5945 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5946 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5947
5948 ret = recv(src, buffer, 1, 0);
5949 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5950 /* want it? it's here, but you can't have it */
5951 broken_seq[0] = close_seq; /* win9x */
5952 broken_seq[1] = NULL;
5953 todo_wine ok_event_seq(src, hEvent, empty_seq, /* wine sends FD_CLOSE here */
5954 broken_seq, 0);
5955
5956 /* Test how FD_CLOSE is handled */
5957 ret = send(dst2, "12", 2, 0);
5958 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
5959
5960 Sleep(200);
5961 shutdown(dst2, SD_SEND);
5962 Sleep(200);
5963
5964 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
5965 regressions, don't mark them as todo_wine, and mark windows as broken */
5966 broken_seq[0] = read_close_seq;
5967 broken_seq[1] = close_seq;
5968 broken_seq[2] = NULL;
5969 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
5970
5971 ret = recv(src2, buffer, 1, 0);
5972 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5973 broken_seq[0] = close_seq; /* win98 */
5974 broken_seq[1] = NULL;
5975 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
5976
5977 ret = recv(src2, buffer, 1, 0);
5978 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5979 broken_seq[0] = empty_seq;
5980 broken_seq[1] = NULL;
5981 ok_event_seq(src2, hEvent2, close_seq, broken_seq, 0);
5982
5983 ret = send(src2, "1", 1, 0);
5984 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
5985 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
5986
5987 ret = send(src2, "1", 1, 0);
5988 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
5989 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
5990
5991 if (useMessages)
5992 {
5993 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, 0);
5994 if (ret)
5995 {
5996 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5997 goto end;
5998 }
5999
6000 ret = set_blocking(src, TRUE);
6001 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6002
6003 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, 0);
6004 if (ret)
6005 {
6006 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6007 goto end;
6008 }
6009
6010 ret = set_blocking(src2, TRUE);
6011 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6012 }
6013 else
6014 {
6015 ret = WSAEventSelect(src, hEvent2, 0);
6016 if (ret)
6017 {
6018 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6019 goto end;
6020 }
6021
6022 ret = set_blocking(src, TRUE);
6023 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6024
6025 ret = WSAEventSelect(src2, hEvent2, 0);
6026 if (ret)
6027 {
6028 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
6029 goto end;
6030 }
6031
6032 ret = set_blocking(src2, TRUE);
6033 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
6034 }
6035
6036 end:
6037 if (src != INVALID_SOCKET)
6038 {
6039 flush_events(src, hEvent);
6040 closesocket(src);
6041 }
6042 if (src2 != INVALID_SOCKET)
6043 {
6044 flush_events(src2, hEvent2);
6045 closesocket(src2);
6046 }
6047 HeapFree(GetProcessHeap(), 0, buffer);
6048 if (server != INVALID_SOCKET)
6049 closesocket(server);
6050 if (dst != INVALID_SOCKET)
6051 closesocket(dst);
6052 if (dst2 != INVALID_SOCKET)
6053 closesocket(dst2);
6054 if (hThread != NULL)
6055 CloseHandle(hThread);
6056 if (hWnd != NULL)
6057 DestroyWindow(hWnd);
6058 if (hEvent != NULL)
6059 CloseHandle(hEvent);
6060 if (hEvent2 != NULL)
6061 CloseHandle(hEvent2);
6062 if (ov.hEvent != NULL)
6063 CloseHandle(ov.hEvent);
6064 if (ov2.hEvent != NULL)
6065 CloseHandle(ov2.hEvent);
6066 }
6067
6068 static void test_ipv6only(void)
6069 {
6070 SOCKET v4 = INVALID_SOCKET,
6071 v6 = INVALID_SOCKET;
6072 struct sockaddr_in sin4;
6073 struct sockaddr_in6 sin6;
6074 int ret;
6075
6076 memset(&sin4, 0, sizeof(sin4));
6077 sin4.sin_family = AF_INET;
6078 sin4.sin_port = htons(SERVERPORT);
6079
6080 memset(&sin6, 0, sizeof(sin6));
6081 sin6.sin6_family = AF_INET6;
6082 sin6.sin6_port = htons(SERVERPORT);
6083
6084 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
6085 if (v6 == INVALID_SOCKET) {
6086 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
6087 WSAGetLastError(), WSAEAFNOSUPPORT);
6088 goto end;
6089 }
6090 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
6091 if (ret) {
6092 skip("Could not bind IPv6 address (LastError: %d).\n",
6093 WSAGetLastError());
6094 goto end;
6095 }
6096
6097 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
6098 if (v4 == INVALID_SOCKET) {
6099 skip("Could not create IPv4 socket (LastError: %d).\n",
6100 WSAGetLastError());
6101 goto end;
6102 }
6103 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
6104 ok(!ret, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
6105 WSAGetLastError(), WSAEADDRINUSE);
6106
6107 end:
6108 if (v4 != INVALID_SOCKET)
6109 closesocket(v4);
6110 if (v6 != INVALID_SOCKET)
6111 closesocket(v6);
6112 }
6113
6114 static void test_WSASendMsg(void)
6115 {
6116 SOCKET sock, dst;
6117 struct sockaddr_in sendaddr, sockaddr;
6118 GUID WSASendMsg_GUID = WSAID_WSASENDMSG;
6119 LPFN_WSASENDMSG pWSASendMsg = NULL;
6120 char teststr[12] = "hello world", buffer[32];
6121 WSABUF iovec[2];
6122 WSAMSG msg;
6123 DWORD bytesSent, err;
6124 int ret, addrlen;
6125
6126 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
6127
6128 sock = socket(AF_INET, SOCK_DGRAM, 0);
6129 ok(sock != INVALID_SOCKET, "socket() failed\n");
6130
6131 /* Obtain the WSASendMsg function */
6132 WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsg_GUID, sizeof(WSASendMsg_GUID),
6133 &pWSASendMsg, sizeof(pWSASendMsg), &err, NULL, NULL);
6134 if (!pWSASendMsg)
6135 {
6136 closesocket(sock);
6137 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
6138 return;
6139 }
6140
6141 /* fake address for now */
6142 sendaddr.sin_family = AF_INET;
6143 sendaddr.sin_port = htons(139);
6144 sendaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6145
6146 memset(&msg, 0, sizeof(msg));
6147 iovec[0].buf = teststr;
6148 iovec[0].len = sizeof(teststr);
6149 iovec[1].buf = teststr;
6150 iovec[1].len = sizeof(teststr) / 2;
6151 msg.name = (struct sockaddr *) &sendaddr;
6152 msg.namelen = sizeof(sendaddr);
6153 msg.lpBuffers = iovec;
6154 msg.dwBufferCount = 1; /* send only one buffer for now */
6155
6156 WSASetLastError(0xdeadbeef);
6157 ret = pWSASendMsg(INVALID_SOCKET, &msg, 0, NULL, NULL, NULL);
6158 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6159 err = WSAGetLastError();
6160 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
6161
6162 WSASetLastError(0xdeadbeef);
6163 ret = pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL);
6164 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6165 err = WSAGetLastError();
6166 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6167
6168 WSASetLastError(0xdeadbeef);
6169 ret = pWSASendMsg(sock, NULL, 0, &bytesSent, NULL, NULL);
6170 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6171 err = WSAGetLastError();
6172 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6173
6174 WSASetLastError(0xdeadbeef);
6175 ret = pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL);
6176 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6177 err = WSAGetLastError();
6178 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6179
6180 closesocket(sock);
6181
6182 sock = socket(AF_INET, SOCK_DGRAM, 0);
6183 ok(sock != INVALID_SOCKET, "socket() failed\n");
6184
6185 dst = socket(AF_INET, SOCK_DGRAM, 0);
6186 ok(dst != INVALID_SOCKET, "socket() failed\n");
6187
6188 memset(&sockaddr, 0, sizeof(sockaddr));
6189 sockaddr.sin_family = AF_INET;
6190 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6191 ok(!bind(dst, (struct sockaddr*)&sockaddr, sizeof(sockaddr)),
6192 "bind should have worked\n");
6193
6194 /* read address to find out the port number to be used in send */
6195 memset(&sendaddr, 0, sizeof(sendaddr));
6196 addrlen = sizeof(sendaddr);
6197 ok(!getsockname(dst, (struct sockaddr *) &sendaddr, &addrlen),
6198 "getsockname should have worked\n");
6199 ok(sendaddr.sin_port, "socket port should be != 0\n");
6200
6201 /* ensure the sending socket is not bound */
6202 WSASetLastError(0xdeadbeef);
6203 addrlen = sizeof(sockaddr);
6204 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
6205 ok(ret == SOCKET_ERROR, "getsockname should have failed\n");
6206 err = WSAGetLastError();
6207 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
6208
6209 set_blocking(sock, TRUE);
6210
6211 bytesSent = 0;
6212 SetLastError(0xdeadbeef);
6213 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6214 ok(!ret, "WSASendMsg should have worked\n");
6215 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6216 "Expected 0, got %d\n", GetLastError());
6217 ok(bytesSent == iovec[0].len, "incorret bytes sent, expected %d, sent %d\n",
6218 iovec[0].len, bytesSent);
6219
6220 /* receive data */
6221 addrlen = sizeof(sockaddr);
6222 memset(buffer, 0, sizeof(buffer));
6223 SetLastError(0xdeadbeef);
6224 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
6225 ok(ret == bytesSent, "got %d, expected %d\n",
6226 ret, bytesSent);
6227 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6228
6229 /* A successful call to WSASendMsg must have bound the socket */
6230 addrlen = sizeof(sockaddr);
6231 sockaddr.sin_port = 0;
6232 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6233 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
6234 ok(!ret, "getsockname should have worked\n");
6235 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
6236 inet_ntoa(sockaddr.sin_addr));
6237 ok(sockaddr.sin_port, "sin_port should be != 0\n");
6238
6239 msg.dwBufferCount = 2; /* send both buffers */
6240
6241 bytesSent = 0;
6242 SetLastError(0xdeadbeef);
6243 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6244 ok(!ret, "WSASendMsg should have worked\n");
6245 ok(bytesSent == iovec[0].len + iovec[1].len, "incorret bytes sent, expected %d, sent %d\n",
6246 iovec[0].len + iovec[1].len, bytesSent);
6247 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6248 "Expected 0, got %d\n", GetLastError());
6249
6250 /* receive data */
6251 addrlen = sizeof(sockaddr);
6252 memset(buffer, 0, sizeof(buffer));
6253 SetLastError(0xdeadbeef);
6254 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
6255 ok(ret == bytesSent, "got %d, expected %d\n",
6256 ret, bytesSent);
6257 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6258
6259 closesocket(sock);
6260 closesocket(dst);
6261
6262 /* a bad call to WSASendMsg will also bind the socket */
6263 addrlen = sizeof(sockaddr);
6264 sockaddr.sin_port = 0;
6265 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6266 sock = socket(AF_INET, SOCK_DGRAM, 0);
6267 ok(sock != INVALID_SOCKET, "socket() failed\n");
6268 ok(pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
6269 todo_wine {
6270 ok(!getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have worked\n");
6271 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
6272 inet_ntoa(sockaddr.sin_addr));
6273 ok(sockaddr.sin_port, "sin_port should be > 0\n");
6274 }
6275 closesocket(sock);
6276
6277 /* a bad call without msg parameter will not trigger the auto-bind */
6278 sock = socket(AF_INET, SOCK_DGRAM, 0);
6279 ok(sock != INVALID_SOCKET, "socket() failed\n");
6280 ok(pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
6281 ok(getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have failed\n");
6282 err = WSAGetLastError();
6283 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
6284 closesocket(sock);
6285
6286 /* SOCK_STREAM sockets are not supported */
6287 bytesSent = 0;
6288 sock = socket(AF_INET, SOCK_STREAM, 0);
6289 ok(sock != INVALID_SOCKET, "socket() failed\n");
6290 SetLastError(0xdeadbeef);
6291 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6292 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6293 err = WSAGetLastError();
6294 todo_wine
6295 ok(err == WSAEINVAL, "expected 10014, got %d instead\n", err);
6296 closesocket(sock);
6297 }
6298
6299 static void test_WSASendTo(void)
6300 {
6301 SOCKET s;
6302 struct sockaddr_in addr;
6303 char buf[12] = "hello world";
6304 WSABUF data_buf;
6305 DWORD bytesSent;
6306 int ret;
6307
6308 addr.sin_family = AF_INET;
6309 addr.sin_port = htons(139);
6310 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6311 data_buf.len = sizeof(buf);
6312 data_buf.buf = buf;
6313
6314 if( (s = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
6315 ok(0, "socket() failed error: %d\n", WSAGetLastError());
6316 return;
6317 }
6318
6319 WSASetLastError(12345);
6320 ret = WSASendTo(INVALID_SOCKET, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
6321 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
6322 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
6323
6324 WSASetLastError(12345);
6325 ret = WSASendTo(s, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
6326 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
6327 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
6328
6329 WSASetLastError(12345);
6330 if(WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL)) {
6331 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
6332 return;
6333 }
6334 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
6335 "a successful call to WSASendTo()\n");
6336 }
6337
6338 static DWORD WINAPI recv_thread(LPVOID arg)
6339 {
6340 SOCKET sock = *(SOCKET *)arg;
6341 char buffer[32];
6342 WSABUF wsa;
6343 WSAOVERLAPPED ov;
6344 DWORD flags = 0;
6345
6346 wsa.buf = buffer;
6347 wsa.len = sizeof(buffer);
6348 ov.hEvent = WSACreateEvent();
6349 WSARecv(sock, &wsa, 1, NULL, &flags, &ov, NULL);
6350
6351 WaitForSingleObject(ov.hEvent, 1000);
6352 WSACloseEvent(ov.hEvent);
6353 return 0;
6354 }
6355
6356 static void test_WSARecv(void)
6357 {
6358 SOCKET src, dest, server = INVALID_SOCKET;
6359 char buf[20];
6360 WSABUF bufs;
6361 WSAOVERLAPPED ov;
6362 DWORD bytesReturned, flags, id;
6363 struct linger ling;
6364 struct sockaddr_in addr;
6365 int iret, len;
6366 DWORD dwret;
6367 BOOL bret;
6368 HANDLE thread;
6369
6370 tcp_socketpair(&src, &dest);
6371 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
6372 {
6373 skip("failed to create sockets\n");
6374 goto end;
6375 }
6376
6377 memset(&ov, 0, sizeof(ov));
6378 flags = 0;
6379 bufs.len = 2;
6380 bufs.buf = buf;
6381
6382 /* Send 4 bytes and receive in two calls of 2 */
6383 SetLastError(0xdeadbeef);
6384 iret = send(src, "test", 4, 0);
6385 ok(iret == 4, "Expected 4, got %d\n", iret);
6386 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6387 SetLastError(0xdeadbeef);
6388 bytesReturned = 0xdeadbeef;
6389 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, NULL, NULL);
6390 ok(!iret, "Expected 0, got %d\n", iret);
6391 ok(bytesReturned, "Expected 2, got %d\n", bytesReturned);
6392 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6393 SetLastError(0xdeadbeef);
6394 bytesReturned = 0xdeadbeef;
6395 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, NULL, NULL);
6396 ok(!iret, "Expected 0, got %d\n", iret);
6397 ok(bytesReturned, "Expected 2, got %d\n", bytesReturned);
6398 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6399
6400 bufs.len = 4;
6401 SetLastError(0xdeadbeef);
6402 iret = send(src, "test", 4, 0);
6403 ok(iret == 4, "Expected 4, got %d\n", iret);
6404 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6405 SetLastError(0xdeadbeef);
6406 bytesReturned = 0xdeadbeef;
6407 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, NULL, NULL);
6408 ok(!iret, "Expected 0, got %d\n", iret);
6409 ok(bytesReturned, "Expected 4, got %d\n", bytesReturned);
6410 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6411
6412 bufs.len = sizeof(buf);
6413
6414 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6415 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
6416 if (!ov.hEvent)
6417 goto end;
6418
6419 ling.l_onoff = 1;
6420 ling.l_linger = 0;
6421 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
6422 ok(!iret, "Failed to set linger %d\n", GetLastError());
6423
6424 iret = WSARecv(dest, &bufs, 1, NULL, &flags, &ov, NULL);
6425 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6426
6427 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
6428 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6429
6430 closesocket(src);
6431 src = INVALID_SOCKET;
6432
6433 dwret = WaitForSingleObject(ov.hEvent, 1000);
6434 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %d + errno %d\n", dwret, GetLastError());
6435
6436 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
6437 todo_wine ok(!bret && (GetLastError() == ERROR_NETNAME_DELETED || broken(GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */),
6438 "Did not get disconnect event: %d, error %d\n", bret, GetLastError());
6439 ok(bytesReturned == 0, "Bytes received is %d\n", bytesReturned);
6440 closesocket(dest);
6441 dest = INVALID_SOCKET;
6442
6443 src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
6444 ok(src != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6445 if (src == INVALID_SOCKET) goto end;
6446
6447 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
6448 ok(server != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6449 if (server == INVALID_SOCKET) goto end;
6450
6451 memset(&addr, 0, sizeof(addr));
6452 addr.sin_family = AF_INET;
6453 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6454 iret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
6455 if (iret) goto end;
6456
6457 len = sizeof(addr);
6458 iret = getsockname(server, (struct sockaddr *)&addr, &len);
6459 if (iret) goto end;
6460
6461 iret = listen(server, 1);
6462 if (iret) goto end;
6463
6464 iret = connect(src, (struct sockaddr *)&addr, sizeof(addr));
6465 if (iret) goto end;
6466
6467 len = sizeof(addr);
6468 dest = accept(server, (struct sockaddr *)&addr, &len);
6469 ok(dest != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6470 if (dest == INVALID_SOCKET) goto end;
6471
6472 send(src, "test message", sizeof("test message"), 0);
6473 thread = CreateThread(NULL, 0, recv_thread, &dest, 0, &id);
6474 WaitForSingleObject(thread, 3000);
6475 CloseHandle(thread);
6476
6477 end:
6478 if (server != INVALID_SOCKET)
6479 closesocket(server);
6480 if (dest != INVALID_SOCKET)
6481 closesocket(dest);
6482 if (src != INVALID_SOCKET)
6483 closesocket(src);
6484 if (ov.hEvent)
6485 WSACloseEvent(ov.hEvent);
6486 }
6487
6488 #define POLL_CLEAR() ix = 0
6489 #define POLL_SET(s, ev) {fds[ix].fd = s; fds[ix++].events = ev;}
6490 #define POLL_ISSET(s, rev) poll_isset(fds, ix, s, rev)
6491 static BOOL poll_isset(WSAPOLLFD *fds, int max, SOCKET s, int rev)
6492 {
6493 int k;
6494 for (k = 0; k < max; k++)
6495 if (fds[k].fd == s && (fds[k].revents == rev)) return TRUE;
6496 return FALSE;
6497 }
6498
6499 static void test_WSAPoll(void)
6500 {
6501 int ix, ret, err, poll_timeout;
6502 SOCKET fdListen, fdRead, fdWrite;
6503 struct sockaddr_in address;
6504 socklen_t len;
6505 static char tmp_buf[1024];
6506 WSAPOLLFD fds[16];
6507 HANDLE thread_handle;
6508 DWORD id;
6509
6510 if (!pWSAPoll) /* >= Vista */
6511 {
6512 skip("WSAPoll is unsupported, some tests will be skipped.\n");
6513 return;
6514 }
6515
6516 /* Invalid parameters test */
6517 SetLastError(0xdeadbeef);
6518 ret = pWSAPoll(NULL, 0, 0);
6519 err = GetLastError();
6520 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6521 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
6522 SetLastError(0xdeadbeef);
6523 ret = pWSAPoll(NULL, 1, 0);
6524 err = GetLastError();
6525 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6526 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
6527 SetLastError(0xdeadbeef);
6528 ret = pWSAPoll(NULL, 0, 1);
6529 err = GetLastError();
6530 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6531 ok(err == WSAEINVAL, "expected 10022, got %d\n", err);
6532 SetLastError(0xdeadbeef);
6533 ret = pWSAPoll(NULL, 1, 1);
6534 err = GetLastError();
6535 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6536 ok(err == WSAEFAULT, "expected 10014, got %d\n", err);
6537
6538 /* WSAPoll() tries to mime the unix poll() call. The following tests do:
6539 * - check if a connection attempt ended with success or error;
6540 * - check if a pending connection is waiting for acceptance;
6541 * - check for data to read, availability for write and OOB data
6542 */
6543 memset(&address, 0, sizeof(address));
6544 address.sin_addr.s_addr = inet_addr("127.0.0.1");
6545 address.sin_family = AF_INET;
6546 len = sizeof(address);
6547 fdListen = setup_server_socket(&address, &len);
6548 poll_timeout = 100;
6549
6550 /* When no events are pending poll returns 0 with no error */
6551 POLL_CLEAR();
6552 POLL_SET(fdListen, POLLIN);
6553 ret = pWSAPoll(fds, ix, poll_timeout);
6554 ok(ret == 0, "expected 0, got %d\n", ret);
6555
6556 /* Test listening socket connection attempt notifications */
6557 fdWrite = setup_connector_socket(&address, len, TRUE);
6558 POLL_CLEAR();
6559 POLL_SET(fdListen, POLLIN | POLLOUT);
6560 ret = pWSAPoll(fds, ix, poll_timeout);
6561 ok(ret == 1, "expected 1, got %d\n", ret);
6562 ok(POLL_ISSET(fdListen, POLLRDNORM), "fdListen socket events incorrect\n");
6563 len = sizeof(address);
6564 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
6565 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
6566
6567 /* Test client side connection attempt notifications */
6568 POLL_CLEAR();
6569 POLL_SET(fdListen, POLLIN | POLLOUT);
6570 POLL_SET(fdRead, POLLIN | POLLOUT);
6571 POLL_SET(fdWrite, POLLIN | POLLOUT);
6572 ret = pWSAPoll(fds, ix, poll_timeout);
6573 ok(ret == 2, "expected 2, got %d\n", ret);
6574 ok(POLL_ISSET(fdWrite, POLLWRNORM), "fdWrite socket events incorrect\n");
6575 ok(POLL_ISSET(fdRead, POLLWRNORM), "fdRead socket events incorrect\n");
6576 len = sizeof(id);
6577 id = 0xdeadbeef;
6578 err = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
6579 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
6580 ok(id == 0, "expected 0, got %d\n", id);
6581
6582 /* Test data receiving notifications */
6583 ret = send(fdWrite, "1234", 4, 0);
6584 ok(ret == 4, "expected 4, got %d\n", ret);
6585 POLL_CLEAR();
6586 POLL_SET(fdListen, POLLIN | POLLOUT);
6587 POLL_SET(fdRead, POLLIN);
6588 ret = pWSAPoll(fds, ix, poll_timeout);
6589 ok(ret == 1, "expected 1, got %d\n", ret);
6590 ok(POLL_ISSET(fdRead, POLLRDNORM), "fdRead socket events incorrect\n");
6591 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
6592 ok(ret == 4, "expected 4, got %d\n", ret);
6593 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
6594
6595 /* Test OOB data notifications */
6596 ret = send(fdWrite, "A", 1, MSG_OOB);
6597 ok(ret == 1, "expected 1, got %d\n", ret);
6598 POLL_CLEAR();
6599 POLL_SET(fdListen, POLLIN | POLLOUT);
6600 POLL_SET(fdRead, POLLIN);
6601 ret = pWSAPoll(fds, ix, poll_timeout);
6602 ok(ret == 1, "expected 1, got %d\n", ret);
6603 ok(POLL_ISSET(fdRead, POLLRDBAND), "fdRead socket events incorrect\n");
6604 tmp_buf[0] = 0xAF;
6605 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
6606 ok(ret == 1, "expected 1, got %d\n", ret);
6607 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
6608
6609 /* If the socket is OOBINLINED the notification is like normal data */
6610 ret = 1;
6611 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
6612 ok(ret == 0, "expected 0, got %d\n", ret);
6613 ret = send(fdWrite, "A", 1, MSG_OOB);
6614 ok(ret == 1, "expected 1, got %d\n", ret);
6615 POLL_CLEAR();
6616 POLL_SET(fdListen, POLLIN | POLLOUT);
6617 POLL_SET(fdRead, POLLIN | POLLOUT);
6618 ret = pWSAPoll(fds, ix, poll_timeout);
6619 ok(ret == 1, "expected 1, got %d\n", ret);
6620 tmp_buf[0] = 0xAF;
6621 SetLastError(0xdeadbeef);
6622 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
6623 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
6624 ok(GetLastError() == WSAEINVAL, "expected 10022, got %d\n", GetLastError());
6625 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
6626 ok(ret == 1, "expected 1, got %d\n", ret);
6627 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
6628
6629 /* Test connection closed notifications */
6630 ret = closesocket(fdRead);
6631 ok(ret == 0, "expected 0, got %d\n", ret);
6632 POLL_CLEAR();
6633 POLL_SET(fdListen, POLLIN | POLLOUT);
6634 POLL_SET(fdWrite, POLLIN);
6635 ret = pWSAPoll(fds, ix, poll_timeout);
6636 ok(ret == 1, "expected 1, got %d\n", ret);
6637 todo_wine
6638 ok(POLL_ISSET(fdWrite, POLLHUP), "fdWrite socket events incorrect\n");
6639 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
6640 ok(ret == 0, "expected 0, got %d\n", ret);
6641
6642 /* When a connection is attempted to a non-listening socket due to a bug
6643 * in the MS code it will never be notified. This is a long standing issue
6644 * that will never be fixed for compatibility reasons so we have to deal
6645 * with it manually. */
6646 ret = closesocket(fdWrite);
6647 ok(ret == 0, "expected 0, got %d\n", ret);
6648 ret = closesocket(fdListen);
6649 ok(ret == 0, "expected 0, got %d\n", ret);
6650 len = sizeof(address);
6651 fdWrite = setup_connector_socket(&address, len, TRUE);
6652 POLL_CLEAR();
6653 POLL_SET(fdWrite, POLLIN | POLLOUT);
6654 poll_timeout = 2000;
6655 ret = pWSAPoll(fds, ix, poll_timeout);
6656 todo_wine
6657 ok(ret == 0, "expected 0, got %d\n", ret);
6658 len = sizeof(id);
6659 id = 0xdeadbeef;
6660 err = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
6661 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
6662 ok(id == WSAECONNREFUSED, "expected 10061, got %d\n", id);
6663 closesocket(fdWrite);
6664
6665 /* Try poll() on a closed socket after connection */
6666 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
6667 closesocket(fdRead);
6668 POLL_CLEAR();
6669 POLL_SET(fdWrite, POLLIN | POLLOUT);
6670 POLL_SET(fdRead, POLLIN | POLLOUT);
6671 ret = pWSAPoll(fds, ix, poll_timeout);
6672 ok(ret == 1, "expected 1, got %d\n", ret);
6673 ok(POLL_ISSET(fdRead, POLLNVAL), "fdRead socket events incorrect\n");
6674 POLL_CLEAR();
6675 POLL_SET(fdWrite, POLLIN | POLLOUT);
6676 ret = pWSAPoll(fds, ix, poll_timeout);
6677 ok(ret == 1, "expected 1, got %d\n", ret);
6678 todo_wine
6679 ok(POLL_ISSET(fdWrite, POLLWRNORM | POLLHUP) || broken(POLL_ISSET(fdWrite, POLLWRNORM)) /* <= 2008 */,
6680 "fdWrite socket events incorrect\n");
6681 closesocket(fdWrite);
6682
6683 /* Close the socket currently being polled in a thread */
6684 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
6685 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
6686 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
6687 POLL_CLEAR();
6688 POLL_SET(fdWrite, POLLIN | POLLOUT);
6689 ret = pWSAPoll(fds, ix, poll_timeout);
6690 ok(ret == 1, "expected 1, got %d\n", ret);
6691 ok(POLL_ISSET(fdWrite, POLLWRNORM), "fdWrite socket events incorrect\n");
6692 WaitForSingleObject (thread_handle, 1000);
6693 closesocket(fdRead);
6694 /* test again with less flags - behavior changes */
6695 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
6696 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
6697 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
6698 POLL_CLEAR();
6699 POLL_SET(fdWrite, POLLIN);
6700 ret = pWSAPoll(fds, ix, poll_timeout);
6701 ok(ret == 1, "expected 1, got %d\n", ret);
6702 todo_wine
6703 ok(POLL_ISSET(fdWrite, POLLNVAL), "fdWrite socket events incorrect\n");
6704 WaitForSingleObject (thread_handle, 1000);
6705 closesocket(fdRead);
6706 }
6707 #undef POLL_SET
6708 #undef POLL_ISSET
6709 #undef POLL_CLEAR
6710
6711 static void test_GetAddrInfoW(void)
6712 {
6713 static const WCHAR port[] = {'8','0',0};
6714 static const WCHAR empty[] = {0};
6715 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
6716 static const WCHAR nxdomain[] =
6717 {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
6718 static const WCHAR zero[] = {'0',0};
6719 int i, ret;
6720 ADDRINFOW *result, *result2, *p, hint;
6721 WCHAR name[256];
6722 DWORD size = sizeof(name)/sizeof(WCHAR);
6723
6724 if (!pGetAddrInfoW || !pFreeAddrInfoW)
6725 {
6726 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
6727 return;
6728 }
6729 memset(&hint, 0, sizeof(ADDRINFOW));
6730 name[0] = 0;
6731 GetComputerNameExW( ComputerNamePhysicalDnsHostname, name, &size );
6732
6733 result = (ADDRINFOW *)0xdeadbeef;
6734 WSASetLastError(0xdeadbeef);
6735 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
6736 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6737 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6738 ok(result == NULL, "got %p\n", result);
6739
6740 result = NULL;
6741 WSASetLastError(0xdeadbeef);
6742 ret = pGetAddrInfoW(empty, NULL, NULL, &result);
6743 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6744 ok(result != NULL, "GetAddrInfoW failed\n");
6745 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6746 pFreeAddrInfoW(result);
6747
6748 result = NULL;
6749 ret = pGetAddrInfoW(NULL, zero, NULL, &result);
6750 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6751 ok(result != NULL, "GetAddrInfoW failed\n");
6752
6753 result2 = NULL;
6754 ret = pGetAddrInfoW(NULL, empty, NULL, &result2);
6755 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6756 ok(result2 != NULL, "GetAddrInfoW failed\n");
6757 compare_addrinfow(result, result2);
6758 pFreeAddrInfoW(result);
6759 pFreeAddrInfoW(result2);
6760
6761 result = NULL;
6762 ret = pGetAddrInfoW(empty, zero, NULL, &result);
6763 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6764 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6765 ok(result != NULL, "GetAddrInfoW failed\n");
6766
6767 result2 = NULL;
6768 ret = pGetAddrInfoW(empty, empty, NULL, &result2);
6769 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6770 ok(result2 != NULL, "GetAddrInfoW failed\n");
6771 compare_addrinfow(result, result2);
6772 pFreeAddrInfoW(result);
6773 pFreeAddrInfoW(result2);
6774
6775 result = NULL;
6776 ret = pGetAddrInfoW(localhost, NULL, NULL, &result);
6777 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6778 pFreeAddrInfoW(result);
6779
6780 result = NULL;
6781 ret = pGetAddrInfoW(localhost, empty, NULL, &result);
6782 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6783 pFreeAddrInfoW(result);
6784
6785 result = NULL;
6786 ret = pGetAddrInfoW(localhost, zero, NULL, &result);
6787 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6788 pFreeAddrInfoW(result);
6789
6790 result = NULL;
6791 ret = pGetAddrInfoW(localhost, port, NULL, &result);
6792 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6793 pFreeAddrInfoW(result);
6794
6795 result = NULL;
6796 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
6797 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6798 pFreeAddrInfoW(result);
6799
6800 result = NULL;
6801 SetLastError(0xdeadbeef);
6802 ret = pGetAddrInfoW(localhost, port, &hint, &result);
6803 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6804 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6805 pFreeAddrInfoW(result);
6806
6807 /* try to get information from the computer name, result is the same
6808 * as if requesting with an empty host name. */
6809 ret = pGetAddrInfoW(name, NULL, NULL, &result);
6810 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6811 ok(result != NULL, "GetAddrInfoW failed\n");
6812
6813 ret = pGetAddrInfoW(empty, NULL, NULL, &result2);
6814 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6815 ok(result != NULL, "GetAddrInfoW failed\n");
6816 compare_addrinfow(result, result2);
6817 pFreeAddrInfoW(result);
6818 pFreeAddrInfoW(result2);
6819
6820 ret = pGetAddrInfoW(name, empty, NULL, &result);
6821 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6822 ok(result != NULL, "GetAddrInfoW failed\n");
6823
6824 ret = pGetAddrInfoW(empty, empty, NULL, &result2);
6825 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6826 ok(result != NULL, "GetAddrInfoW failed\n");
6827 compare_addrinfow(result, result2);
6828 pFreeAddrInfoW(result);
6829 pFreeAddrInfoW(result2);
6830
6831 result = (ADDRINFOW *)0xdeadbeef;
6832 WSASetLastError(0xdeadbeef);
6833 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
6834 if(ret == 0)
6835 {
6836 skip("nxdomain returned success. Broken ISP redirects?\n");
6837 return;
6838 }
6839 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6840 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6841 ok(result == NULL, "got %p\n", result);
6842
6843 result = (ADDRINFOW *)0xdeadbeef;
6844 WSASetLastError(0xdeadbeef);
6845 ret = pGetAddrInfoW(nxdomain, NULL, NULL, &result);
6846 if(ret == 0)
6847 {
6848 skip("nxdomain returned success. Broken ISP redirects?\n");
6849 return;
6850 }
6851 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6852 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6853 ok(result == NULL, "got %p\n", result);
6854
6855 for (i = 0;i < (sizeof(hinttests) / sizeof(hinttests[0]));i++)
6856 {
6857 hint.ai_family = hinttests[i].family;
6858 hint.ai_socktype = hinttests[i].socktype;
6859 hint.ai_protocol = hinttests[i].protocol;
6860
6861 result = NULL;
6862 SetLastError(0xdeadbeef);
6863 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
6864 if (!ret)
6865 {
6866 if (hinttests[i].error)
6867 ok(0, "test %d: GetAddrInfoW succeeded unexpectedly\n", i);
6868 else
6869 {
6870 p = result;
6871 do
6872 {
6873 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
6874 if (hinttests[i].family == AF_UNSPEC)
6875 ok(p->ai_family == AF_INET || p->ai_family == AF_INET6,
6876 "test %d: expected AF_INET or AF_INET6, got %d\n",
6877 i, p->ai_family);
6878 else
6879 ok(p->ai_family == hinttests[i].family,
6880 "test %d: expected family %d, got %d\n",
6881 i, hinttests[i].family, p->ai_family);
6882
6883 ok(p->ai_socktype == hinttests[i].socktype,
6884 "test %d: expected type %d, got %d\n",
6885 i, hinttests[i].socktype, p->ai_socktype);
6886 ok(p->ai_protocol == hinttests[i].protocol,
6887 "test %d: expected protocol %d, got %d\n",
6888 i, hinttests[i].protocol, p->ai_protocol);
6889 p = p->ai_next;
6890 }
6891 while (p);
6892 }
6893 pFreeAddrInfoW(result);
6894 }
6895 else
6896 {
6897 DWORD err = WSAGetLastError();
6898 if (hinttests[i].error)
6899 ok(hinttests[i].error == err, "test %d: GetAddrInfoW failed with error %d, expected %d\n",
6900 i, err, hinttests[i].error);
6901 else
6902 ok(0, "test %d: GetAddrInfoW failed with %d (err %d)\n", i, ret, err);
6903 }
6904 }
6905 }
6906
6907 static void test_getaddrinfo(void)
6908 {
6909 int i, ret;
6910 ADDRINFOA *result, *result2, *p, hint;
6911 CHAR name[256];
6912 DWORD size = sizeof(name);
6913
6914 if (!pgetaddrinfo || !pfreeaddrinfo)
6915 {
6916 win_skip("getaddrinfo and/or freeaddrinfo not present\n");
6917 return;
6918 }
6919 memset(&hint, 0, sizeof(ADDRINFOA));
6920 GetComputerNameExA( ComputerNamePhysicalDnsHostname, name, &size );
6921
6922 result = (ADDRINFOA *)0xdeadbeef;
6923 WSASetLastError(0xdeadbeef);
6924 ret = pgetaddrinfo(NULL, NULL, NULL, &result);
6925 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6926 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6927 ok(result == NULL, "got %p\n", result);
6928
6929 result = NULL;
6930 WSASetLastError(0xdeadbeef);
6931 ret = pgetaddrinfo("", NULL, NULL, &result);
6932 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6933 ok(result != NULL, "getaddrinfo failed\n");
6934 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6935 pfreeaddrinfo(result);
6936
6937 result = NULL;
6938 ret = pgetaddrinfo(NULL, "0", NULL, &result);
6939 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6940 ok(result != NULL, "getaddrinfo failed\n");
6941
6942 result2 = NULL;
6943 ret = pgetaddrinfo(NULL, "", NULL, &result2);
6944 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6945 ok(result2 != NULL, "getaddrinfo failed\n");
6946 compare_addrinfo(result, result2);
6947 pfreeaddrinfo(result);
6948 pfreeaddrinfo(result2);
6949
6950 result = NULL;
6951 WSASetLastError(0xdeadbeef);
6952 ret = pgetaddrinfo("", "0", NULL, &result);
6953 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6954 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6955 ok(result != NULL, "getaddrinfo failed\n");
6956
6957 result2 = NULL;
6958 ret = pgetaddrinfo("", "", NULL, &result2);
6959 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6960 ok(result2 != NULL, "getaddrinfo failed\n");
6961 compare_addrinfo(result, result2);
6962 pfreeaddrinfo(result);
6963 pfreeaddrinfo(result2);
6964
6965 result = NULL;
6966 ret = pgetaddrinfo("localhost", NULL, NULL, &result);
6967 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6968 pfreeaddrinfo(result);
6969
6970 result = NULL;
6971 ret = pgetaddrinfo("localhost", "", NULL, &result);
6972 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6973 pfreeaddrinfo(result);
6974
6975 result = NULL;
6976 ret = pgetaddrinfo("localhost", "0", NULL, &result);
6977 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6978 pfreeaddrinfo(result);
6979
6980 result = NULL;
6981 ret = pgetaddrinfo("localhost", "80", NULL, &result);
6982 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6983 pfreeaddrinfo(result);
6984
6985 result = NULL;
6986 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
6987 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6988 pfreeaddrinfo(result);
6989
6990 result = NULL;
6991 WSASetLastError(0xdeadbeef);
6992 ret = pgetaddrinfo("localhost", "80", &hint, &result);
6993 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6994 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6995 pfreeaddrinfo(result);
6996
6997 /* try to get information from the computer name, result is the same
6998 * as if requesting with an empty host name. */
6999 ret = pgetaddrinfo(name, NULL, NULL, &result);
7000 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7001 ok(result != NULL, "GetAddrInfoW failed\n");
7002
7003 ret = pgetaddrinfo("", NULL, NULL, &result2);
7004 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7005 ok(result != NULL, "GetAddrInfoW failed\n");
7006 compare_addrinfo(result, result2);
7007 pfreeaddrinfo(result);
7008 pfreeaddrinfo(result2);
7009
7010 ret = pgetaddrinfo(name, "", NULL, &result);
7011 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7012 ok(result != NULL, "GetAddrInfoW failed\n");
7013
7014 ret = pgetaddrinfo("", "", NULL, &result2);
7015 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
7016 ok(result != NULL, "GetAddrInfoW failed\n");
7017 compare_addrinfo(result, result2);
7018 pfreeaddrinfo(result);
7019 pfreeaddrinfo(result2);
7020
7021 result = (ADDRINFOA *)0xdeadbeef;
7022 WSASetLastError(0xdeadbeef);
7023 ret = pgetaddrinfo("nxdomain.codeweavers.com", NULL, NULL, &result);
7024 if(ret == 0)
7025 {
7026 skip("nxdomain returned success. Broken ISP redirects?\n");
7027 return;
7028 }
7029 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
7030 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
7031 ok(result == NULL, "got %p\n", result);
7032
7033 for (i = 0;i < (sizeof(hinttests) / sizeof(hinttests[0]));i++)
7034 {
7035 hint.ai_family = hinttests[i].family;
7036 hint.ai_socktype = hinttests[i].socktype;
7037 hint.ai_protocol = hinttests[i].protocol;
7038
7039 result = NULL;
7040 SetLastError(0xdeadbeef);
7041 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
7042 if(!ret)
7043 {
7044 if (hinttests[i].error)
7045 ok(0, "test %d: getaddrinfo succeeded unexpectedly\n", i);
7046 else
7047 {
7048 p = result;
7049 do
7050 {
7051 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
7052 if (hinttests[i].family == AF_UNSPEC)
7053 ok(p->ai_family == AF_INET || p->ai_family == AF_INET6,
7054 "test %d: expected AF_INET or AF_INET6, got %d\n",
7055 i, p->ai_family);
7056 else
7057 ok(p->ai_family == hinttests[i].family,
7058 "test %d: expected family %d, got %d\n",
7059 i, hinttests[i].family, p->ai_family);
7060
7061 ok(p->ai_socktype == hinttests[i].socktype,
7062 "test %d: expected type %d, got %d\n",
7063 i, hinttests[i].socktype, p->ai_socktype);
7064 ok(p->ai_protocol == hinttests[i].protocol,
7065 "test %d: expected protocol %d, got %d\n",
7066 i, hinttests[i].protocol, p->ai_protocol);
7067 p = p->ai_next;
7068 }
7069 while (p);
7070 }
7071 pfreeaddrinfo(result);
7072 }
7073 else
7074 {
7075 DWORD err = WSAGetLastError();
7076 if (hinttests[i].error)
7077 ok(hinttests[i].error == err, "test %d: getaddrinfo failed with error %d, expected %d\n",
7078 i, err, hinttests[i].error);
7079 else
7080 ok(0, "test %d: getaddrinfo failed with %d (err %d)\n", i, ret, err);
7081 }
7082 }
7083 }
7084
7085 static void test_ConnectEx(void)
7086 {
7087 SOCKET listener = INVALID_SOCKET;
7088 SOCKET acceptor = INVALID_SOCKET;
7089 SOCKET connector = INVALID_SOCKET;
7090 struct sockaddr_in address, conaddress;
7091 int addrlen;
7092 OVERLAPPED overlapped;
7093 LPFN_CONNECTEX pConnectEx;
7094 GUID connectExGuid = WSAID_CONNECTEX;
7095 DWORD bytesReturned;
7096 char buffer[1024];
7097 BOOL bret;
7098 DWORD dwret;
7099 int iret;
7100
7101 memset(&overlapped, 0, sizeof(overlapped));
7102
7103 listener = socket(AF_INET, SOCK_STREAM, 0);
7104 if (listener == INVALID_SOCKET) {
7105 skip("could not create listener socket, error %d\n", WSAGetLastError());
7106 goto end;
7107 }
7108
7109 connector = socket(AF_INET, SOCK_STREAM, 0);
7110 if (connector == INVALID_SOCKET) {
7111 skip("could not create connector socket, error %d\n", WSAGetLastError());
7112 goto end;
7113 }
7114
7115 memset(&address, 0, sizeof(address));
7116 address.sin_family = AF_INET;
7117 address.sin_addr.s_addr = inet_addr("127.0.0.1");
7118 iret = bind(listener, (struct sockaddr*)&address, sizeof(address));
7119 if (iret != 0) {
7120 skip("failed to bind, error %d\n", WSAGetLastError());
7121 goto end;
7122 }
7123
7124 addrlen = sizeof(address);
7125 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
7126 if (iret != 0) {
7127 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
7128 goto end;
7129 }
7130
7131 if (set_blocking(listener, TRUE)) {
7132 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7133 goto end;
7134 }
7135
7136 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectExGuid, sizeof(connectExGuid),
7137 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
7138 if (iret) {
7139 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret, WSAGetLastError());
7140 goto end;
7141 }
7142
7143 bret = pConnectEx(INVALID_SOCKET, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
7144 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "ConnectEx on invalid socket "
7145 "returned %d + errno %d\n", bret, WSAGetLastError());
7146
7147 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
7148 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "ConnectEx on a unbound socket "
7149 "returned %d + errno %d\n", bret, WSAGetLastError());
7150 if (bret == TRUE || WSAGetLastError() != WSAEINVAL)
7151 {
7152 acceptor = accept(listener, NULL, NULL);
7153 if (acceptor != INVALID_SOCKET) {
7154 closesocket(acceptor);
7155 acceptor = INVALID_SOCKET;
7156 }
7157
7158 closesocket(connector);
7159 connector = socket(AF_INET, SOCK_STREAM, 0);
7160 if (connector == INVALID_SOCKET) {
7161 skip("could not create connector socket, error %d\n", WSAGetLastError());
7162 goto end;
7163 }
7164 }
7165
7166 /* ConnectEx needs a bound socket */
7167 memset(&conaddress, 0, sizeof(conaddress));
7168 conaddress.sin_family = AF_INET;
7169 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
7170 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
7171 if (iret != 0) {
7172 skip("failed to bind, error %d\n", WSAGetLastError());
7173 goto end;
7174 }
7175
7176 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, NULL);
7177 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "ConnectEx on a NULL overlapped "
7178 "returned %d + errno %d\n", bret, WSAGetLastError());
7179
7180 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
7181 if (overlapped.hEvent == NULL) {
7182 skip("could not create event object, errno = %d\n", GetLastError());
7183 goto end;
7184 }
7185
7186 iret = listen(listener, 1);
7187 if (iret != 0) {
7188 skip("listening failed, errno = %d\n", WSAGetLastError());
7189 goto end;
7190 }
7191
7192 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
7193 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
7194 "returned %d + errno %d\n", bret, WSAGetLastError());
7195 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
7196 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
7197
7198 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
7199 ok(bret, "Connecting failed, error %d\n", GetLastError());
7200 ok(bytesReturned == 0, "Bytes sent is %d\n", bytesReturned);
7201
7202 closesocket(connector);
7203 connector = socket(AF_INET, SOCK_STREAM, 0);
7204 if (connector == INVALID_SOCKET) {
7205 skip("could not create connector socket, error %d\n", WSAGetLastError());
7206 goto end;
7207 }
7208 /* ConnectEx needs a bound socket */
7209 memset(&conaddress, 0, sizeof(conaddress));
7210 conaddress.sin_family = AF_INET;
7211 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
7212 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
7213 if (iret != 0) {
7214 skip("failed to bind, error %d\n", WSAGetLastError());
7215 goto end;
7216 }
7217
7218 acceptor = accept(listener, NULL, NULL);
7219 if (acceptor != INVALID_SOCKET) {
7220 closesocket(acceptor);
7221 }
7222
7223 buffer[0] = '1';
7224 buffer[1] = '2';
7225 buffer[2] = '3';
7226 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, buffer, 3, &bytesReturned, &overlapped);
7227 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
7228 "returned %d + errno %d\n", bret, WSAGetLastError());
7229 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
7230 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
7231
7232 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
7233 ok(bret, "Connecting failed, error %d\n", GetLastError());
7234 ok(bytesReturned == 3, "Bytes sent is %d\n", bytesReturned);
7235
7236 acceptor = accept(listener, NULL, NULL);
7237 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
7238
7239 bytesReturned = recv(acceptor, buffer, 3, 0);
7240 buffer[4] = 0;
7241 ok(bytesReturned == 3, "Didn't get all sent data, got only %d\n", bytesReturned);
7242 ok(buffer[0] == '1' && buffer[1] == '2' && buffer[2] == '3',
7243 "Failed to get the right data, expected '123', got '%s'\n", buffer);
7244
7245 closesocket(connector);
7246 connector = socket(AF_INET, SOCK_STREAM, 0);
7247 if (connector == INVALID_SOCKET) {
7248 skip("could not create connector socket, error %d\n", WSAGetLastError());
7249 goto end;
7250 }
7251 /* ConnectEx needs a bound socket */
7252 memset(&conaddress, 0, sizeof(conaddress));
7253 conaddress.sin_family = AF_INET;
7254 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
7255 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
7256 if (iret != 0) {
7257 skip("failed to bind, error %d\n", WSAGetLastError());
7258 goto end;
7259 }
7260
7261 if (acceptor != INVALID_SOCKET) {
7262 closesocket(acceptor);
7263 acceptor = INVALID_SOCKET;
7264 }
7265
7266 /* Connect with error */
7267 closesocket(listener);
7268 listener = INVALID_SOCKET;
7269
7270 address.sin_port = htons(1);
7271
7272 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
7273 ok(bret == FALSE && GetLastError(), "ConnectEx to bad destination failed: "
7274 "returned %d + errno %d\n", bret, GetLastError());
7275
7276 if (GetLastError() == ERROR_IO_PENDING)
7277 {
7278 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
7279 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
7280
7281 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
7282 ok(bret == FALSE && GetLastError() == ERROR_CONNECTION_REFUSED,
7283 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
7284 }
7285 else {
7286 ok(GetLastError() == WSAECONNREFUSED,
7287 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
7288 }
7289
7290 end:
7291 if (overlapped.hEvent)
7292 WSACloseEvent(overlapped.hEvent);
7293 if (listener != INVALID_SOCKET)
7294 closesocket(listener);
7295 if (acceptor != INVALID_SOCKET)
7296 closesocket(acceptor);
7297 if (connector != INVALID_SOCKET)
7298 closesocket(connector);
7299 }
7300
7301 static void test_AcceptEx(void)
7302 {
7303 SOCKET listener = INVALID_SOCKET;
7304 SOCKET acceptor = INVALID_SOCKET;
7305 SOCKET connector = INVALID_SOCKET;
7306 SOCKET connector2 = INVALID_SOCKET;
7307 struct sockaddr_in bindAddress, peerAddress, *readBindAddress, *readRemoteAddress;
7308 int socklen, optlen;
7309 GUID acceptExGuid = WSAID_ACCEPTEX, getAcceptExGuid = WSAID_GETACCEPTEXSOCKADDRS;
7310 LPFN_ACCEPTEX pAcceptEx = NULL;
7311 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs = NULL;
7312 fd_set fds_accept, fds_send;
7313 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
7314 int got, conn1, i;
7315 DWORD bytesReturned, connect_time;
7316 char buffer[1024], ipbuffer[32];
7317 OVERLAPPED overlapped;
7318 int iret, localSize = sizeof(struct sockaddr_in), remoteSize = localSize;
7319 BOOL bret;
7320 DWORD dwret;
7321
7322 memset(&overlapped, 0, sizeof(overlapped));
7323
7324 listener = socket(AF_INET, SOCK_STREAM, 0);
7325 if (listener == INVALID_SOCKET) {
7326 skip("could not create listener socket, error %d\n", WSAGetLastError());
7327 goto end;
7328 }
7329
7330 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7331 if (acceptor == INVALID_SOCKET) {
7332 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7333 goto end;
7334 }
7335
7336 connector = socket(AF_INET, SOCK_STREAM, 0);
7337 if (connector == INVALID_SOCKET) {
7338 skip("could not create connector socket, error %d\n", WSAGetLastError());
7339 goto end;
7340 }
7341
7342 memset(&bindAddress, 0, sizeof(bindAddress));
7343 bindAddress.sin_family = AF_INET;
7344 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
7345 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7346 if (iret != 0) {
7347 skip("failed to bind, error %d\n", WSAGetLastError());
7348 goto end;
7349 }
7350
7351 socklen = sizeof(bindAddress);
7352 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
7353 if (iret != 0) {
7354 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
7355 goto end;
7356 }
7357
7358 if (set_blocking(listener, FALSE)) {
7359 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7360 goto end;
7361 }
7362
7363 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
7364 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
7365 if (iret) {
7366 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
7367 goto end;
7368 }
7369
7370 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &getAcceptExGuid, sizeof(getAcceptExGuid),
7371 &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &bytesReturned, NULL, NULL);
7372 if (iret) {
7373 skip("WSAIoctl failed to get GetAcceptExSockaddrs with ret %d + errno %d\n", iret, WSAGetLastError());
7374 goto end;
7375 }
7376
7377 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7378 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7379 &bytesReturned, &overlapped);
7380 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
7381 "returned %d + errno %d\n", bret, WSAGetLastError());
7382
7383 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7384 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7385 &bytesReturned, &overlapped);
7386 todo_wine
7387 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
7388 "returned %d + errno %d\n", bret, WSAGetLastError());
7389
7390 iret = listen(listener, 5);
7391 if (iret != 0) {
7392 skip("listening failed, errno = %d\n", WSAGetLastError());
7393 goto end;
7394 }
7395
7396 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7397 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7398 &bytesReturned, &overlapped);
7399 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid accepting socket "
7400 "returned %d + errno %d\n", bret, WSAGetLastError());
7401
7402 bret = pAcceptEx(listener, acceptor, NULL, 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 &&
7406 (WSAGetLastError() == WSAEINVAL ||
7407 broken(WSAGetLastError() == WSAEFAULT)), /* NT4 */
7408 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
7409
7410 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
7411 &bytesReturned, &overlapped);
7412 ok(bret == FALSE && (WSAGetLastError() == ERROR_IO_PENDING || broken(WSAGetLastError() == WSAEINVAL)) /* NT4 */,
7413 "AcceptEx on too small local address size returned %d + errno %d\n",
7414 bret, WSAGetLastError());
7415 bret = CancelIo((HANDLE) listener);
7416 ok(bret, "Failed to cancel pending accept socket\n");
7417
7418 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 15,
7419 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
7420 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx on too small local address "
7421 "size returned %d + errno %d\n",
7422 bret, WSAGetLastError());
7423 bret = CancelIo((HANDLE) listener);
7424 ok(bret, "Failed to cancel pending accept socket\n");
7425
7426 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
7427 &bytesReturned, &overlapped);
7428 ok(bret == FALSE && (WSAGetLastError() == WSAEFAULT || broken(WSAGetLastError() == WSAEINVAL)) /* NT4 */,
7429 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
7430
7431 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
7432 sizeof(struct sockaddr_in) + 15, &bytesReturned, &overlapped);
7433 ok(bret == FALSE && (WSAGetLastError() == ERROR_IO_PENDING || broken(WSAGetLastError() == WSAEINVAL)) /* NT4 */,
7434 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
7435 bret = CancelIo((HANDLE) listener);
7436 ok(bret, "Failed to cancel pending accept socket\n");
7437
7438 bret = pAcceptEx(listener, acceptor, buffer, 0,
7439 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7440 &bytesReturned, NULL);
7441 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
7442 "returned %d + errno %d\n", bret, WSAGetLastError());
7443
7444 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, 0, &bytesReturned, NULL);
7445 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
7446 "returned %d + errno %d\n", bret, WSAGetLastError());
7447
7448 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
7449 if (overlapped.hEvent == NULL) {
7450 skip("could not create event object, errno = %d\n", GetLastError());
7451 goto end;
7452 }
7453
7454 bret = pAcceptEx(listener, acceptor, buffer, 0,
7455 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7456 &bytesReturned, &overlapped);
7457 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7458
7459 bret = pAcceptEx(listener, acceptor, buffer, 0,
7460 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7461 &bytesReturned, &overlapped);
7462 todo_wine ok((bret == FALSE && WSAGetLastError() == WSAEINVAL) || broken(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) /* NT4 */,
7463 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
7464 if (bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) {
7465 /* We need to cancel this call, otherwise things fail */
7466 bret = CancelIo((HANDLE) listener);
7467 ok(bret, "Failed to cancel failed test. Bailing...\n");
7468 if (!bret) return;
7469 WaitForSingleObject(overlapped.hEvent, 0);
7470
7471 bret = pAcceptEx(listener, acceptor, buffer, 0,
7472 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7473 &bytesReturned, &overlapped);
7474 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7475 }
7476
7477 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7478 todo_wine ok((iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL) || broken(!iret) /* NT4 */,
7479 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
7480 if (!iret || (iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)) {
7481 /* We need to cancel this call, otherwise things fail */
7482 closesocket(acceptor);
7483 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7484 if (acceptor == INVALID_SOCKET) {
7485 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7486 goto end;
7487 }
7488
7489 bret = CancelIo((HANDLE) listener);
7490 ok(bret, "Failed to cancel failed test. Bailing...\n");
7491 if (!bret) return;
7492
7493 bret = pAcceptEx(listener, acceptor, buffer, 0,
7494 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7495 &bytesReturned, &overlapped);
7496 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7497 }
7498
7499 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7500 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7501
7502 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
7503 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7504
7505 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7506 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7507 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7508
7509 closesocket(connector);
7510 connector = INVALID_SOCKET;
7511 closesocket(acceptor);
7512
7513 /* Test short reads */
7514
7515 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7516 if (acceptor == INVALID_SOCKET) {
7517 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7518 goto end;
7519 }
7520 connector = socket(AF_INET, SOCK_STREAM, 0);
7521 if (connector == INVALID_SOCKET) {
7522 skip("could not create connector socket, error %d\n", WSAGetLastError());
7523 goto end;
7524 }
7525 bret = pAcceptEx(listener, acceptor, buffer, 2,
7526 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7527 &bytesReturned, &overlapped);
7528 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7529
7530 connect_time = 0xdeadbeef;
7531 optlen = sizeof(connect_time);
7532 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
7533 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
7534 ok(connect_time == ~0u, "unexpected connect time %u\n", connect_time);
7535
7536 /* AcceptEx() still won't complete until we send data */
7537 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7538 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7539
7540 connect_time = 0xdeadbeef;
7541 optlen = sizeof(connect_time);
7542 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
7543 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
7544 ok(connect_time < 0xdeadbeef, "unexpected connect time %u\n", connect_time);
7545
7546 dwret = WaitForSingleObject(overlapped.hEvent, 0);
7547 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %d + errno %d\n", dwret, GetLastError());
7548
7549 iret = getsockname( connector, (struct sockaddr *)&peerAddress, &remoteSize);
7550 ok( !iret, "getsockname failed.\n");
7551
7552 /* AcceptEx() could complete any time now */
7553 iret = send(connector, buffer, 1, 0);
7554 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
7555
7556 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7557 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7558
7559 /* Check if the buffer from AcceptEx is decoded correctly */
7560 pGetAcceptExSockaddrs(buffer, 2, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7561 (struct sockaddr **)&readBindAddress, &localSize,
7562 (struct sockaddr **)&readRemoteAddress, &remoteSize);
7563 strcpy( ipbuffer, inet_ntoa(readBindAddress->sin_addr));
7564 ok( readBindAddress->sin_addr.s_addr == bindAddress.sin_addr.s_addr,
7565 "Local socket address is different %s != %s\n",
7566 ipbuffer, inet_ntoa(bindAddress.sin_addr));
7567 ok( readBindAddress->sin_port == bindAddress.sin_port,
7568 "Local socket port is different: %d != %d\n",
7569 readBindAddress->sin_port, bindAddress.sin_port);
7570 strcpy( ipbuffer, inet_ntoa(readRemoteAddress->sin_addr));
7571 ok( readRemoteAddress->sin_addr.s_addr == peerAddress.sin_addr.s_addr,
7572 "Remote socket address is different %s != %s\n",
7573 ipbuffer, inet_ntoa(peerAddress.sin_addr));
7574 ok( readRemoteAddress->sin_port == peerAddress.sin_port,
7575 "Remote socket port is different: %d != %d\n",
7576 readRemoteAddress->sin_port, peerAddress.sin_port);
7577
7578 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7579 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7580 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7581
7582 closesocket(connector);
7583 connector = INVALID_SOCKET;
7584 closesocket(acceptor);
7585
7586 /* Test CF_DEFER & AcceptEx interaction */
7587
7588 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7589 if (acceptor == INVALID_SOCKET) {
7590 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7591 goto end;
7592 }
7593 connector = socket(AF_INET, SOCK_STREAM, 0);
7594 if (connector == INVALID_SOCKET) {
7595 skip("could not create connector socket, error %d\n", WSAGetLastError());
7596 goto end;
7597 }
7598 connector2 = socket(AF_INET, SOCK_STREAM, 0);
7599 if (connector == INVALID_SOCKET) {
7600 skip("could not create connector socket, error %d\n", WSAGetLastError());
7601 goto end;
7602 }
7603
7604 if (set_blocking(connector, FALSE)) {
7605 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7606 goto end;
7607 }
7608
7609 if (set_blocking(connector2, FALSE)) {
7610 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7611 goto end;
7612 }
7613
7614 /* Connect socket #1 */
7615 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7616 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7617
7618 FD_ZERO ( &fds_accept );
7619 FD_ZERO ( &fds_send );
7620
7621 FD_SET ( listener, &fds_accept );
7622 FD_SET ( connector, &fds_send );
7623
7624 buffer[0] = '0';
7625 got = 0;
7626 conn1 = 0;
7627
7628 for (i = 0; i < 4000; ++i)
7629 {
7630 fd_set fds_openaccept = fds_accept, fds_opensend = fds_send;
7631
7632 wsa_ok ( ( select ( 0, &fds_openaccept, &fds_opensend, NULL, &timeout ) ), SOCKET_ERROR !=,
7633 "acceptex test(%d): could not select on socket, errno %d\n" );
7634
7635 /* check for incoming requests */
7636 if ( FD_ISSET ( listener, &fds_openaccept ) ) {
7637 got++;
7638 if (got == 1) {
7639 SOCKET tmp = WSAAccept(listener, NULL, NULL, (LPCONDITIONPROC) AlwaysDeferConditionFunc, 0);
7640 ok(tmp == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
7641 bret = pAcceptEx(listener, acceptor, buffer, 0,
7642 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7643 &bytesReturned, &overlapped);
7644 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7645 }
7646 else if (got == 2) {
7647 /* this should be socket #2 */
7648 SOCKET tmp = accept(listener, NULL, NULL);
7649 ok(tmp != INVALID_SOCKET, "accept failed %d\n", WSAGetLastError());
7650 closesocket(tmp);
7651 }
7652 else {
7653 ok(FALSE, "Got more than 2 connections?\n");
7654 }
7655 }
7656 if ( conn1 && FD_ISSET ( connector2, &fds_opensend ) ) {
7657 /* Send data on second socket, and stop */
7658 send(connector2, "2", 1, 0);
7659 FD_CLR ( connector2, &fds_send );
7660
7661 break;
7662 }
7663 if ( FD_ISSET ( connector, &fds_opensend ) ) {
7664 /* Once #1 is connected, allow #2 to connect */
7665 conn1 = 1;
7666
7667 send(connector, "1", 1, 0);
7668 FD_CLR ( connector, &fds_send );
7669
7670 iret = connect(connector2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7671 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7672 FD_SET ( connector2, &fds_send );
7673 }
7674 }
7675
7676 ok (got == 2 || broken(got == 1) /* NT4 */,
7677 "Did not get both connections, got %d\n", got);
7678
7679 dwret = WaitForSingleObject(overlapped.hEvent, 0);
7680 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7681
7682 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7683 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7684 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7685
7686 set_blocking(acceptor, TRUE);
7687 iret = recv( acceptor, buffer, 2, 0);
7688 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
7689
7690 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
7691
7692 closesocket(connector);
7693 connector = INVALID_SOCKET;
7694 closesocket(acceptor);
7695
7696 /* clean up in case of failures */
7697 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
7698 closesocket(acceptor);
7699
7700 /* Disconnect during receive? */
7701
7702 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7703 if (acceptor == INVALID_SOCKET) {
7704 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7705 goto end;
7706 }
7707 connector = socket(AF_INET, SOCK_STREAM, 0);
7708 if (connector == INVALID_SOCKET) {
7709 skip("could not create connector socket, error %d\n", WSAGetLastError());
7710 goto end;
7711 }
7712 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7713 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7714 &bytesReturned, &overlapped);
7715 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7716
7717 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7718 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7719
7720 closesocket(connector);
7721 connector = INVALID_SOCKET;
7722
7723 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7724 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7725
7726 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7727 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7728 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7729
7730 closesocket(acceptor);
7731
7732 /* Test closing with pending requests */
7733
7734 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7735 if (acceptor == INVALID_SOCKET) {
7736 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7737 goto end;
7738 }
7739 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7740 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7741 &bytesReturned, &overlapped);
7742 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7743
7744 closesocket(acceptor);
7745
7746 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7747 todo_wine ok(dwret == WAIT_OBJECT_0 || broken(dwret == WAIT_TIMEOUT) /* NT4/2000 */,
7748 "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7749
7750 if (dwret != WAIT_TIMEOUT) {
7751 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7752 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
7753 }
7754 else {
7755 bret = CancelIo((HANDLE) listener);
7756 ok(bret, "Failed to cancel failed test. Bailing...\n");
7757 if (!bret) return;
7758 WaitForSingleObject(overlapped.hEvent, 0);
7759 }
7760
7761 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7762 if (acceptor == INVALID_SOCKET) {
7763 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7764 goto end;
7765 }
7766 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7767 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7768 &bytesReturned, &overlapped);
7769 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7770
7771 CancelIo((HANDLE) acceptor);
7772
7773 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7774 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %d + errno %d\n", dwret, GetLastError());
7775
7776 closesocket(acceptor);
7777
7778 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7779 if (acceptor == INVALID_SOCKET) {
7780 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7781 goto end;
7782 }
7783 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7784 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7785 &bytesReturned, &overlapped);
7786 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7787
7788 closesocket(listener);
7789 listener = INVALID_SOCKET;
7790
7791 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7792 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7793
7794 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7795 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
7796
7797 end:
7798 if (overlapped.hEvent)
7799 WSACloseEvent(overlapped.hEvent);
7800 if (listener != INVALID_SOCKET)
7801 closesocket(listener);
7802 if (acceptor != INVALID_SOCKET)
7803 closesocket(acceptor);
7804 if (connector != INVALID_SOCKET)
7805 closesocket(connector);
7806 if (connector2 != INVALID_SOCKET)
7807 closesocket(connector2);
7808 }
7809
7810 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
7811
7812 static void compare_file2(HANDLE handle, SOCKET sock, int offset, const char *file, int line)
7813 {
7814 char buf1[256], buf2[256];
7815 BOOL success;
7816 int i = 0;
7817
7818 SetFilePointer(handle, offset, NULL, FILE_BEGIN);
7819 while (1)
7820 {
7821 DWORD n1 = 0, n2 = 0;
7822
7823 success = ReadFile(handle, buf1, sizeof(buf1), &n1, NULL);
7824 ok_(file,line)(success, "Failed to read from file.\n");
7825 if (success && n1 == 0)
7826 break;
7827 else if(!success)
7828 return;
7829 n2 = recv(sock, buf2, n1, 0);
7830 ok_(file,line)(n1 == n2, "Block %d size mismatch (%d != %d)\n", i, n1, n2);
7831 ok_(file,line)(memcmp(buf1, buf2, n2) == 0, "Block %d failed\n", i);
7832 i++;
7833 }
7834 }
7835
7836 static void test_TransmitFile(void)
7837 {
7838 DWORD num_bytes, err, file_size, total_sent;
7839 GUID transmitFileGuid = WSAID_TRANSMITFILE;
7840 LPFN_TRANSMITFILE pTransmitFile = NULL;
7841 HANDLE file = INVALID_HANDLE_VALUE;
7842 char header_msg[] = "hello world";
7843 char footer_msg[] = "goodbye!!!";
7844 char system_ini_path[MAX_PATH];
7845 struct sockaddr_in bindAddress;
7846 TRANSMIT_FILE_BUFFERS buffers;
7847 SOCKET client, server, dest;
7848 WSAOVERLAPPED ov;
7849 char buf[256];
7850 int iret, len;
7851 BOOL bret;
7852
7853 memset( &ov, 0, sizeof(ov) );
7854
7855 /* Setup sockets for testing TransmitFile */
7856 client = socket(AF_INET, SOCK_STREAM, 0);
7857 server = socket(AF_INET, SOCK_STREAM, 0);
7858 if (client == INVALID_SOCKET || server == INVALID_SOCKET)
7859 {
7860 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7861 goto cleanup;
7862 }
7863 iret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &transmitFileGuid, sizeof(transmitFileGuid),
7864 &pTransmitFile, sizeof(pTransmitFile), &num_bytes, NULL, NULL);
7865 if (iret)
7866 {
7867 skip("WSAIoctl failed to get TransmitFile with ret %d + errno %d\n", iret, WSAGetLastError());
7868 goto cleanup;
7869 }
7870 GetSystemWindowsDirectoryA(system_ini_path, MAX_PATH );
7871 strcat(system_ini_path, "\\system.ini");
7872 file = CreateFileA(system_ini_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0x0, NULL);
7873 if (file == INVALID_HANDLE_VALUE)
7874 {
7875 skip("Unable to open a file to transmit.\n");
7876 goto cleanup;
7877 }
7878 file_size = GetFileSize(file, NULL);
7879
7880 /* Test TransmitFile with an invalid socket */
7881 bret = pTransmitFile(INVALID_SOCKET, file, 0, 0, NULL, NULL, 0);
7882 err = WSAGetLastError();
7883 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
7884 ok(err == WSAENOTSOCK, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTSOCK);
7885
7886 /* Test a bogus TransmitFile without a connected socket */
7887 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, TF_REUSE_SOCKET);
7888 err = WSAGetLastError();
7889 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
7890 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTCONN);
7891
7892 /* Setup a properly connected socket for transfers */
7893 memset(&bindAddress, 0, sizeof(bindAddress));
7894 bindAddress.sin_family = AF_INET;
7895 bindAddress.sin_port = htons(9375);
7896 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
7897 iret = bind(server, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7898 if (iret != 0)
7899 {
7900 skip("failed to bind(), error %d\n", WSAGetLastError());
7901 goto cleanup;
7902 }
7903 iret = listen(server, 1);
7904 if (iret != 0)
7905 {
7906 skip("failed to listen(), error %d\n", WSAGetLastError());
7907 goto cleanup;
7908 }
7909 iret = connect(client, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7910 if (iret != 0)
7911 {
7912 skip("failed to connect(), error %d\n", WSAGetLastError());
7913 goto cleanup;
7914 }
7915 len = sizeof(bindAddress);
7916 dest = accept(server, (struct sockaddr*)&bindAddress, &len);
7917 if (dest == INVALID_SOCKET)
7918 {
7919 skip("failed to accept(), error %d\n", WSAGetLastError());
7920 goto cleanup;
7921 }
7922 if (set_blocking(dest, FALSE))
7923 {
7924 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7925 goto cleanup;
7926 }
7927
7928 /* Test TransmitFile with no possible buffer */
7929 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
7930 ok(bret, "TransmitFile failed unexpectedly.\n");
7931 iret = recv(dest, buf, sizeof(buf), 0);
7932 ok(iret == -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret);
7933
7934 /* Test TransmitFile with only buffer data */
7935 buffers.Head = &header_msg[0];
7936 buffers.HeadLength = sizeof(header_msg)+1;
7937 buffers.Tail = &footer_msg[0];
7938 buffers.TailLength = sizeof(footer_msg)+1;
7939 bret = pTransmitFile(client, NULL, 0, 0, NULL, &buffers, 0);
7940 ok(bret, "TransmitFile failed unexpectedly.\n");
7941 iret = recv(dest, buf, sizeof(buf), 0);
7942 ok(iret == sizeof(header_msg)+sizeof(footer_msg)+2,
7943 "Returned an unexpected buffer from TransmitFile: %d\n", iret );
7944 ok(memcmp(&buf[0], &header_msg[0], sizeof(header_msg)+1) == 0,
7945 "TransmitFile header buffer did not match!\n");
7946 ok(memcmp(&buf[sizeof(header_msg)+1], &footer_msg[0], sizeof(footer_msg)+1) == 0,
7947 "TransmitFile footer buffer did not match!\n");
7948
7949 /* Test TransmitFile with only file data */
7950 bret = pTransmitFile(client, file, 0, 0, NULL, NULL, 0);
7951 ok(bret, "TransmitFile failed unexpectedly.\n");
7952 compare_file(file, dest, 0);
7953
7954 /* Test TransmitFile with both file and buffer data */
7955 buffers.Head = &header_msg[0];
7956 buffers.HeadLength = sizeof(header_msg)+1;
7957 buffers.Tail = &footer_msg[0];
7958 buffers.TailLength = sizeof(footer_msg)+1;
7959 SetFilePointer(file, 0, NULL, FILE_BEGIN);
7960 bret = pTransmitFile(client, file, 0, 0, NULL, &buffers, 0);
7961 ok(bret, "TransmitFile failed unexpectedly.\n");
7962 iret = recv(dest, buf, sizeof(header_msg)+1, 0);
7963 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)+1) == 0,
7964 "TransmitFile header buffer did not match!\n");
7965 compare_file(file, dest, 0);
7966 iret = recv(dest, buf, sizeof(footer_msg)+1, 0);
7967 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)+1) == 0,
7968 "TransmitFile footer buffer did not match!\n");
7969
7970 /* Test overlapped TransmitFile */
7971 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
7972 if (ov.hEvent == INVALID_HANDLE_VALUE)
7973 {
7974 skip("Could not create event object, some tests will be skipped. errno = %d\n",
7975 GetLastError());
7976 goto cleanup;
7977 }
7978 SetFilePointer(file, 0, NULL, FILE_BEGIN);
7979 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
7980 err = WSAGetLastError();
7981 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
7982 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n",
7983 err, ERROR_IO_PENDING);
7984 iret = WaitForSingleObject(ov.hEvent, 2000);
7985 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
7986 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
7987 ok(total_sent == file_size,
7988 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
7989 total_sent, file_size);
7990 compare_file(file, dest, 0);
7991
7992 /* Test overlapped TransmitFile w/ start offset */
7993 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
7994 if (ov.hEvent == INVALID_HANDLE_VALUE)
7995 {
7996 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
7997 goto cleanup;
7998 }
7999 SetFilePointer(file, 0, NULL, FILE_BEGIN);
8000 ov.Offset = 10;
8001 bret = pTransmitFile(client, file, 0, 0, &ov, NULL, 0);
8002 err = WSAGetLastError();
8003 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8004 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n", err, ERROR_IO_PENDING);
8005 iret = WaitForSingleObject(ov.hEvent, 2000);
8006 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
8007 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
8008 ok(total_sent == (file_size - ov.Offset),
8009 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8010 total_sent, file_size - ov.Offset);
8011 compare_file(file, dest, ov.Offset);
8012
8013 /* Test overlapped TransmitFile w/ file and buffer data */
8014 ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
8015 if (ov.hEvent == INVALID_HANDLE_VALUE)
8016 {
8017 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
8018 goto cleanup;
8019 }
8020 buffers.Head = &header_msg[0];
8021 buffers.HeadLength = sizeof(header_msg)+1;
8022 buffers.Tail = &footer_msg[0];
8023 buffers.TailLength = sizeof(footer_msg)+1;
8024 SetFilePointer(file, 0, NULL, FILE_BEGIN);
8025 ov.Offset = 0;
8026 bret = pTransmitFile(client, file, 0, 0, &ov, &buffers, 0);
8027 err = WSAGetLastError();
8028 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8029 ok(err == ERROR_IO_PENDING, "TransmitFile triggered unexpected errno (%d != %d)\n", err, ERROR_IO_PENDING);
8030 iret = WaitForSingleObject(ov.hEvent, 2000);
8031 ok(iret == WAIT_OBJECT_0, "Overlapped TransmitFile failed.\n");
8032 WSAGetOverlappedResult(client, &ov, &total_sent, FALSE, NULL);
8033 ok(total_sent == (file_size + buffers.HeadLength + buffers.TailLength),
8034 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8035 total_sent, file_size + buffers.HeadLength + buffers.TailLength);
8036 iret = recv(dest, buf, sizeof(header_msg)+1, 0);
8037 ok(memcmp(buf, &header_msg[0], sizeof(header_msg)+1) == 0,
8038 "TransmitFile header buffer did not match!\n");
8039 compare_file(file, dest, 0);
8040 iret = recv(dest, buf, sizeof(footer_msg)+1, 0);
8041 ok(memcmp(buf, &footer_msg[0], sizeof(footer_msg)+1) == 0,
8042 "TransmitFile footer buffer did not match!\n");
8043
8044 /* Test TransmitFile with a UDP datagram socket */
8045 closesocket(client);
8046 client = socket(AF_INET, SOCK_DGRAM, 0);
8047 bret = pTransmitFile(client, NULL, 0, 0, NULL, NULL, 0);
8048 err = WSAGetLastError();
8049 ok(!bret, "TransmitFile succeeded unexpectedly.\n");
8050 ok(err == WSAENOTCONN, "TransmitFile triggered unexpected errno (%d != %d)\n", err, WSAENOTCONN);
8051
8052 cleanup:
8053 CloseHandle(file);
8054 CloseHandle(ov.hEvent);
8055 closesocket(client);
8056 closesocket(server);
8057 }
8058
8059 static void test_getpeername(void)
8060 {
8061 SOCKET sock;
8062 struct sockaddr_in sa, sa_out;
8063 SOCKADDR_STORAGE ss;
8064 int sa_len;
8065 const char buf[] = "hello world";
8066 int ret;
8067
8068 /* Test the parameter validation order. */
8069 ret = getpeername(INVALID_SOCKET, NULL, NULL);
8070 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8071 ok(WSAGetLastError() == WSAENOTSOCK,
8072 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
8073
8074 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
8075 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
8076 if (sock == INVALID_SOCKET)
8077 {
8078 skip("Socket creation failed with %d\n", WSAGetLastError());
8079 return;
8080 }
8081
8082 ret = getpeername(sock, NULL, NULL);
8083 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8084 ok(WSAGetLastError() == WSAENOTCONN ||
8085 broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
8086 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8087
8088 memset(&sa, 0, sizeof(sa));
8089 sa.sin_family = AF_INET;
8090 sa.sin_port = htons(139);
8091 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
8092
8093 /* sendto does not change a socket's connection state. */
8094 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
8095 ok(ret != SOCKET_ERROR,
8096 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
8097
8098 ret = getpeername(sock, NULL, NULL);
8099 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8100 ok(WSAGetLastError() == WSAENOTCONN ||
8101 broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
8102 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8103
8104 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
8105 ok(ret == 0,
8106 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
8107
8108 ret = getpeername(sock, NULL, NULL);
8109 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8110 ok(WSAGetLastError() == WSAEFAULT,
8111 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8112
8113 /* Test crashes on Wine. */
8114 if (0)
8115 {
8116 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
8117 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
8118 ok(WSAGetLastError() == WSAEFAULT,
8119 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8120 }
8121
8122 ret = getpeername(sock, (struct sockaddr*)&sa_out, NULL);
8123 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
8124 ok(WSAGetLastError() == WSAEFAULT,
8125 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8126
8127 sa_len = 0;
8128 ret = getpeername(sock, NULL, &sa_len);
8129 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
8130 ok(WSAGetLastError() == WSAEFAULT,
8131 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8132 ok(!sa_len, "got %d\n", sa_len);
8133
8134 sa_len = 0;
8135 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
8136 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
8137 ok(WSAGetLastError() == WSAEFAULT,
8138 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8139 ok(!sa_len, "got %d\n", sa_len);
8140
8141 sa_len = sizeof(ss);
8142 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
8143 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
8144 ok(!memcmp(&sa, &ss, sizeof(sa)),
8145 "Expected the returned structure to be identical to the connect structure\n");
8146 ok(sa_len == sizeof(sa), "got %d\n", sa_len);
8147
8148 closesocket(sock);
8149 }
8150
8151 static void test_sioRoutingInterfaceQuery(void)
8152 {
8153 int ret;
8154 SOCKET sock;
8155 SOCKADDR_IN sin = { 0 }, sout = { 0 };
8156 DWORD bytesReturned;
8157
8158 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
8159 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
8160 if (sock == INVALID_SOCKET)
8161 {
8162 skip("Socket creation failed with %d\n", WSAGetLastError());
8163 return;
8164 }
8165 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, NULL, 0, NULL, 0, NULL,
8166 NULL, NULL);
8167 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
8168 "expected WSAEFAULT, got %d\n", WSAGetLastError());
8169 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
8170 NULL, 0, NULL, NULL, NULL);
8171 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
8172 "expected WSAEFAULT, got %d\n", WSAGetLastError());
8173 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
8174 NULL, 0, &bytesReturned, NULL, NULL);
8175 ok(ret == SOCKET_ERROR &&
8176 (WSAGetLastError() == WSAEFAULT /* Win98 */ ||
8177 WSAGetLastError() == WSAEINVAL /* NT4 */||
8178 WSAGetLastError() == WSAEAFNOSUPPORT),
8179 "expected WSAEFAULT or WSAEINVAL or WSAEAFNOSUPPORT, got %d\n",
8180 WSAGetLastError());
8181 sin.sin_family = AF_INET;
8182 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
8183 NULL, 0, &bytesReturned, NULL, NULL);
8184 ok(ret == SOCKET_ERROR &&
8185 (WSAGetLastError() == WSAEFAULT /* Win98 */ ||
8186 WSAGetLastError() == WSAEINVAL),
8187 "expected WSAEFAULT or WSAEINVAL, got %d\n", WSAGetLastError());
8188 sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
8189 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
8190 NULL, 0, &bytesReturned, NULL, NULL);
8191 ok(ret == SOCKET_ERROR &&
8192 (WSAGetLastError() == WSAEINVAL /* NT4 */ ||
8193 WSAGetLastError() == WSAEFAULT),
8194 "expected WSAEINVAL or WSAEFAULT, got %d\n", WSAGetLastError());
8195 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
8196 &sout, sizeof(sout), &bytesReturned, NULL, NULL);
8197 ok(!ret || broken(WSAGetLastError() == WSAEINVAL /* NT4 */),
8198 "WSAIoctl failed: %d\n", WSAGetLastError());
8199 if (!ret)
8200 {
8201 ok(sout.sin_family == AF_INET, "expected AF_INET, got %d\n",
8202 sout.sin_family);
8203 /* We expect the source address to be INADDR_LOOPBACK as well, but
8204 * there's no guarantee that a route to the loopback address exists,
8205 * so rather than introduce spurious test failures we do not test the
8206 * source address.
8207 */
8208 }
8209 closesocket(sock);
8210 }
8211
8212 static void test_sioAddressListChange(void)
8213 {
8214 struct sockaddr_in bindAddress;
8215 struct in_addr net_address;
8216 WSAOVERLAPPED overlapped;
8217 struct hostent *h;
8218 DWORD num_bytes;
8219 SOCKET sock;
8220 int acount;
8221 int ret;
8222
8223 if (!winetest_interactive)
8224 {
8225 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
8226 return;
8227 }
8228
8229 /* Use gethostbyname to find the list of local network interfaces */
8230 h = gethostbyname("");
8231 if (!h)
8232 {
8233 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, gethostbyname failed with %u\n",
8234 WSAGetLastError());
8235 return;
8236 }
8237 for (acount = 0; h->h_addr_list[acount]; acount++);
8238 if (acount == 0)
8239 {
8240 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
8241 return;
8242 }
8243 net_address.s_addr = *(ULONG *) h->h_addr_list[0];
8244
8245 /* Bind an overlapped socket to the first found network interface */
8246 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
8247 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
8248 if (sock == INVALID_SOCKET)
8249 {
8250 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, socket creation failed with %u\n",
8251 WSAGetLastError());
8252 return;
8253 }
8254 memset(&bindAddress, 0, sizeof(bindAddress));
8255 bindAddress.sin_family = AF_INET;
8256 bindAddress.sin_addr.s_addr = net_address.s_addr;
8257 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8258 if (ret != 0)
8259 {
8260 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, failed to bind, error %u\n", WSAGetLastError());
8261 goto end;
8262 }
8263
8264 /* Wait for address changes, request that the user connects/disconnects an interface */
8265 memset(&overlapped, 0, sizeof(overlapped));
8266 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
8267 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
8268 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
8269 ok(WSAGetLastError() == WSA_IO_PENDING, "Expected pending last error %d\n", WSAGetLastError());
8270 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
8271 " change the ipv4 address of any of the local network interfaces (10 second timeout).\n");
8272 ret = WaitForSingleObject(overlapped.hEvent, 10000);
8273 ok(ret == WAIT_OBJECT_0, "failed to get overlapped event %u\n", ret);
8274
8275 end:
8276 closesocket(sock);
8277 }
8278
8279 static void test_synchronous_WSAIoctl(void)
8280 {
8281 HANDLE previous_port, io_port;
8282 WSAOVERLAPPED overlapped, *olp;
8283 SOCKET socket;
8284 ULONG on;
8285 ULONG_PTR key;
8286 DWORD num_bytes;
8287 BOOL ret;
8288 int res;
8289
8290 previous_port = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );
8291 ok( previous_port != NULL, "failed to create completion port %u\n", GetLastError() );
8292
8293 socket = WSASocketW( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED );
8294 ok( socket != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError() );
8295
8296 io_port = CreateIoCompletionPort( (HANDLE)socket, previous_port, 0, 0 );
8297 ok( io_port != NULL, "failed to create completion port %u\n", GetLastError() );
8298
8299 on = 1;
8300 memset( &overlapped, 0, sizeof(overlapped) );
8301 res = WSAIoctl( socket, FIONBIO, &on, sizeof(on), NULL, 0, &num_bytes, &overlapped, NULL );
8302 ok( !res, "WSAIoctl failed %d\n", WSAGetLastError() );
8303
8304 ret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 10000 );
8305 ok( ret, "failed to get completion status %u\n", GetLastError() );
8306
8307 CloseHandle( io_port );
8308 closesocket( socket );
8309 CloseHandle( previous_port );
8310 }
8311
8312 #define WM_ASYNCCOMPLETE (WM_USER + 100)
8313 static HWND create_async_message_window(void)
8314 {
8315 static const char class_name[] = "ws2_32 async message window class";
8316
8317 WNDCLASSEXA wndclass;
8318 HWND hWnd;
8319
8320 wndclass.cbSize = sizeof(wndclass);
8321 wndclass.style = CS_HREDRAW | CS_VREDRAW;
8322 wndclass.lpfnWndProc = DefWindowProcA;
8323 wndclass.cbClsExtra = 0;
8324 wndclass.cbWndExtra = 0;
8325 wndclass.hInstance = GetModuleHandleA(NULL);
8326 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
8327 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
8328 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
8329 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
8330 wndclass.lpszClassName = class_name;
8331 wndclass.lpszMenuName = NULL;
8332
8333 RegisterClassExA(&wndclass);
8334
8335 hWnd = CreateWindowA(class_name, "ws2_32 async message window", WS_OVERLAPPEDWINDOW,
8336 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
8337 if (!hWnd)
8338 {
8339 ok(0, "failed to create window: %u\n", GetLastError());
8340 return NULL;
8341 }
8342
8343 return hWnd;
8344 }
8345
8346 static void test_WSAAsyncGetServByPort(void)
8347 {
8348 HWND hwnd = create_async_message_window();
8349 HANDLE ret;
8350 char buffer[MAXGETHOSTSTRUCT];
8351
8352 if (!hwnd)
8353 return;
8354
8355 /* FIXME: The asynchronous window messages should be tested. */
8356
8357 /* Parameters are not checked when initiating the asynchronous operation. */
8358 ret = WSAAsyncGetServByPort(NULL, 0, 0, NULL, NULL, 0);
8359 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
8360
8361 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, 0, NULL, NULL, 0);
8362 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
8363
8364 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, NULL, 0);
8365 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
8366
8367 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, buffer, MAXGETHOSTSTRUCT);
8368 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
8369
8370 DestroyWindow(hwnd);
8371 }
8372
8373 static void test_WSAAsyncGetServByName(void)
8374 {
8375 HWND hwnd = create_async_message_window();
8376 HANDLE ret;
8377 char buffer[MAXGETHOSTSTRUCT];
8378
8379 if (!hwnd)
8380 return;
8381
8382 /* FIXME: The asynchronous window messages should be tested. */
8383
8384 /* Parameters are not checked when initiating the asynchronous operation. */
8385 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", NULL, NULL, 0);
8386 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
8387
8388 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", "", buffer, MAXGETHOSTSTRUCT);
8389 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
8390
8391 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", NULL, NULL, 0);
8392 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
8393
8394 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", "tcp", buffer, MAXGETHOSTSTRUCT);
8395 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
8396
8397 DestroyWindow(hwnd);
8398 }
8399
8400 /*
8401 * Provide consistent initialization for the AcceptEx IOCP tests.
8402 */
8403 static SOCKET setup_iocp_src(struct sockaddr_in *bindAddress)
8404 {
8405 SOCKET src, ret = INVALID_SOCKET;
8406 int iret, socklen;
8407
8408 src = socket(AF_INET, SOCK_STREAM, 0);
8409 if (src == INVALID_SOCKET)
8410 {
8411 skip("could not create listener socket, error %d\n", WSAGetLastError());
8412 goto end;
8413 }
8414
8415 memset(bindAddress, 0, sizeof(*bindAddress));
8416 bindAddress->sin_family = AF_INET;
8417 bindAddress->sin_addr.s_addr = inet_addr("127.0.0.1");
8418 iret = bind(src, (struct sockaddr*)bindAddress, sizeof(*bindAddress));
8419 if (iret != 0)
8420 {
8421 skip("failed to bind, error %d\n", WSAGetLastError());
8422 goto end;
8423 }
8424
8425 socklen = sizeof(*bindAddress);
8426 iret = getsockname(src, (struct sockaddr*)bindAddress, &socklen);
8427 if (iret != 0) {
8428 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
8429 goto end;
8430 }
8431
8432 if (set_blocking(src, FALSE))
8433 {
8434 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8435 goto end;
8436 }
8437
8438 iret = listen(src, 5);
8439 if (iret != 0)
8440 {
8441 skip("listening failed, errno = %d\n", WSAGetLastError());
8442 goto end;
8443 }
8444
8445 ret = src;
8446 end:
8447 if (src != ret && ret == INVALID_SOCKET)
8448 closesocket(src);
8449 return ret;
8450 }
8451
8452 static void test_completion_port(void)
8453 {
8454 HANDLE previous_port, io_port;
8455 WSAOVERLAPPED ov, *olp;
8456 SOCKET src, dest, dup, connector = INVALID_SOCKET;
8457 WSAPROTOCOL_INFOA info;
8458 char buf[1024];
8459 WSABUF bufs;
8460 DWORD num_bytes, flags;
8461 struct linger ling;
8462 int iret;
8463 BOOL bret;
8464 ULONG_PTR key;
8465 struct sockaddr_in bindAddress;
8466 GUID acceptExGuid = WSAID_ACCEPTEX;
8467 LPFN_ACCEPTEX pAcceptEx = NULL;
8468
8469 memset(buf, 0, sizeof(buf));
8470 previous_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
8471 ok( previous_port != NULL, "Failed to create completion port %u\n", GetLastError());
8472
8473 memset(&ov, 0, sizeof(ov));
8474
8475 tcp_socketpair(&src, &dest);
8476 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
8477 {
8478 skip("failed to create sockets\n");
8479 goto end;
8480 }
8481
8482 bufs.len = sizeof(buf);
8483 bufs.buf = buf;
8484 flags = 0;
8485
8486 ling.l_onoff = 1;
8487 ling.l_linger = 0;
8488 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
8489 ok(!iret, "Failed to set linger %d\n", GetLastError());
8490
8491 io_port = CreateIoCompletionPort( (HANDLE)dest, previous_port, 125, 0 );
8492 ok(io_port != NULL, "Failed to create completion port %u\n", GetLastError());
8493
8494 SetLastError(0xdeadbeef);
8495
8496 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
8497 ok(iret == SOCKET_ERROR, "WSARecv returned %d\n", iret);
8498 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8499
8500 Sleep(100);
8501
8502 closesocket(src);
8503 src = INVALID_SOCKET;
8504
8505 SetLastError(0xdeadbeef);
8506 key = 0xdeadbeef;
8507 num_bytes = 0xdeadbeef;
8508 olp = (WSAOVERLAPPED *)0xdeadbeef;
8509
8510 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8511 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret);
8512 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED, "Last error was %d\n", GetLastError());
8513 ok(key == 125, "Key is %lu\n", key);
8514 ok(num_bytes == 0, "Number of bytes received is %u\n", num_bytes);
8515 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8516
8517 SetLastError(0xdeadbeef);
8518 key = 0xdeadbeef;
8519 num_bytes = 0xdeadbeef;
8520 olp = (WSAOVERLAPPED *)0xdeadbeef;
8521
8522 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8523 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret );
8524 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8525 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8526 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8527 ok(!olp, "Overlapped structure is at %p\n", olp);
8528
8529 if (dest != INVALID_SOCKET)
8530 closesocket(dest);
8531
8532 memset(&ov, 0, sizeof(ov));
8533
8534 tcp_socketpair(&src, &dest);
8535 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
8536 {
8537 skip("failed to create sockets\n");
8538 goto end;
8539 }
8540
8541 bufs.len = sizeof(buf);
8542 bufs.buf = buf;
8543 flags = 0;
8544
8545 ling.l_onoff = 1;
8546 ling.l_linger = 0;
8547 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
8548 ok(!iret, "Failed to set linger %d\n", GetLastError());
8549
8550 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
8551 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8552
8553 set_blocking(dest, FALSE);
8554
8555 closesocket(src);
8556 src = INVALID_SOCKET;
8557
8558 Sleep(100);
8559
8560 num_bytes = 0xdeadbeef;
8561 SetLastError(0xdeadbeef);
8562
8563 iret = WSASend(dest, &bufs, 1, &num_bytes, 0, &ov, NULL);
8564 ok(iret == SOCKET_ERROR, "WSASend failed - %d\n", iret);
8565 ok(GetLastError() == WSAECONNRESET, "Last error was %d\n", GetLastError());
8566 ok(num_bytes == 0xdeadbeef, "Managed to send %d\n", num_bytes);
8567
8568 SetLastError(0xdeadbeef);
8569 key = 0xdeadbeef;
8570 num_bytes = 0xdeadbeef;
8571 olp = (WSAOVERLAPPED *)0xdeadbeef;
8572
8573 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8574 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
8575 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8576 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8577 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8578 ok(!olp, "Overlapped structure is at %p\n", olp);
8579
8580 if (dest != INVALID_SOCKET)
8581 closesocket(dest);
8582
8583 dest = socket(AF_INET, SOCK_STREAM, 0);
8584 if (dest == INVALID_SOCKET)
8585 {
8586 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8587 goto end;
8588 }
8589
8590 iret = WSAIoctl(dest, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
8591 &pAcceptEx, sizeof(pAcceptEx), &num_bytes, NULL, NULL);
8592 if (iret)
8593 {
8594 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
8595 goto end;
8596 }
8597
8598 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
8599
8600 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8601 goto end;
8602
8603 SetLastError(0xdeadbeef);
8604
8605 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8606 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8607 &num_bytes, &ov);
8608 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8609 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8610
8611 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8612 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8613
8614 closesocket(src);
8615 src = INVALID_SOCKET;
8616
8617 SetLastError(0xdeadbeef);
8618 key = 0xdeadbeef;
8619 num_bytes = 0xdeadbeef;
8620 olp = (WSAOVERLAPPED *)0xdeadbeef;
8621
8622 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8623 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8624 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8625 ok(key == 125, "Key is %lu\n", key);
8626 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8627 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8628 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8629
8630 SetLastError(0xdeadbeef);
8631 key = 0xdeadbeef;
8632 num_bytes = 0xdeadbeef;
8633 olp = (WSAOVERLAPPED *)0xdeadbeef;
8634 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8635 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8636 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8637 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8638 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8639 ok(!olp, "Overlapped structure is at %p\n", olp);
8640
8641 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
8642
8643 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8644 goto end;
8645
8646 SetLastError(0xdeadbeef);
8647
8648 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8649 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8650
8651 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8652 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8653 &num_bytes, &ov);
8654 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8655 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8656
8657 closesocket(src);
8658 src = INVALID_SOCKET;
8659
8660 SetLastError(0xdeadbeef);
8661 key = 0xdeadbeef;
8662 num_bytes = 0xdeadbeef;
8663 olp = (WSAOVERLAPPED *)0xdeadbeef;
8664
8665 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8666 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8667 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8668 ok(key == 125, "Key is %lu\n", key);
8669 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8670 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8671 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8672
8673 SetLastError(0xdeadbeef);
8674 key = 0xdeadbeef;
8675 num_bytes = 0xdeadbeef;
8676 olp = (WSAOVERLAPPED *)0xdeadbeef;
8677 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8678 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8679 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8680 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8681 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8682 ok(!olp, "Overlapped structure is at %p\n", olp);
8683
8684 /* Test IOCP with duplicated handle */
8685
8686 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8687 goto end;
8688
8689 SetLastError(0xdeadbeef);
8690
8691 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8692 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8693
8694 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
8695 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
8696 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
8697
8698 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8699 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8700 &num_bytes, &ov);
8701 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8702 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8703
8704 SetLastError(0xdeadbeef);
8705 key = 0xdeadbeef;
8706 num_bytes = 0xdeadbeef;
8707 olp = (WSAOVERLAPPED *)0xdeadbeef;
8708 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8709 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8710 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8711 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8712 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8713 ok(!olp, "Overlapped structure is at %p\n", olp);
8714
8715 closesocket(src);
8716 src = INVALID_SOCKET;
8717 closesocket(dup);
8718 dup = INVALID_SOCKET;
8719
8720 SetLastError(0xdeadbeef);
8721 key = 0xdeadbeef;
8722 num_bytes = 0xdeadbeef;
8723 olp = (WSAOVERLAPPED *)0xdeadbeef;
8724 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8725 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8726 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8727 ok(key == 125, "Key is %lu\n", key);
8728 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8729 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8730 ok(olp && olp->Internal == (ULONG)STATUS_CANCELLED, "Internal status is %lx\n", olp ? olp->Internal : 0);
8731
8732 SetLastError(0xdeadbeef);
8733 key = 0xdeadbeef;
8734 num_bytes = 0xdeadbeef;
8735 olp = (WSAOVERLAPPED *)0xdeadbeef;
8736 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8737 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8738 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8739 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8740 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8741 ok(!olp, "Overlapped structure is at %p\n", olp);
8742
8743 /* Test IOCP with duplicated handle (closing duplicated handle) */
8744
8745 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8746 goto end;
8747
8748 SetLastError(0xdeadbeef);
8749
8750 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8751 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8752
8753 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
8754 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
8755 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
8756
8757 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8758 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8759 &num_bytes, &ov);
8760 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8761 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8762
8763 closesocket(dup);
8764 dup = INVALID_SOCKET;
8765
8766 SetLastError(0xdeadbeef);
8767 key = 0xdeadbeef;
8768 num_bytes = 0xdeadbeef;
8769 olp = (WSAOVERLAPPED *)0xdeadbeef;
8770 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8771 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8772 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8773 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8774 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8775 ok(!olp, "Overlapped structure is at %p\n", olp);
8776
8777 SetLastError(0xdeadbeef);
8778 key = 0xdeadbeef;
8779 num_bytes = 0xdeadbeef;
8780 olp = (WSAOVERLAPPED *)0xdeadbeef;
8781 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8782 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8783 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8784 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8785 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8786 ok(!olp, "Overlapped structure is at %p\n", olp);
8787
8788 closesocket(src);
8789 src = INVALID_SOCKET;
8790
8791 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8792 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8793 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8794 ok(key == 125, "Key is %lu\n", key);
8795 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8796 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8797 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8798
8799 SetLastError(0xdeadbeef);
8800 key = 0xdeadbeef;
8801 num_bytes = 0xdeadbeef;
8802 olp = (WSAOVERLAPPED *)0xdeadbeef;
8803 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8804 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8805 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8806 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8807 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8808 ok(!olp, "Overlapped structure is at %p\n", olp);
8809
8810 /* Test IOCP with duplicated handle (closing original handle) */
8811
8812 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8813 goto end;
8814
8815 SetLastError(0xdeadbeef);
8816
8817 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8818 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8819
8820 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
8821 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
8822 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
8823
8824 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8825 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8826 &num_bytes, &ov);
8827 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8828 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8829
8830 closesocket(src);
8831 src = INVALID_SOCKET;
8832
8833 SetLastError(0xdeadbeef);
8834 key = 0xdeadbeef;
8835 num_bytes = 0xdeadbeef;
8836 olp = (WSAOVERLAPPED *)0xdeadbeef;
8837 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8838 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8839 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8840 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8841 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8842 ok(!olp, "Overlapped structure is at %p\n", olp);
8843
8844 closesocket(dup);
8845 dup = INVALID_SOCKET;
8846
8847 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8848 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8849 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8850 ok(key == 125, "Key is %lu\n", key);
8851 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8852 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8853 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8854
8855 SetLastError(0xdeadbeef);
8856 key = 0xdeadbeef;
8857 num_bytes = 0xdeadbeef;
8858 olp = (WSAOVERLAPPED *)0xdeadbeef;
8859 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8860 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8861 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8862 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8863 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8864 ok(!olp, "Overlapped structure is at %p\n", olp);
8865
8866 /* Test IOCP without AcceptEx */
8867
8868 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8869 goto end;
8870
8871 SetLastError(0xdeadbeef);
8872
8873 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8874 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8875
8876 closesocket(src);
8877 src = INVALID_SOCKET;
8878
8879 SetLastError(0xdeadbeef);
8880 key = 0xdeadbeef;
8881 num_bytes = 0xdeadbeef;
8882 olp = (WSAOVERLAPPED *)0xdeadbeef;
8883 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8884 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8885 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8886 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8887 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8888 ok(!olp, "Overlapped structure is at %p\n", olp);
8889
8890 /* */
8891
8892 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8893 goto end;
8894
8895 connector = socket(AF_INET, SOCK_STREAM, 0);
8896 if (connector == INVALID_SOCKET) {
8897 skip("could not create connector socket, error %d\n", WSAGetLastError());
8898 goto end;
8899 }
8900
8901 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8902 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8903
8904 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
8905 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8906
8907 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8908 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8909 &num_bytes, &ov);
8910 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8911 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8912
8913 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8914 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8915
8916 closesocket(connector);
8917 connector = INVALID_SOCKET;
8918
8919 SetLastError(0xdeadbeef);
8920 key = 0xdeadbeef;
8921 num_bytes = 0xdeadbeef;
8922 olp = (WSAOVERLAPPED *)0xdeadbeef;
8923
8924 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8925 ok(bret == TRUE, "failed to get completion status %u\n", bret);
8926 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8927 ok(key == 125, "Key is %lu\n", key);
8928 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8929 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8930 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
8931
8932 SetLastError(0xdeadbeef);
8933 key = 0xdeadbeef;
8934 num_bytes = 0xdeadbeef;
8935 olp = (WSAOVERLAPPED *)0xdeadbeef;
8936 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8937 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8938 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8939 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8940 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8941 ok(!olp, "Overlapped structure is at %p\n", olp);
8942
8943 if (dest != INVALID_SOCKET)
8944 closesocket(dest);
8945 if (src != INVALID_SOCKET)
8946 closesocket(dest);
8947
8948 /* */
8949
8950 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8951 goto end;
8952
8953 dest = socket(AF_INET, SOCK_STREAM, 0);
8954 if (dest == INVALID_SOCKET)
8955 {
8956 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8957 goto end;
8958 }
8959
8960 connector = socket(AF_INET, SOCK_STREAM, 0);
8961 if (connector == INVALID_SOCKET) {
8962 skip("could not create connector socket, error %d\n", WSAGetLastError());
8963 goto end;
8964 }
8965
8966 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8967 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8968
8969 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
8970 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8971
8972 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8973 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8974 &num_bytes, &ov);
8975 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8976 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8977
8978 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8979 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8980
8981 iret = send(connector, buf, 1, 0);
8982 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
8983
8984 Sleep(100);
8985
8986 closesocket(dest);
8987 dest = INVALID_SOCKET;
8988
8989 SetLastError(0xdeadbeef);
8990 key = 0xdeadbeef;
8991 num_bytes = 0xdeadbeef;
8992 olp = (WSAOVERLAPPED *)0xdeadbeef;
8993
8994 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8995 ok(bret == TRUE, "failed to get completion status %u\n", bret);
8996 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8997 ok(key == 125, "Key is %lu\n", key);
8998 ok(num_bytes == 1, "Number of bytes transferred is %u\n", num_bytes);
8999 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9000 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
9001
9002 SetLastError(0xdeadbeef);
9003 key = 0xdeadbeef;
9004 num_bytes = 0xdeadbeef;
9005 olp = (WSAOVERLAPPED *)0xdeadbeef;
9006 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9007 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9008 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9009 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9010 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9011 ok(!olp, "Overlapped structure is at %p\n", olp);
9012
9013 if (src != INVALID_SOCKET)
9014 closesocket(src);
9015 if (connector != INVALID_SOCKET)
9016 closesocket(connector);
9017
9018 /* */
9019
9020 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
9021 goto end;
9022
9023 dest = socket(AF_INET, SOCK_STREAM, 0);
9024 if (dest == INVALID_SOCKET)
9025 {
9026 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
9027 goto end;
9028 }
9029
9030 connector = socket(AF_INET, SOCK_STREAM, 0);
9031 if (connector == INVALID_SOCKET) {
9032 skip("could not create connector socket, error %d\n", WSAGetLastError());
9033 goto end;
9034 }
9035
9036 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
9037 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9038
9039 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
9040 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
9041
9042 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
9043 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
9044 &num_bytes, &ov);
9045 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
9046 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
9047
9048 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
9049 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9050
9051 closesocket(dest);
9052 dest = INVALID_SOCKET;
9053
9054 SetLastError(0xdeadbeef);
9055 key = 0xdeadbeef;
9056 num_bytes = 0xdeadbeef;
9057 olp = (WSAOVERLAPPED *)0xdeadbeef;
9058
9059 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
9060 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9061 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED ||
9062 GetLastError() == ERROR_OPERATION_ABORTED ||
9063 GetLastError() == ERROR_CONNECTION_ABORTED ||
9064 GetLastError() == ERROR_PIPE_NOT_CONNECTED /* win 2000 */,
9065 "Last error was %d\n", GetLastError());
9066 ok(key == 125, "Key is %lu\n", key);
9067 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
9068 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
9069 todo_wine ok(olp && (olp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT ||
9070 olp->Internal == (ULONG)STATUS_CANCELLED ||
9071 olp->Internal == (ULONG)STATUS_CONNECTION_ABORTED ||
9072 olp->Internal == (ULONG)STATUS_PIPE_DISCONNECTED /* win 2000 */),
9073 "Internal status is %lx\n", olp ? olp->Internal : 0);
9074
9075 SetLastError(0xdeadbeef);
9076 key = 0xdeadbeef;
9077 num_bytes = 0xdeadbeef;
9078 olp = (WSAOVERLAPPED *)0xdeadbeef;
9079 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
9080 ok(bret == FALSE, "failed to get completion status %u\n", bret);
9081 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
9082 ok(key == 0xdeadbeef, "Key is %lu\n", key);
9083 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
9084 ok(!olp, "Overlapped structure is at %p\n", olp);
9085
9086
9087 end:
9088 if (dest != INVALID_SOCKET)
9089 closesocket(dest);
9090 if (src != INVALID_SOCKET)
9091 closesocket(src);
9092 if (connector != INVALID_SOCKET)
9093 closesocket(connector);
9094 CloseHandle(previous_port);
9095 }
9096
9097 static void test_address_list_query(void)
9098 {
9099 SOCKET_ADDRESS_LIST *address_list;
9100 DWORD bytes_returned, size;
9101 unsigned int i;
9102 SOCKET s;
9103 int ret;
9104
9105 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
9106 ok(s != INVALID_SOCKET, "Failed to create socket, error %d.\n", WSAGetLastError());
9107
9108 bytes_returned = 0;
9109 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0, &bytes_returned, NULL, NULL);
9110 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9111 if(WSAGetLastError() == WSAEINVAL)
9112 {
9113 win_skip("Windows <= NT4 is not supported in this test\n");
9114 closesocket(s);
9115 return;
9116 }
9117 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9118 ok(bytes_returned >= FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]),
9119 "Got unexpected bytes_returned %u.\n", bytes_returned);
9120
9121 size = bytes_returned;
9122 bytes_returned = 0;
9123 address_list = HeapAlloc(GetProcessHeap(), 0, size * 2);
9124 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, size * 2, &bytes_returned, NULL, NULL);
9125 ok(!ret, "Got unexpected ret %d, error %d.\n", ret, WSAGetLastError());
9126 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
9127
9128 bytes_returned = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[address_list->iAddressCount]);
9129 for (i = 0; i < address_list->iAddressCount; ++i)
9130 {
9131 bytes_returned += address_list->Address[i].iSockaddrLength;
9132 }
9133 ok(size == bytes_returned, "Got unexpected size %u, expected %u.\n", size, bytes_returned);
9134
9135 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, size, NULL, NULL, NULL);
9136 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9137 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9138
9139 bytes_returned = 0xdeadbeef;
9140 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, size, &bytes_returned, NULL, NULL);
9141 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9142 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9143 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
9144
9145 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, 1, &bytes_returned, NULL, NULL);
9146 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9147 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
9148 ok(bytes_returned == 0, "Got unexpected bytes_returned %u.\n", bytes_returned);
9149
9150 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list,
9151 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &bytes_returned, NULL, NULL);
9152 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
9153 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
9154 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
9155
9156 HeapFree(GetProcessHeap(), 0, address_list);
9157 closesocket(s);
9158 }
9159
9160 static DWORD WINAPI inet_ntoa_thread_proc(void *param)
9161 {
9162 ULONG addr;
9163 const char *str;
9164 HANDLE *event = param;
9165
9166 addr = inet_addr("4.3.2.1");
9167 ok(addr == htonl(0x04030201), "expected 0x04030201, got %08x\n", addr);
9168 str = inet_ntoa(*(struct in_addr *)&addr);
9169 ok(!strcmp(str, "4.3.2.1"), "expected 4.3.2.1, got %s\n", str);
9170
9171 SetEvent(event[0]);
9172 WaitForSingleObject(event[1], 3000);
9173
9174 return 0;
9175 }
9176
9177 static void test_inet_ntoa(void)
9178 {
9179 ULONG addr;
9180 const char *str;
9181 HANDLE thread, event[2];
9182 DWORD tid;
9183
9184 addr = inet_addr("1.2.3.4");
9185 ok(addr == htonl(0x01020304), "expected 0x01020304, got %08x\n", addr);
9186 str = inet_ntoa(*(struct in_addr *)&addr);
9187 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
9188
9189 event[0] = CreateEventW(NULL, TRUE, FALSE, NULL);
9190 event[1] = CreateEventW(NULL, TRUE, FALSE, NULL);
9191
9192 thread = CreateThread(NULL, 0, inet_ntoa_thread_proc, event, 0, &tid);
9193 WaitForSingleObject(event[0], 3000);
9194
9195 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
9196
9197 SetEvent(event[1]);
9198 WaitForSingleObject(thread, 3000);
9199
9200 CloseHandle(event[0]);
9201 CloseHandle(event[1]);
9202 CloseHandle(thread);
9203 }
9204
9205 static void test_WSALookupService(void)
9206 {
9207 char buffer[4096], strbuff[128];
9208 WSAQUERYSETW *qs = NULL;
9209 HANDLE hnd;
9210 PNLA_BLOB netdata;
9211 int ret;
9212 DWORD error, offset, bsize;
9213
9214 if (!pWSALookupServiceBeginW || !pWSALookupServiceEnd || !pWSALookupServiceNextW)
9215 {
9216 win_skip("WSALookupServiceBeginW or WSALookupServiceEnd or WSALookupServiceNextW not found\n");
9217 return;
9218 }
9219
9220 qs = (WSAQUERYSETW *)buffer;
9221 memset(qs, 0, sizeof(*qs));
9222
9223 /* invalid parameter tests */
9224 ret = pWSALookupServiceBeginW(NULL, 0, &hnd);
9225 error = WSAGetLastError();
9226 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
9227 todo_wine
9228 ok(error == WSAEFAULT, "expected 10014, got %d\n", error);
9229
9230 ret = pWSALookupServiceBeginW(qs, 0, NULL);
9231 error = WSAGetLastError();
9232 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
9233 todo_wine
9234 ok(error == WSAEFAULT, "expected 10014, got %d\n", error);
9235
9236 ret = pWSALookupServiceBeginW(qs, 0, &hnd);
9237 error = WSAGetLastError();
9238 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
9239 todo_wine
9240 ok(error == WSAEINVAL
9241 || broken(error == ERROR_INVALID_PARAMETER) /* == XP */
9242 || broken(error == WSAEFAULT) /* == NT */
9243 || broken(error == WSASERVICE_NOT_FOUND) /* == 2000 */,
9244 "expected 10022, got %d\n", error);
9245
9246 ret = pWSALookupServiceEnd(NULL);
9247 error = WSAGetLastError();
9248 todo_wine
9249 ok(ret == SOCKET_ERROR, "WSALookupServiceEnd should have failed\n");
9250 todo_wine
9251 ok(error == ERROR_INVALID_HANDLE, "expected 6, got %d\n", error);
9252
9253 /* standard network list query */
9254 qs->dwSize = sizeof(*qs);
9255 hnd = (HANDLE)0xdeadbeef;
9256 ret = pWSALookupServiceBeginW(qs, LUP_RETURN_ALL | LUP_DEEP, &hnd);
9257 error = WSAGetLastError();
9258 if(ret && error == ERROR_INVALID_PARAMETER)
9259 {
9260 win_skip("the current WSALookupServiceBeginW test is not supported in win <= 2000\n");
9261 return;
9262 }
9263
9264 todo_wine
9265 ok(!ret, "WSALookupServiceBeginW failed unexpectedly with error %d\n", error);
9266 todo_wine
9267 ok(hnd != (HANDLE)0xdeadbeef, "Handle was not filled\n");
9268
9269 offset = 0;
9270 do
9271 {
9272 memset(qs, 0, sizeof(*qs));
9273 bsize = sizeof(buffer);
9274
9275 if (pWSALookupServiceNextW(hnd, 0, &bsize, qs) == SOCKET_ERROR)
9276 {
9277 error = WSAGetLastError();
9278 if (error == WSA_E_NO_MORE) break;
9279 ok(0, "Error %d happened while listing services\n", error);
9280 break;
9281 }
9282
9283 WideCharToMultiByte(CP_ACP, 0, qs->lpszServiceInstanceName, -1,
9284 strbuff, sizeof(strbuff), NULL, NULL);
9285 trace("Network Name: %s\n", strbuff);
9286
9287 /* network data is written in the blob field */
9288 if (qs->lpBlob)
9289 {
9290 /* each network may have multiple NLA_BLOB information structures */
9291 do
9292 {
9293 netdata = (PNLA_BLOB) &qs->lpBlob->pBlobData[offset];
9294 switch (netdata->header.type)
9295 {
9296 case NLA_RAW_DATA:
9297 trace("\tNLA Data Type: NLA_RAW_DATA\n");
9298 break;
9299 case NLA_INTERFACE:
9300 trace("\tNLA Data Type: NLA_INTERFACE\n");
9301 trace("\t\tType: %d\n", netdata->data.interfaceData.dwType);
9302 trace("\t\tSpeed: %d\n", netdata->data.interfaceData.dwSpeed);
9303 trace("\t\tAdapter Name: %s\n", netdata->data.interfaceData.adapterName);
9304 break;
9305 case NLA_802_1X_LOCATION:
9306 trace("\tNLA Data Type: NLA_802_1X_LOCATION\n");
9307 trace("\t\tInformation: %s\n", netdata->data.locationData.information);
9308 break;
9309 case NLA_CONNECTIVITY:
9310 switch (netdata->data.connectivity.type)
9311 {
9312 case NLA_NETWORK_AD_HOC:
9313 trace("\t\tNetwork Type: AD HOC\n");
9314 break;
9315 case NLA_NETWORK_MANAGED:
9316 trace("\t\tNetwork Type: Managed\n");
9317 break;
9318 case NLA_NETWORK_UNMANAGED:
9319 trace("\t\tNetwork Type: Unmanaged\n");
9320 break;
9321 case NLA_NETWORK_UNKNOWN:
9322 trace("\t\tNetwork Type: Unknown\n");
9323 }
9324 switch (netdata->data.connectivity.internet)
9325 {
9326 case NLA_INTERNET_NO:
9327 trace("\t\tInternet connectivity: No\n");
9328 break;
9329 case NLA_INTERNET_YES:
9330 trace("\t\tInternet connectivity: Yes\n");
9331 break;
9332 case NLA_INTERNET_UNKNOWN:
9333 trace("\t\tInternet connectivity: Unknown\n");
9334 break;
9335 }
9336 break;
9337 case NLA_ICS:
9338 trace("\tNLA Data Type: NLA_ICS\n");
9339 trace("\t\tSpeed: %d\n",
9340 netdata->data.ICS.remote.speed);
9341 trace("\t\tType: %d\n",
9342 netdata->data.ICS.remote.type);
9343 trace("\t\tState: %d\n",
9344 netdata->data.ICS.remote.state);
9345 WideCharToMultiByte(CP_ACP, 0, netdata->data.ICS.remote.machineName, -1,
9346 strbuff, sizeof(strbuff), NULL, NULL);
9347 trace("\t\tMachine Name: %s\n", strbuff);
9348 WideCharToMultiByte(CP_ACP, 0, netdata->data.ICS.remote.sharedAdapterName, -1,
9349 strbuff, sizeof(strbuff), NULL, NULL);
9350 trace("\t\tShared Adapter Name: %s\n", strbuff);
9351 break;
9352 default:
9353 trace("\tNLA Data Type: Unknown\n");
9354 break;
9355 }
9356 }
9357 while (offset);
9358 }
9359 }
9360 while (1);
9361
9362 ret = pWSALookupServiceEnd(hnd);
9363 ok(!ret, "WSALookupServiceEnd failed unexpectedly\n");
9364 }
9365
9366 static void test_WSAEnumNameSpaceProvidersA(void)
9367 {
9368 LPWSANAMESPACE_INFOA name = NULL;
9369 DWORD ret, error, blen = 0, i;
9370 if (!pWSAEnumNameSpaceProvidersA)
9371 {
9372 win_skip("WSAEnumNameSpaceProvidersA not found\n");
9373 return;
9374 }
9375
9376 SetLastError(0xdeadbeef);
9377 ret = pWSAEnumNameSpaceProvidersA(&blen, name);
9378 error = WSAGetLastError();
9379 todo_wine
9380 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9381 todo_wine
9382 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9383
9384 /* Invalid parameter tests */
9385 SetLastError(0xdeadbeef);
9386 ret = pWSAEnumNameSpaceProvidersA(NULL, name);
9387 error = WSAGetLastError();
9388 todo_wine
9389 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9390 todo_wine
9391 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9392
9393 SetLastError(0xdeadbeef);
9394 ret = pWSAEnumNameSpaceProvidersA(NULL, NULL);
9395 error = WSAGetLastError();
9396 todo_wine
9397 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9398 todo_wine
9399 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9400
9401 SetLastError(0xdeadbeef);
9402 ret = pWSAEnumNameSpaceProvidersA(&blen, NULL);
9403 error = WSAGetLastError();
9404 todo_wine
9405 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9406 todo_wine
9407 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9408
9409 name = HeapAlloc(GetProcessHeap(), 0, blen);
9410 if (!name)
9411 {
9412 skip("Failed to alloc memory\n");
9413 return;
9414 }
9415
9416 ret = pWSAEnumNameSpaceProvidersA(&blen, name);
9417 todo_wine
9418 ok(ret > 0, "Expected more than zero name space providers\n");
9419
9420 for (i = 0;i < ret; i++)
9421 {
9422 trace("Name space Identifier (%p): %s\n", name[i].lpszIdentifier,
9423 name[i].lpszIdentifier);
9424 switch (name[i].dwNameSpace)
9425 {
9426 case NS_DNS:
9427 trace("\tName space ID: NS_DNS (%u)\n", name[i].dwNameSpace);
9428 break;
9429 case NS_NLA:
9430 trace("\tName space ID: NS_NLA (%u)\n", name[i].dwNameSpace);
9431 break;
9432 default:
9433 trace("\tName space ID: Unknown (%u)\n", name[i].dwNameSpace);
9434 break;
9435 }
9436 trace("\tActive: %d\n", name[i].fActive);
9437 trace("\tVersion: %d\n", name[i].dwVersion);
9438 }
9439
9440 HeapFree(GetProcessHeap(), 0, name);
9441 }
9442
9443 static void test_WSAEnumNameSpaceProvidersW(void)
9444 {
9445 LPWSANAMESPACE_INFOW name = NULL;
9446 DWORD ret, error, blen = 0, i;
9447 if (!pWSAEnumNameSpaceProvidersW)
9448 {
9449 win_skip("WSAEnumNameSpaceProvidersW not found\n");
9450 return;
9451 }
9452
9453 SetLastError(0xdeadbeef);
9454 ret = pWSAEnumNameSpaceProvidersW(&blen, name);
9455 error = WSAGetLastError();
9456 todo_wine
9457 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9458 todo_wine
9459 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9460
9461 /* Invalid parameter tests */
9462 SetLastError(0xdeadbeef);
9463 ret = pWSAEnumNameSpaceProvidersW(NULL, name);
9464 error = WSAGetLastError();
9465 todo_wine
9466 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9467 todo_wine
9468 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9469
9470 SetLastError(0xdeadbeef);
9471 ret = pWSAEnumNameSpaceProvidersW(NULL, NULL);
9472 error = WSAGetLastError();
9473 todo_wine
9474 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9475 todo_wine
9476 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9477
9478 SetLastError(0xdeadbeef);
9479 ret = pWSAEnumNameSpaceProvidersW(&blen, NULL);
9480 error = WSAGetLastError();
9481 todo_wine
9482 ok(ret == SOCKET_ERROR, "Expected failure, got %u\n", ret);
9483 todo_wine
9484 ok(error == WSAEFAULT, "Expected 10014, got %u\n", error);
9485
9486 name = HeapAlloc(GetProcessHeap(), 0, blen);
9487 if (!name)
9488 {
9489 skip("Failed to alloc memory\n");
9490 return;
9491 }
9492
9493 ret = pWSAEnumNameSpaceProvidersW(&blen, name);
9494 todo_wine
9495 ok(ret > 0, "Expected more than zero name space providers\n");
9496
9497 for (i = 0;i < ret; i++)
9498 {
9499 trace("Name space Identifier (%p): %s\n", name[i].lpszIdentifier,
9500 wine_dbgstr_w(name[i].lpszIdentifier));
9501 switch (name[i].dwNameSpace)
9502 {
9503 case NS_DNS:
9504 trace("\tName space ID: NS_DNS (%u)\n", name[i].dwNameSpace);
9505 break;
9506 case NS_NLA:
9507 trace("\tName space ID: NS_NLA (%u)\n", name[i].dwNameSpace);
9508 break;
9509 default:
9510 trace("\tName space ID: Unknown (%u)\n", name[i].dwNameSpace);
9511 break;
9512 }
9513 trace("\tActive: %d\n", name[i].fActive);
9514 trace("\tVersion: %d\n", name[i].dwVersion);
9515 }
9516
9517 HeapFree(GetProcessHeap(), 0, name);
9518 }
9519
9520 /**************** Main program ***************/
9521
9522 START_TEST( sock )
9523 {
9524 int i;
9525
9526 /* Leave these tests at the beginning. They depend on WSAStartup not having been
9527 * called, which is done by Init() below. */
9528 test_WithoutWSAStartup();
9529 test_WithWSAStartup();
9530
9531 Init();
9532
9533 test_inet_ntoa();
9534 test_inet_pton();
9535 test_set_getsockopt();
9536 test_so_reuseaddr();
9537 test_ip_pktinfo();
9538 test_extendedSocketOptions();
9539
9540 for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
9541 {
9542 trace ( " **** STARTING TEST %d ****\n", i );
9543 do_test ( &tests[i] );
9544 trace ( " **** TEST %d COMPLETE ****\n", i );
9545 }
9546
9547 test_UDP();
9548
9549 test_getservbyname();
9550 test_WSASocket();
9551 test_WSADuplicateSocket();
9552 test_WSAEnumNetworkEvents();
9553
9554 test_WSAAddressToStringA();
9555 test_WSAAddressToStringW();
9556
9557 test_WSAStringToAddressA();
9558 test_WSAStringToAddressW();
9559
9560 test_errors();
9561 test_listen();
9562 test_select();
9563 test_accept();
9564 test_getpeername();
9565 test_getsockname();
9566 test_inet_addr();
9567 test_addr_to_print();
9568 test_ioctlsocket();
9569 test_dns();
9570 test_gethostbyname();
9571 test_gethostbyname_hack();
9572 test_gethostname();
9573
9574 test_WSASendMsg();
9575 test_WSASendTo();
9576 test_WSARecv();
9577 test_WSAPoll();
9578
9579 test_events(0);
9580 test_events(1);
9581
9582 test_ipv6only();
9583 test_TransmitFile();
9584 test_GetAddrInfoW();
9585 test_getaddrinfo();
9586 test_AcceptEx();
9587 test_ConnectEx();
9588
9589 test_sioRoutingInterfaceQuery();
9590 test_sioAddressListChange();
9591
9592 test_WSALookupService();
9593 test_WSAEnumNameSpaceProvidersA();
9594 test_WSAEnumNameSpaceProvidersW();
9595
9596 test_WSAAsyncGetServByPort();
9597 test_WSAAsyncGetServByName();
9598
9599 test_completion_port();
9600 test_address_list_query();
9601
9602 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
9603 test_send();
9604 test_synchronous_WSAIoctl();
9605
9606 Exit();
9607 }
Maarten's multimedia branch