?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ws2_32/tests: Add tests for InetPtonW.
[wine/multimedia.git] / dlls / ws2_32 / tests / sock.c
blob75746314746ac3a1197673f9cf4ec6d6f8206c9f
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 <stdio.h>
34 #include "wine/test.h"
35
36 #define MAX_CLIENTS 4 /* Max number of clients */
37 #define FIRST_CHAR 'A' /* First character in transferred pattern */
38 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
39 #define BIND_TRIES 6 /* Number of bind() attempts */
40 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
41 after server initialization, if something hangs */
42
43 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
44
45 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
46 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
47
48 #define SERVERIP "127.0.0.1" /* IP to bind to */
49 #define SERVERPORT 9374 /* Port number to bind to */
50
51 #define wsa_ok(op, cond, msg) \
52 do { \
53 int tmp, err = 0; \
54 tmp = op; \
55 if ( !(cond tmp) ) err = WSAGetLastError(); \
56 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
57 } while (0);
58
59 #define make_keepalive(k, enable, time, interval) \
60 k.onoff = enable; \
61 k.keepalivetime = time; \
62 k.keepaliveinterval = interval;
63
64 /* Function pointers */
65 static void (WINAPI *pfreeaddrinfo)(struct addrinfo *);
66 static int (WINAPI *pgetaddrinfo)(LPCSTR,LPCSTR,const struct addrinfo *,struct addrinfo **);
67 static void (WINAPI *pFreeAddrInfoW)(PADDRINFOW);
68 static int (WINAPI *pGetAddrInfoW)(LPCWSTR,LPCWSTR,const ADDRINFOW *,PADDRINFOW *);
69 static PCSTR (WINAPI *pInetNtop)(INT,LPVOID,LPSTR,ULONG);
70 static int (WINAPI *pInetPtonA)(INT,LPCSTR,LPVOID);
71 static int (WINAPI *pInetPtonW)(INT,LPWSTR,LPVOID);
72 static int (WINAPI *pWSALookupServiceBeginW)(LPWSAQUERYSETW,DWORD,LPHANDLE);
73 static int (WINAPI *pWSALookupServiceEnd)(HANDLE);
74 static int (WINAPI *pWSALookupServiceNextW)(HANDLE,DWORD,LPDWORD,LPWSAQUERYSETW);
75
76 /**************** Structs and typedefs ***************/
77
78 typedef struct thread_info
79 {
80 HANDLE thread;
81 DWORD id;
82 } thread_info;
83
84 /* Information in the server about open client connections */
85 typedef struct sock_info
86 {
87 SOCKET s;
88 struct sockaddr_in addr;
89 struct sockaddr_in peer;
90 char *buf;
91 int n_recvd;
92 int n_sent;
93 } sock_info;
94
95 /* Test parameters for both server & client */
96 typedef struct test_params
97 {
98 int sock_type;
99 int sock_prot;
100 const char *inet_addr;
101 short inet_port;
102 int chunk_size;
103 int n_chunks;
104 int n_clients;
105 } test_params;
106
107 /* server-specific test parameters */
108 typedef struct server_params
109 {
110 test_params *general;
111 DWORD sock_flags;
112 int buflen;
113 } server_params;
114
115 /* client-specific test parameters */
116 typedef struct client_params
117 {
118 test_params *general;
119 DWORD sock_flags;
120 int buflen;
121 } client_params;
122
123 /* This type combines all information for setting up a test scenario */
124 typedef struct test_setup
125 {
126 test_params general;
127 LPVOID srv;
128 server_params srv_params;
129 LPVOID clt;
130 client_params clt_params;
131 } test_setup;
132
133 /* Thread local storage for server */
134 typedef struct server_memory
135 {
136 SOCKET s;
137 struct sockaddr_in addr;
138 sock_info sock[MAX_CLIENTS];
139 } server_memory;
140
141 /* Thread local storage for client */
142 typedef struct client_memory
143 {
144 SOCKET s;
145 struct sockaddr_in addr;
146 char *send_buf;
147 char *recv_buf;
148 } client_memory;
149
150 /* SelectReadThread thread parameters */
151 typedef struct select_thread_params
152 {
153 SOCKET s;
154 BOOL ReadKilled;
155 } select_thread_params;
156
157 /* Tests used in both getaddrinfo and GetAddrInfoW */
158 static const struct addr_hint_tests
159 {
160 int family, socktype, protocol;
161 DWORD error;
162 } hinttests[] = {
163 {AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0 },
164 {AF_UNSPEC, SOCK_STREAM, IPPROTO_UDP, 0 },
165 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_TCP, 0 },
166 {AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, 0 },
167 {AF_INET, SOCK_STREAM, IPPROTO_TCP, 0 },
168 {AF_INET, SOCK_STREAM, IPPROTO_UDP, 0 },
169 {AF_INET, SOCK_DGRAM, IPPROTO_TCP, 0 },
170 {AF_INET, SOCK_DGRAM, IPPROTO_UDP, 0 },
171 {AF_UNSPEC, 0, IPPROTO_TCP, 0 },
172 {AF_UNSPEC, 0, IPPROTO_UDP, 0 },
173 {AF_UNSPEC, SOCK_STREAM, 0, 0 },
174 {AF_UNSPEC, SOCK_DGRAM, 0, 0 },
175 {AF_INET, 0, IPPROTO_TCP, 0 },
176 {AF_INET, 0, IPPROTO_UDP, 0 },
177 {AF_INET, SOCK_STREAM, 0, 0 },
178 {AF_INET, SOCK_DGRAM, 0, 0 },
179 {AF_UNSPEC, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT },
180 {AF_UNSPEC, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT },
181 {AF_INET, 999, IPPROTO_TCP, WSAESOCKTNOSUPPORT },
182 {AF_INET, 999, IPPROTO_UDP, WSAESOCKTNOSUPPORT },
183 {AF_UNSPEC, SOCK_STREAM, 999, 0 },
184 {AF_UNSPEC, SOCK_STREAM, 999, 0 },
185 {AF_INET, SOCK_DGRAM, 999, 0 },
186 {AF_INET, SOCK_DGRAM, 999, 0 },
187 };
188
189 /**************** Static variables ***************/
190
191 static DWORD tls; /* Thread local storage index */
192 static HANDLE thread[1+MAX_CLIENTS];
193 static DWORD thread_id[1+MAX_CLIENTS];
194 static HANDLE server_ready;
195 static HANDLE client_ready[MAX_CLIENTS];
196 static int client_id;
197
198 /**************** General utility functions ***************/
199
200 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len);
201 static SOCKET setup_connector_socket(struct sockaddr_in *addr, int len, BOOL nonblock);
202
203 static int tcp_socketpair(SOCKET *src, SOCKET *dst)
204 {
205 SOCKET server = INVALID_SOCKET;
206 struct sockaddr_in addr;
207 int len;
208 int ret;
209
210 *src = INVALID_SOCKET;
211 *dst = INVALID_SOCKET;
212
213 *src = socket(AF_INET, SOCK_STREAM, 0);
214 if (*src == INVALID_SOCKET)
215 goto end;
216
217 server = socket(AF_INET, SOCK_STREAM, 0);
218 if (server == INVALID_SOCKET)
219 goto end;
220
221 memset(&addr, 0, sizeof(addr));
222 addr.sin_family = AF_INET;
223 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
224 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
225 if (ret != 0)
226 goto end;
227
228 len = sizeof(addr);
229 ret = getsockname(server, (struct sockaddr*)&addr, &len);
230 if (ret != 0)
231 goto end;
232
233 ret = listen(server, 1);
234 if (ret != 0)
235 goto end;
236
237 ret = connect(*src, (struct sockaddr*)&addr, sizeof(addr));
238 if (ret != 0)
239 goto end;
240
241 len = sizeof(addr);
242 *dst = accept(server, (struct sockaddr*)&addr, &len);
243
244 end:
245 if (server != INVALID_SOCKET)
246 closesocket(server);
247 if (*src != INVALID_SOCKET && *dst != INVALID_SOCKET)
248 return 0;
249 closesocket(*src);
250 closesocket(*dst);
251 return -1;
252 }
253
254 static void set_so_opentype ( BOOL overlapped )
255 {
256 int optval = !overlapped, newval, len = sizeof (int);
257
258 ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
259 (LPVOID) &optval, sizeof (optval) ) == 0,
260 "setting SO_OPENTYPE failed\n" );
261 ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
262 (LPVOID) &newval, &len ) == 0,
263 "getting SO_OPENTYPE failed\n" );
264 ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
265 }
266
267 static int set_blocking ( SOCKET s, BOOL blocking )
268 {
269 u_long val = !blocking;
270 return ioctlsocket ( s, FIONBIO, &val );
271 }
272
273 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
274 {
275 char c, *p;
276 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
277 memset ( p, c, chunk_size );
278 }
279
280 static int test_buffer ( char *buf, int chunk_size, int n_chunks )
281 {
282 char c, *p;
283 int i;
284 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
285 {
286 for ( i = 0; i < chunk_size; i++ )
287 if ( p[i] != c ) return i;
288 }
289 return -1;
290 }
291
292 /*
293 * This routine is called when a client / server does not expect any more data,
294 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
295 */
296 static void read_zero_bytes ( SOCKET s )
297 {
298 char buf[256];
299 int tmp, n = 0;
300 while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
301 n += tmp;
302 ok ( n <= 0, "garbage data received: %d bytes\n", n );
303 }
304
305 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int flags, int sendlen )
306 {
307 char* last = buf + buflen, *p;
308 int n = 1;
309 for ( p = buf; n > 0 && p < last; )
310 {
311 n = send ( s, p, min ( sendlen, last - p ), flags );
312 if (n > 0) p += n;
313 }
314 wsa_ok ( n, 0 <=, "do_synchronous_send (%x): error %d\n" );
315 return p - buf;
316 }
317
318 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int flags, int recvlen )
319 {
320 char* last = buf + buflen, *p;
321 int n = 1;
322 for ( p = buf; n > 0 && p < last; )
323 {
324 n = recv ( s, p, min ( recvlen, last - p ), flags );
325 if (n > 0) p += n;
326 }
327 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
328 return p - buf;
329 }
330
331 static int do_synchronous_recvfrom ( SOCKET s, char *buf, int buflen, int flags, struct sockaddr *from, int *fromlen, int recvlen )
332 {
333 char* last = buf + buflen, *p;
334 int n = 1;
335 for ( p = buf; n > 0 && p < last; )
336 {
337 n = recvfrom ( s, p, min ( recvlen, last - p ), flags, from, fromlen );
338 if (n > 0) p += n;
339 }
340 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
341 return p - buf;
342 }
343
344 /*
345 * Call this routine right after thread startup.
346 * SO_OPENTYPE must by 0, regardless what the server did.
347 */
348 static void check_so_opentype (void)
349 {
350 int tmp = 1, len;
351 len = sizeof (tmp);
352 getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
353 ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
354 }
355
356 static void compare_addrinfo (ADDRINFO *a, ADDRINFO *b)
357 {
358 for (; a && b ; a = a->ai_next, b = b->ai_next)
359 {
360 ok(a->ai_flags == b->ai_flags,
361 "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags);
362 ok(a->ai_family == b->ai_family,
363 "Wrong family %d != %d\n", a->ai_family, b->ai_family);
364 ok(a->ai_socktype == b->ai_socktype,
365 "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype);
366 ok(a->ai_protocol == b->ai_protocol,
367 "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol);
368 ok(a->ai_addrlen == b->ai_addrlen,
369 "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen);
370 ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)),
371 "Wrong address data\n");
372 if (a->ai_canonname && b->ai_canonname)
373 {
374 ok(!strcmp(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n",
375 a->ai_canonname, b->ai_canonname);
376 }
377 else
378 ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n",
379 a->ai_canonname, b->ai_canonname);
380 }
381 ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b);
382 }
383
384 static void compare_addrinfow (ADDRINFOW *a, ADDRINFOW *b)
385 {
386 for (; a && b ; a = a->ai_next, b = b->ai_next)
387 {
388 ok(a->ai_flags == b->ai_flags,
389 "Wrong flags %d != %d\n", a->ai_flags, b->ai_flags);
390 ok(a->ai_family == b->ai_family,
391 "Wrong family %d != %d\n", a->ai_family, b->ai_family);
392 ok(a->ai_socktype == b->ai_socktype,
393 "Wrong socktype %d != %d\n", a->ai_socktype, b->ai_socktype);
394 ok(a->ai_protocol == b->ai_protocol,
395 "Wrong protocol %d != %d\n", a->ai_protocol, b->ai_protocol);
396 ok(a->ai_addrlen == b->ai_addrlen,
397 "Wrong addrlen %lu != %lu\n", a->ai_addrlen, b->ai_addrlen);
398 ok(!memcmp(a->ai_addr, b->ai_addr, min(a->ai_addrlen, b->ai_addrlen)),
399 "Wrong address data\n");
400 if (a->ai_canonname && b->ai_canonname)
401 {
402 ok(!lstrcmpW(a->ai_canonname, b->ai_canonname), "Wrong canonical name '%s' != '%s'\n",
403 wine_dbgstr_w(a->ai_canonname), wine_dbgstr_w(b->ai_canonname));
404 }
405 else
406 ok(!a->ai_canonname && !b->ai_canonname, "Expected both names absent (%p != %p)\n",
407 a->ai_canonname, b->ai_canonname);
408 }
409 ok(!a && !b, "Expected both addresses null (%p != %p)\n", a, b);
410 }
411
412 /**************** Server utility functions ***************/
413
414 /*
415 * Even if we have closed our server socket cleanly,
416 * the OS may mark the address "in use" for some time -
417 * this happens with native Linux apps, too.
418 */
419 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
420 {
421 int err, wsaerr = 0, n_try = BIND_TRIES;
422
423 while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
424 ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
425 n_try-- >= 0)
426 {
427 trace ( "address in use, waiting ...\n" );
428 Sleep ( 1000 * BIND_SLEEP );
429 }
430 ok ( err == 0, "failed to bind: %d\n", wsaerr );
431 }
432
433 static void server_start ( server_params *par )
434 {
435 int i;
436 test_params *gen = par->general;
437 server_memory *mem = LocalAlloc ( LPTR, sizeof ( server_memory ) );
438
439 TlsSetValue ( tls, mem );
440 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
441 NULL, 0, par->sock_flags );
442 ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
443
444 mem->addr.sin_family = AF_INET;
445 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
446 mem->addr.sin_port = htons ( gen->inet_port );
447
448 for (i = 0; i < MAX_CLIENTS; i++)
449 {
450 mem->sock[i].s = INVALID_SOCKET;
451 mem->sock[i].buf = LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
452 mem->sock[i].n_recvd = 0;
453 mem->sock[i].n_sent = 0;
454 }
455
456 if ( gen->sock_type == SOCK_STREAM )
457 do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
458 }
459
460 static void server_stop (void)
461 {
462 int i;
463 server_memory *mem = TlsGetValue ( tls );
464
465 for (i = 0; i < MAX_CLIENTS; i++ )
466 {
467 LocalFree ( mem->sock[i].buf );
468 if ( mem->sock[i].s != INVALID_SOCKET )
469 closesocket ( mem->sock[i].s );
470 }
471 ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
472 LocalFree ( mem );
473 ExitThread ( GetCurrentThreadId () );
474 }
475
476 /**************** Client utilitiy functions ***************/
477
478 static void client_start ( client_params *par )
479 {
480 test_params *gen = par->general;
481 client_memory *mem = LocalAlloc (LPTR, sizeof (client_memory));
482
483 TlsSetValue ( tls, mem );
484
485 WaitForSingleObject ( server_ready, INFINITE );
486
487 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
488 NULL, 0, par->sock_flags );
489
490 mem->addr.sin_family = AF_INET;
491 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
492 mem->addr.sin_port = htons ( gen->inet_port );
493
494 ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
495
496 mem->send_buf = LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
497 mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
498 fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
499
500 SetEvent ( client_ready[client_id] );
501 /* Wait for the other clients to come up */
502 WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
503 }
504
505 static void client_stop (void)
506 {
507 client_memory *mem = TlsGetValue ( tls );
508 wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%x): %d\n" );
509 LocalFree ( mem->send_buf );
510 LocalFree ( mem );
511 ExitThread(0);
512 }
513
514 /**************** Servers ***************/
515
516 /*
517 * simple_server: A very basic server doing synchronous IO.
518 */
519 static VOID WINAPI simple_server ( server_params *par )
520 {
521 test_params *gen = par->general;
522 server_memory *mem;
523 int pos, n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
524 id = GetCurrentThreadId();
525
526 trace ( "simple_server (%x) starting\n", id );
527
528 set_so_opentype ( FALSE ); /* non-overlapped */
529 server_start ( par );
530 mem = TlsGetValue ( tls );
531
532 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
533 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%x): listen failed: %d\n");
534
535 trace ( "simple_server (%x) ready\n", id );
536 SetEvent ( server_ready ); /* notify clients */
537
538 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
539 {
540 trace ( "simple_server (%x): waiting for client\n", id );
541
542 /* accept a single connection */
543 tmp = sizeof ( mem->sock[0].peer );
544 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
545 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%x): accept failed: %d\n" );
546
547 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
548 "simple_server (%x): strange peer address\n", id );
549
550 /* Receive data & check it */
551 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
552 ok ( n_recvd == n_expected,
553 "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
554 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
555 ok ( pos == -1, "simple_server (%x): test pattern error: %d\n", id, pos);
556
557 /* Echo data back */
558 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
559 ok ( n_sent == n_expected,
560 "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
561
562 /* cleanup */
563 read_zero_bytes ( mem->sock[0].s );
564 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "simple_server (%x): closesocket error: %d\n" );
565 mem->sock[0].s = INVALID_SOCKET;
566 }
567
568 trace ( "simple_server (%x) exiting\n", id );
569 server_stop ();
570 }
571
572 /*
573 * oob_server: A very basic server receiving out-of-band data.
574 */
575 static VOID WINAPI oob_server ( server_params *par )
576 {
577 test_params *gen = par->general;
578 server_memory *mem;
579 u_long atmark = 0;
580 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, tmp,
581 id = GetCurrentThreadId();
582
583 trace ( "oob_server (%x) starting\n", id );
584
585 set_so_opentype ( FALSE ); /* non-overlapped */
586 server_start ( par );
587 mem = TlsGetValue ( tls );
588
589 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
590 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "oob_server (%x): listen failed: %d\n");
591
592 trace ( "oob_server (%x) ready\n", id );
593 SetEvent ( server_ready ); /* notify clients */
594
595 trace ( "oob_server (%x): waiting for client\n", id );
596
597 /* accept a single connection */
598 tmp = sizeof ( mem->sock[0].peer );
599 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
600 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "oob_server (%x): accept failed: %d\n" );
601
602 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
603 "oob_server (%x): strange peer address\n", id );
604
605 /* check initial atmark state */
606 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
607 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
608
609 /* Receive normal data */
610 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
611 ok ( n_recvd == n_expected,
612 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
613 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
614 ok ( pos == -1, "oob_server (%x): test pattern error: %d\n", id, pos);
615
616 /* check atmark state */
617 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
618 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
619
620 /* Echo data back */
621 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
622 ok ( n_sent == n_expected,
623 "oob_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
624
625 /* Receive a part of the out-of-band data and check atmark state */
626 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, 8, 0, par->buflen );
627 ok ( n_recvd == 8,
628 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, 8 );
629 n_expected -= 8;
630
631 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
632 todo_wine ok ( atmark == 0, "oob_server (%x): not at the OOB mark: %i\n", id, atmark );
633
634 /* Receive the rest of the out-of-band data and check atmark state */
635 do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
636
637 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
638 todo_wine ok ( atmark == 0, "oob_server (%x): not at the OOB mark: %i\n", id, atmark );
639
640 /* cleanup */
641 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "oob_server (%x): closesocket error: %d\n" );
642 mem->sock[0].s = INVALID_SOCKET;
643
644 trace ( "oob_server (%x) exiting\n", id );
645 server_stop ();
646 }
647
648 /*
649 * select_server: A non-blocking server.
650 */
651 static VOID WINAPI select_server ( server_params *par )
652 {
653 test_params *gen = par->general;
654 server_memory *mem;
655 int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
656 id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
657 n_set, delta, n_ready;
658 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
659 fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
660
661 trace ( "select_server (%x) starting\n", id );
662
663 set_so_opentype ( FALSE ); /* non-overlapped */
664 server_start ( par );
665 mem = TlsGetValue ( tls );
666
667 wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
668 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%x): listen failed: %d\n");
669
670 trace ( "select_server (%x) ready\n", id );
671 SetEvent ( server_ready ); /* notify clients */
672
673 FD_ZERO ( &fds_openrecv );
674 FD_ZERO ( &fds_recv );
675 FD_ZERO ( &fds_send );
676 FD_ZERO ( &fds_opensend );
677
678 FD_SET ( mem->s, &fds_openrecv );
679
680 while(1)
681 {
682 fds_recv = fds_openrecv;
683 fds_send = fds_opensend;
684
685 n_set = 0;
686
687 wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
688 "select_server (%x): select() failed: %d\n" );
689
690 /* check for incoming requests */
691 if ( FD_ISSET ( mem->s, &fds_recv ) ) {
692 n_set += 1;
693
694 trace ( "select_server (%x): accepting client connection\n", id );
695
696 /* accept a single connection */
697 tmp = sizeof ( mem->sock[n_connections].peer );
698 mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
699 wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%x): accept() failed: %d\n" );
700
701 ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
702 "select_server (%x): strange peer address\n", id );
703
704 /* add to list of open connections */
705 FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
706 FD_SET ( mem->sock[n_connections].s, &fds_opensend );
707
708 n_connections++;
709 }
710
711 /* handle open requests */
712
713 for ( i = 0; i < n_connections; i++ )
714 {
715 if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
716 n_set += 1;
717
718 if ( mem->sock[i].n_recvd < n_expected ) {
719 /* Receive data & check it */
720 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 );
721 ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
722 mem->sock[i].n_recvd += n_recvd;
723
724 if ( mem->sock[i].n_recvd == n_expected ) {
725 int pos = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
726 ok ( pos == -1, "select_server (%x): test pattern error: %d\n", id, pos );
727 FD_CLR ( mem->sock[i].s, &fds_openrecv );
728 }
729
730 ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
731 }
732 }
733
734 /* only echo back what we've received */
735 delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
736
737 if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
738 n_set += 1;
739
740 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
741 /* Echo data back */
742 n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
743 ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
744 mem->sock[i].n_sent += n_sent;
745
746 if ( mem->sock[i].n_sent == n_expected ) {
747 FD_CLR ( mem->sock[i].s, &fds_opensend );
748 }
749
750 ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
751 }
752 }
753 }
754
755 /* check that select returned the correct number of ready sockets */
756 ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
757
758 /* check if all clients are done */
759 if ( ( fds_opensend.fd_count == 0 )
760 && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
761 && ( n_connections == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
762 break;
763 }
764 }
765
766 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
767 {
768 /* cleanup */
769 read_zero_bytes ( mem->sock[i].s );
770 wsa_ok ( closesocket ( mem->sock[i].s ), 0 ==, "select_server (%x): closesocket error: %d\n" );
771 mem->sock[i].s = INVALID_SOCKET;
772 }
773
774 trace ( "select_server (%x) exiting\n", id );
775 server_stop ();
776 }
777
778 /**************** Clients ***************/
779
780 /*
781 * simple_client: A very basic client doing synchronous IO.
782 */
783 static VOID WINAPI simple_client ( client_params *par )
784 {
785 test_params *gen = par->general;
786 client_memory *mem;
787 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
788
789 id = GetCurrentThreadId();
790 trace ( "simple_client (%x): starting\n", id );
791 /* wait here because we want to call set_so_opentype before creating a socket */
792 WaitForSingleObject ( server_ready, INFINITE );
793 trace ( "simple_client (%x): server ready\n", id );
794
795 check_so_opentype ();
796 set_so_opentype ( FALSE ); /* non-overlapped */
797 client_start ( par );
798 mem = TlsGetValue ( tls );
799
800 /* Connect */
801 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
802 0 ==, "simple_client (%x): connect error: %d\n" );
803 ok ( set_blocking ( mem->s, TRUE ) == 0,
804 "simple_client (%x): failed to set blocking mode\n", id );
805 trace ( "simple_client (%x) connected\n", id );
806
807 /* send data to server */
808 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
809 ok ( n_sent == n_expected,
810 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
811
812 /* shutdown send direction */
813 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
814
815 /* Receive data echoed back & check it */
816 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
817 ok ( n_recvd == n_expected,
818 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
819
820 /* check data */
821 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
822 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
823
824 /* cleanup */
825 read_zero_bytes ( mem->s );
826 trace ( "simple_client (%x) exiting\n", id );
827 client_stop ();
828 }
829
830 /*
831 * oob_client: A very basic client sending out-of-band data.
832 */
833 static VOID WINAPI oob_client ( client_params *par )
834 {
835 test_params *gen = par->general;
836 client_memory *mem;
837 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
838
839 id = GetCurrentThreadId();
840 trace ( "oob_client (%x): starting\n", id );
841 /* wait here because we want to call set_so_opentype before creating a socket */
842 WaitForSingleObject ( server_ready, INFINITE );
843 trace ( "oob_client (%x): server ready\n", id );
844
845 check_so_opentype ();
846 set_so_opentype ( FALSE ); /* non-overlapped */
847 client_start ( par );
848 mem = TlsGetValue ( tls );
849
850 /* Connect */
851 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
852 0 ==, "oob_client (%x): connect error: %d\n" );
853 ok ( set_blocking ( mem->s, TRUE ) == 0,
854 "oob_client (%x): failed to set blocking mode\n", id );
855 trace ( "oob_client (%x) connected\n", id );
856
857 /* send data to server */
858 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
859 ok ( n_sent == n_expected,
860 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
861
862 /* Receive data echoed back & check it */
863 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, 0, par->buflen );
864 ok ( n_recvd == n_expected,
865 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
866 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
867 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
868
869 /* send out-of-band data to server */
870 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, MSG_OOB, par->buflen );
871 ok ( n_sent == n_expected,
872 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
873
874 /* shutdown send direction */
875 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
876
877 /* cleanup */
878 read_zero_bytes ( mem->s );
879 trace ( "oob_client (%x) exiting\n", id );
880 client_stop ();
881 }
882
883 /*
884 * simple_mixed_client: mixing send and recvfrom
885 */
886 static VOID WINAPI simple_mixed_client ( client_params *par )
887 {
888 test_params *gen = par->general;
889 client_memory *mem;
890 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
891 int fromLen = sizeof(mem->addr);
892 struct sockaddr test;
893
894 id = GetCurrentThreadId();
895 trace ( "simple_client (%x): starting\n", id );
896 /* wait here because we want to call set_so_opentype before creating a socket */
897 WaitForSingleObject ( server_ready, INFINITE );
898 trace ( "simple_client (%x): server ready\n", id );
899
900 check_so_opentype ();
901 set_so_opentype ( FALSE ); /* non-overlapped */
902 client_start ( par );
903 mem = TlsGetValue ( tls );
904
905 /* Connect */
906 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
907 0 ==, "simple_client (%x): connect error: %d\n" );
908 ok ( set_blocking ( mem->s, TRUE ) == 0,
909 "simple_client (%x): failed to set blocking mode\n", id );
910 trace ( "simple_client (%x) connected\n", id );
911
912 /* send data to server */
913 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, 0, par->buflen );
914 ok ( n_sent == n_expected,
915 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
916
917 /* shutdown send direction */
918 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
919
920 /* this shouldn't change, since lpFrom, is not updated on
921 connection oriented sockets - exposed by bug 11640
922 */
923 ((struct sockaddr_in*)&test)->sin_addr.s_addr = inet_addr("0.0.0.0");
924
925 /* Receive data echoed back & check it */
926 n_recvd = do_synchronous_recvfrom ( mem->s,
927 mem->recv_buf,
928 n_expected,
929 0,
930 (struct sockaddr *)&test,
931 &fromLen,
932 par->buflen );
933 ok ( n_recvd == n_expected,
934 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
935
936 /* check that lpFrom was not updated */
937 ok(0 ==
938 strcmp(
939 inet_ntoa(((struct sockaddr_in*)&test)->sin_addr),
940 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
941
942 /* check data */
943 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
944 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
945
946 /* cleanup */
947 read_zero_bytes ( mem->s );
948 trace ( "simple_client (%x) exiting\n", id );
949 client_stop ();
950 }
951
952 /*
953 * event_client: An event-driven client
954 */
955 static void WINAPI event_client ( client_params *par )
956 {
957 test_params *gen = par->general;
958 client_memory *mem;
959 int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
960 tmp, err, n;
961 HANDLE event;
962 WSANETWORKEVENTS wsa_events;
963 char *send_last, *recv_last, *send_p, *recv_p;
964 LONG mask = FD_READ | FD_WRITE | FD_CLOSE;
965
966 trace ( "event_client (%x): starting\n", id );
967 client_start ( par );
968 trace ( "event_client (%x): server ready\n", id );
969
970 mem = TlsGetValue ( tls );
971
972 /* Prepare event notification for connect, makes socket nonblocking */
973 event = WSACreateEvent ();
974 WSAEventSelect ( mem->s, event, FD_CONNECT );
975 tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
976 if ( tmp != 0 ) {
977 err = WSAGetLastError ();
978 ok ( err == WSAEWOULDBLOCK, "event_client (%x): connect error: %d\n", id, err );
979 tmp = WaitForSingleObject ( event, INFINITE );
980 ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
981 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
982 ok ( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
983 err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
984 ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
985 if ( err ) goto out;
986 }
987
988 trace ( "event_client (%x) connected\n", id );
989
990 WSAEventSelect ( mem->s, event, mask );
991
992 recv_p = mem->recv_buf;
993 recv_last = mem->recv_buf + n_expected;
994 send_p = mem->send_buf;
995 send_last = mem->send_buf + n_expected;
996
997 while ( TRUE )
998 {
999 err = WaitForSingleObject ( event, INFINITE );
1000 ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
1001
1002 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
1003 ok( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
1004
1005 if ( wsa_events.lNetworkEvents & FD_WRITE )
1006 {
1007 err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
1008 ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
1009
1010 if ( err== 0 )
1011 do
1012 {
1013 n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
1014 if ( n < 0 )
1015 {
1016 err = WSAGetLastError ();
1017 ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
1018 }
1019 else
1020 send_p += n;
1021 }
1022 while ( n >= 0 && send_p < send_last );
1023
1024 if ( send_p == send_last )
1025 {
1026 trace ( "event_client (%x): all data sent - shutdown\n", id );
1027 shutdown ( mem->s, SD_SEND );
1028 mask &= ~FD_WRITE;
1029 WSAEventSelect ( mem->s, event, mask );
1030 }
1031 }
1032 if ( wsa_events.lNetworkEvents & FD_READ )
1033 {
1034 err = wsa_events.iErrorCode[ FD_READ_BIT ];
1035 ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
1036 if ( err != 0 ) break;
1037
1038 /* First read must succeed */
1039 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
1040 wsa_ok ( n, 0 <=, "event_client (%x): recv error: %d\n" );
1041
1042 while ( n >= 0 ) {
1043 recv_p += n;
1044 if ( recv_p == recv_last )
1045 {
1046 mask &= ~FD_READ;
1047 trace ( "event_client (%x): all data received\n", id );
1048 WSAEventSelect ( mem->s, event, mask );
1049 break;
1050 }
1051 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
1052 if ( n < 0 && ( err = WSAGetLastError()) != WSAEWOULDBLOCK )
1053 ok ( 0, "event_client (%x): read error: %d\n", id, err );
1054
1055 }
1056 }
1057 if ( wsa_events.lNetworkEvents & FD_CLOSE )
1058 {
1059 trace ( "event_client (%x): close event\n", id );
1060 err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
1061 ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
1062 break;
1063 }
1064 }
1065
1066 n = send_p - mem->send_buf;
1067 ok ( send_p == send_last,
1068 "simple_client (%x): sent less data than expected: %d of %d\n", id, n, n_expected );
1069 n = recv_p - mem->recv_buf;
1070 ok ( recv_p == recv_last,
1071 "simple_client (%x): received less data than expected: %d of %d\n", id, n, n_expected );
1072 n = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
1073 ok ( n == -1, "event_client (%x): test pattern error: %d\n", id, n);
1074
1075 out:
1076 WSACloseEvent ( event );
1077 trace ( "event_client (%x) exiting\n", id );
1078 client_stop ();
1079 }
1080
1081 /* Tests for WSAStartup */
1082 static void test_WithoutWSAStartup(void)
1083 {
1084 DWORD err;
1085
1086 WSASetLastError(0xdeadbeef);
1087 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET, "WSASocketA should have failed\n");
1088 err = WSAGetLastError();
1089 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
1090
1091 WSASetLastError(0xdeadbeef);
1092 ok(gethostbyname("localhost") == NULL, "gethostbyname() succeeded unexpectedly\n");
1093 err = WSAGetLastError();
1094 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
1095 }
1096
1097 static void test_WithWSAStartup(void)
1098 {
1099 WSADATA data;
1100 WORD version = MAKEWORD( 2, 2 );
1101 INT res;
1102 LPVOID ptr;
1103 SOCKET src, dst;
1104 DWORD error;
1105
1106 res = WSAStartup( version, &data );
1107 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1108
1109 ptr = gethostbyname("localhost");
1110 ok(ptr != NULL, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1111
1112 ok(!tcp_socketpair(&src, &dst), "creating socket pair failed\n");
1113
1114 res = send(src, "TEST", 4, 0);
1115 ok(res == 4, "send failed with error %d\n", WSAGetLastError());
1116
1117 WSACleanup();
1118
1119 res = WSAStartup( version, &data );
1120 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
1121
1122 /* show that sockets are destroyed automatically after WSACleanup */
1123 todo_wine {
1124 SetLastError(0xdeadbeef);
1125 res = send(src, "TEST", 4, 0);
1126 error = WSAGetLastError();
1127 ok(res == SOCKET_ERROR, "send should have failed\n");
1128 ok(error == WSAENOTSOCK, "expected 10038, got %d\n", error);
1129
1130 SetLastError(0xdeadbeef);
1131 res = closesocket(dst);
1132 error = WSAGetLastError();
1133 ok(res == SOCKET_ERROR, "closesocket should have failed\n");
1134 ok(error == WSAENOTSOCK, "expected 10038, got %d\n", error);
1135 }
1136
1137 closesocket(src);
1138 closesocket(dst);
1139
1140 res = WSACleanup();
1141 ok(res == 0, "expected 0, got %d\n", res);
1142 WSASetLastError(0xdeadbeef);
1143 res = WSACleanup();
1144 error = WSAGetLastError();
1145 ok ( (res == SOCKET_ERROR && error == WSANOTINITIALISED) ||
1146 broken(res == 0), /* WinME */
1147 "WSACleanup returned %d WSAGetLastError is %d\n", res, error);
1148 }
1149
1150 /**************** Main program utility functions ***************/
1151
1152 static void Init (void)
1153 {
1154 WORD ver = MAKEWORD (2, 2);
1155 WSADATA data;
1156 HMODULE hws2_32 = GetModuleHandleA("ws2_32.dll");
1157
1158 pfreeaddrinfo = (void *)GetProcAddress(hws2_32, "freeaddrinfo");
1159 pgetaddrinfo = (void *)GetProcAddress(hws2_32, "getaddrinfo");
1160 pFreeAddrInfoW = (void *)GetProcAddress(hws2_32, "FreeAddrInfoW");
1161 pGetAddrInfoW = (void *)GetProcAddress(hws2_32, "GetAddrInfoW");
1162 pInetNtop = (void *)GetProcAddress(hws2_32, "inet_ntop");
1163 pInetPtonA = (void *)GetProcAddress(hws2_32, "inet_pton");
1164 pInetPtonW = (void *)GetProcAddress(hws2_32, "InetPtonW");
1165 pWSALookupServiceBeginW = (void *)GetProcAddress(hws2_32, "WSALookupServiceBeginW");
1166 pWSALookupServiceEnd = (void *)GetProcAddress(hws2_32, "WSALookupServiceEnd");
1167 pWSALookupServiceNextW = (void *)GetProcAddress(hws2_32, "WSALookupServiceNextW");
1168
1169 ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
1170 tls = TlsAlloc();
1171 }
1172
1173 static void Exit (void)
1174 {
1175 INT ret, err;
1176 TlsFree ( tls );
1177 ret = WSACleanup();
1178 err = WSAGetLastError();
1179 ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
1180 }
1181
1182 static void StartServer (LPTHREAD_START_ROUTINE routine,
1183 test_params *general, server_params *par)
1184 {
1185 par->general = general;
1186 thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
1187 ok ( thread[0] != NULL, "Failed to create server thread\n" );
1188 }
1189
1190 static void StartClients (LPTHREAD_START_ROUTINE routine,
1191 test_params *general, client_params *par)
1192 {
1193 int i;
1194 par->general = general;
1195 for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
1196 {
1197 client_id = i - 1;
1198 thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
1199 ok ( thread[i] != NULL, "Failed to create client thread\n" );
1200 /* Make sure the client is up and running */
1201 WaitForSingleObject ( client_ready[client_id], INFINITE );
1202 };
1203 }
1204
1205 static void do_test( test_setup *test )
1206 {
1207 DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
1208 DWORD wait;
1209
1210 server_ready = CreateEventA ( NULL, TRUE, FALSE, NULL );
1211 for (i = 0; i <= n; i++)
1212 client_ready[i] = CreateEventA ( NULL, TRUE, FALSE, NULL );
1213
1214 StartServer ( test->srv, &test->general, &test->srv_params );
1215 StartClients ( test->clt, &test->general, &test->clt_params );
1216 WaitForSingleObject ( server_ready, INFINITE );
1217
1218 wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
1219 ok ( wait <= WAIT_OBJECT_0 + n ,
1220 "some threads have not completed: %x\n", wait );
1221
1222 if ( ! ( wait <= WAIT_OBJECT_0 + n ) )
1223 {
1224 for (i = 0; i <= n; i++)
1225 {
1226 if ( WaitForSingleObject ( thread[i], 0 ) != WAIT_OBJECT_0 )
1227 {
1228 trace ("terminating thread %08x\n", thread_id[i]);
1229 TerminateThread ( thread [i], 0 );
1230 }
1231 }
1232 }
1233 CloseHandle ( server_ready );
1234 for (i = 0; i <= n; i++)
1235 CloseHandle ( client_ready[i] );
1236 }
1237
1238 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1239 /* optname = SO_LINGER */
1240 static const LINGER linger_testvals[] = {
1241 {0,0},
1242 {0,73},
1243 {1,0},
1244 {5,189}
1245 };
1246
1247 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1248 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1249 bug in the linux kernel (fixed in 2.6.8) */
1250 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1251
1252 static void test_set_getsockopt(void)
1253 {
1254 SOCKET s, s2;
1255 int i, err, lasterr;
1256 int timeout;
1257 LINGER lingval;
1258 int size;
1259 WSAPROTOCOL_INFOA infoA;
1260 WSAPROTOCOL_INFOW infoW;
1261 char providername[WSAPROTOCOL_LEN + 1];
1262 struct _prottest
1263 {
1264 int family, type, proto;
1265 } prottest[] = {
1266 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
1267 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
1268 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
1269 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP}
1270 };
1271 union _csspace
1272 {
1273 CSADDR_INFO cs;
1274 char space[128];
1275 } csinfoA, csinfoB;
1276
1277 s = socket(AF_INET, SOCK_STREAM, 0);
1278 ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1279 if( s == INVALID_SOCKET) return;
1280 /* SO_RCVTIMEO */
1281 timeout = SOCKTIMEOUT1;
1282 size = sizeof(timeout);
1283 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1284 if( !err)
1285 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1286 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1287 ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1288
1289 timeout = 0;
1290 size = sizeof(timeout);
1291 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1292 if( !err)
1293 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1294 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1295 ok( timeout == 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1296
1297 /* SO_SNDTIMEO */
1298 timeout = SOCKTIMEOUT2; /* 997 seconds. See remark above */
1299 size = sizeof(timeout);
1300 err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
1301 if( !err)
1302 err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
1303 ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1304 ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
1305 /* SO_LINGER */
1306 for( i = 0; i < sizeof(linger_testvals)/sizeof(LINGER);i++) {
1307 size = sizeof(lingval);
1308 lingval = linger_testvals[i];
1309 err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, size);
1310 if( !err)
1311 err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, &size);
1312 ok( !err, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1313 ok( !lingval.l_onoff == !linger_testvals[i].l_onoff &&
1314 (lingval.l_linger == linger_testvals[i].l_linger ||
1315 (!lingval.l_linger && !linger_testvals[i].l_onoff))
1316 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i,
1317 lingval.l_onoff, lingval.l_linger,
1318 linger_testvals[i].l_onoff, linger_testvals[i].l_linger);
1319 }
1320
1321 size = sizeof(lingval);
1322 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, size);
1323 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1324 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1325 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, 0);
1326 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1327 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1328
1329 size = sizeof(BOOL);
1330 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, size);
1331 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1332 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1333 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, 0);
1334 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1335 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1336
1337 /* Test for erroneously passing a value instead of a pointer as optval */
1338 size = sizeof(char);
1339 err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
1340 ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
1341 "instead of failing.\n");
1342 lasterr = WSAGetLastError();
1343 ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
1344 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1345 lasterr, WSAEFAULT);
1346
1347 /* SO_RCVTIMEO with invalid values for level */
1348 size = sizeof(timeout);
1349 timeout = SOCKTIMEOUT1;
1350 SetLastError(0xdeadbeef);
1351 err = setsockopt(s, 0xffffffff, SO_RCVTIMEO, (char *) &timeout, size);
1352 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1353 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1354 err, WSAGetLastError());
1355
1356 timeout = SOCKTIMEOUT1;
1357 SetLastError(0xdeadbeef);
1358 err = setsockopt(s, 0x00008000, SO_RCVTIMEO, (char *) &timeout, size);
1359 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1360 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1361 err, WSAGetLastError());
1362
1363 /* Test SO_ERROR set/get */
1364 SetLastError(0xdeadbeef);
1365 i = 1234;
1366 err = setsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, size);
1367 todo_wine
1368 ok( !err && !WSAGetLastError(),
1369 "got %d with %d (expected 0 with 0)\n",
1370 err, WSAGetLastError());
1371
1372 SetLastError(0xdeadbeef);
1373 i = 4321;
1374 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1375 todo_wine
1376 ok( !err && !WSAGetLastError(),
1377 "got %d with %d (expected 0 with 0)\n",
1378 err, WSAGetLastError());
1379 todo_wine
1380 ok (i == 1234, "got %d (expected 1234)\n", i);
1381
1382 /* Test invalid optlen */
1383 SetLastError(0xdeadbeef);
1384 size = 1;
1385 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1386 todo_wine
1387 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEFAULT),
1388 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1389 err, WSAGetLastError());
1390
1391 closesocket(s);
1392 /* Test with the closed socket */
1393 SetLastError(0xdeadbeef);
1394 size = sizeof(i);
1395 i = 1234;
1396 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1397 todo_wine
1398 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAENOTSOCK),
1399 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1400 err, WSAGetLastError());
1401 ok (i == 1234, "expected 1234, got %d\n", i);
1402
1403 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1404 s = socket(AF_INET, SOCK_DGRAM, 0);
1405 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1406 size = sizeof(i);
1407 i = 0x0000000a;
1408 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &i, size);
1409 if (!err)
1410 {
1411 for (i = 0; i < 4; i++)
1412 {
1413 int k, j;
1414 const int tests[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1415 err = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &tests[i], i + 1);
1416 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1417 err = getsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *) &k, &size);
1418 ok(!err, "Test [%d] Expected 0, got %d\n", i, err);
1419 j = i != 3 ? tests[i] & ((1 << (i + 1) * 8) - 1) : tests[i];
1420 ok(k == j, "Test [%d] Expected 0x%x, got 0x%x\n", i, j, k);
1421 }
1422 }
1423 else
1424 win_skip("IP_MULTICAST_TTL is unsupported\n");
1425 closesocket(s);
1426
1427 /* test SO_PROTOCOL_INFOA invalid parameters */
1428 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1429 "getsockopt should have failed\n");
1430 err = WSAGetLastError();
1431 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1432 size = sizeof(WSAPROTOCOL_INFOA);
1433 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1434 "getsockopt should have failed\n");
1435 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1436 err = WSAGetLastError();
1437 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1438 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1439 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1440 "getsockopt should have failed\n");
1441 err = WSAGetLastError();
1442 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1443 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, NULL),
1444 "getsockopt should have failed\n");
1445 err = WSAGetLastError();
1446 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1447 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, &size),
1448 "getsockopt should have failed\n");
1449 err = WSAGetLastError();
1450 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1451 size = sizeof(WSAPROTOCOL_INFOA) / 2;
1452 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1453 "getsockopt should have failed\n");
1454 err = WSAGetLastError();
1455 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1456 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1457 size = sizeof(WSAPROTOCOL_INFOA) * 2;
1458 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1459 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1460 ok(size == sizeof(WSAPROTOCOL_INFOA) * 2, "got size %d\n", size);
1461
1462 closesocket(s);
1463
1464 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1465 for (i = 0; i < sizeof(prottest) / sizeof(prottest[0]); i++)
1466 {
1467 s = socket(prottest[i].family, prottest[i].type, prottest[i].proto);
1468 if (s == INVALID_SOCKET && prottest[i].family == AF_INET6) continue;
1469
1470 ok(s != INVALID_SOCKET, "Failed to create socket: %d\n",
1471 WSAGetLastError());
1472
1473 /* compare both A and W version */
1474 infoA.szProtocol[0] = 0;
1475 size = sizeof(WSAPROTOCOL_INFOA);
1476 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1477 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1478 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1479
1480 infoW.szProtocol[0] = 0;
1481 size = sizeof(WSAPROTOCOL_INFOW);
1482 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &infoW, &size);
1483 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1484 ok(size == sizeof(WSAPROTOCOL_INFOW), "got size %d\n", size);
1485
1486 trace("provider name '%s', family %d, type %d, proto %d\n",
1487 infoA.szProtocol, prottest[i].family, prottest[i].type, prottest[i].proto);
1488
1489 ok(infoA.szProtocol[0] || broken(!infoA.szProtocol[0]) /* NT4 */,
1490 "WSAPROTOCOL_INFOA was not filled\n");
1491 ok(infoW.szProtocol[0] || broken(!infoA.szProtocol[0]) /* NT4 */,
1492 "WSAPROTOCOL_INFOW was not filled\n");
1493
1494 WideCharToMultiByte(CP_ACP, 0, infoW.szProtocol, -1,
1495 providername, sizeof(providername), NULL, NULL);
1496 ok(!strcmp(infoA.szProtocol,providername),
1497 "different provider names '%s' != '%s'\n", infoA.szProtocol, providername);
1498
1499 ok(!memcmp(&infoA, &infoW, FIELD_OFFSET(WSAPROTOCOL_INFOA, szProtocol)),
1500 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1501
1502 /* Remove IF when WSAEnumProtocols support IPV6 data */
1503 if (prottest[i].family == AF_INET6)
1504 {
1505 todo_wine
1506 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1507 prottest[i].family, infoA.iAddressFamily);
1508 }
1509 else
1510 {
1511 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1512 prottest[i].family, infoA.iAddressFamily);
1513 } ok(infoA.iSocketType == prottest[i].type, "socket type invalid, expected %d received %d\n",
1514 prottest[i].type, infoA.iSocketType);
1515 ok(infoA.iProtocol == prottest[i].proto, "socket protocol invalid, expected %d received %d\n",
1516 prottest[i].proto, infoA.iProtocol);
1517
1518 closesocket(s);
1519 }
1520
1521 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1522 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1523 ok(s != INVALID_SOCKET, "Failed to create socket\n");
1524 s2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1525 ok(s2 != INVALID_SOCKET, "Failed to create socket\n");
1526
1527 SetLastError(0xdeadbeef);
1528 size = sizeof(csinfoA);
1529 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1530 if (!err)
1531 {
1532 struct sockaddr_in saddr;
1533 memset(&saddr, 0, sizeof(saddr));
1534 saddr.sin_family = AF_INET;
1535 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1536
1537 /* Socket is not bound, no information provided */
1538 ok(!csinfoA.cs.LocalAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1539 ok(csinfoA.cs.LocalAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1540 /* Socket is not connected, no information provided */
1541 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1542 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1543
1544 err = bind(s, (struct sockaddr*)&saddr, sizeof(saddr));
1545 ok(!err, "Expected 0, got %d\n", err);
1546 size = sizeof(csinfoA);
1547 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1548 ok(!err, "Expected 0, got %d\n", err);
1549
1550 /* Socket is bound */
1551 ok(csinfoA.cs.LocalAddr.iSockaddrLength, "Expected non-zero\n");
1552 ok(csinfoA.cs.LocalAddr.lpSockaddr != NULL, "Expected non-null\n");
1553 /* Socket is not connected, no information provided */
1554 ok(!csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected 0, got %d\n", csinfoA.cs.LocalAddr.iSockaddrLength);
1555 ok(csinfoA.cs.RemoteAddr.lpSockaddr == NULL, "Expected NULL, got %p\n", csinfoA.cs.LocalAddr.lpSockaddr);
1556
1557 err = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1558 ok(!err, "Expected 0, got %d\n", err);
1559 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1560 ok(!err, "Expected 0, got %d\n", err);
1561 err = listen(s2, 1);
1562 ok(!err, "Expected 0, got %d\n", err);
1563 err = connect(s, (struct sockaddr*)&saddr, sizeof(saddr));
1564 ok(!err, "Expected 0, got %d\n", err);
1565 size = sizeof(saddr);
1566 err = accept(s2, (struct sockaddr*)&saddr, &size);
1567 ok(err != INVALID_SOCKET, "Failed to accept socket\n");
1568 closesocket(s2);
1569 s2 = err;
1570
1571 size = sizeof(csinfoA);
1572 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1573 ok(!err, "Expected 0, got %d\n", err);
1574 err = getsockopt(s2, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoB, &size);
1575 ok(!err, "Expected 0, got %d\n", err);
1576 ok(size == sizeof(csinfoA), "Got %d\n", size);
1577 size = sizeof(saddr);
1578 ok(size == csinfoA.cs.LocalAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1579 csinfoA.cs.LocalAddr.iSockaddrLength);
1580 ok(size == csinfoA.cs.RemoteAddr.iSockaddrLength, "Expected %d, got %d\n", size,
1581 csinfoA.cs.RemoteAddr.iSockaddrLength);
1582 ok(!memcmp(csinfoA.cs.LocalAddr.lpSockaddr, csinfoB.cs.RemoteAddr.lpSockaddr, size),
1583 "Expected matching addresses\n");
1584 ok(!memcmp(csinfoB.cs.LocalAddr.lpSockaddr, csinfoA.cs.RemoteAddr.lpSockaddr, size),
1585 "Expected matching addresses\n");
1586 ok(csinfoA.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1587 ok(csinfoB.cs.iSocketType == SOCK_STREAM, "Wrong socket type\n");
1588 ok(csinfoA.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1589 ok(csinfoB.cs.iProtocol == IPPROTO_TCP, "Wrong socket protocol\n");
1590
1591 err = getpeername(s, (struct sockaddr *)&saddr, &size);
1592 ok(!err, "Expected 0, got %d\n", err);
1593 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1594 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1595 err = getpeername(s2, (struct sockaddr *)&saddr, &size);
1596 ok(!err, "Expected 0, got %d\n", err);
1597 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1598 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1599 err = getsockname(s, (struct sockaddr *)&saddr, &size);
1600 ok(!err, "Expected 0, got %d\n", err);
1601 ok(!memcmp(&saddr, csinfoA.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1602 ok(!memcmp(&saddr, csinfoB.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1603 err = getsockname(s2, (struct sockaddr *)&saddr, &size);
1604 ok(!err, "Expected 0, got %d\n", err);
1605 ok(!memcmp(&saddr, csinfoB.cs.LocalAddr.lpSockaddr, size), "Expected matching addresses\n");
1606 ok(!memcmp(&saddr, csinfoA.cs.RemoteAddr.lpSockaddr, size), "Expected matching addresses\n");
1607
1608 SetLastError(0xdeadbeef);
1609 size = sizeof(CSADDR_INFO);
1610 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1611 ok(err, "Expected non-zero\n");
1612 ok(size == sizeof(CSADDR_INFO), "Got %d\n", size);
1613 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %d\n", GetLastError());
1614
1615 /* At least for IPv4 the size is exactly 56 bytes */
1616 size = sizeof(*csinfoA.cs.LocalAddr.lpSockaddr) * 2 + sizeof(csinfoA.cs);
1617 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1618 ok(!err, "Expected 0, got %d\n", err);
1619 size--;
1620 SetLastError(0xdeadbeef);
1621 err = getsockopt(s, SOL_SOCKET, SO_BSP_STATE, (char *) &csinfoA, &size);
1622 ok(err, "Expected non-zero\n");
1623 ok(GetLastError() == WSAEFAULT, "Expected 10014, got %d\n", GetLastError());
1624 }
1625 else
1626 ok(GetLastError() == WSAENOPROTOOPT, "Expected 10042, got %d\n", GetLastError());
1627
1628 closesocket(s);
1629 closesocket(s2);
1630 }
1631
1632 static void test_so_reuseaddr(void)
1633 {
1634 struct sockaddr_in saddr;
1635 SOCKET s1,s2;
1636 unsigned int rc,reuse;
1637 int size;
1638 DWORD err;
1639
1640 saddr.sin_family = AF_INET;
1641 saddr.sin_port = htons(9375);
1642 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1643
1644 s1=socket(AF_INET, SOCK_STREAM, 0);
1645 ok(s1!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1646 rc = bind(s1, (struct sockaddr*)&saddr, sizeof(saddr));
1647 ok(rc!=SOCKET_ERROR, "bind(s1) failed error: %d\n", WSAGetLastError());
1648
1649 s2=socket(AF_INET, SOCK_STREAM, 0);
1650 ok(s2!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1651
1652 reuse=0x1234;
1653 size=sizeof(reuse);
1654 rc=getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size );
1655 ok(rc==0 && reuse==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc,reuse);
1656
1657 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1658 ok(rc==SOCKET_ERROR, "bind() succeeded\n");
1659
1660 reuse = 1;
1661 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
1662 ok(rc==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1663
1664 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1665 * a port immediately after closing another socket on that port, so
1666 * basically following the BSD socket semantics here. */
1667 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1668 if(rc==0)
1669 {
1670 int s3=socket(AF_INET, SOCK_STREAM, 0), s4;
1671 trace("<= Win XP behavior of SO_REUSEADDR\n");
1672
1673 /* If we could bind again in the same port this is Windows version <= XP.
1674 * Lets test if we can really connect to one of them. */
1675 set_blocking(s1, FALSE);
1676 set_blocking(s2, FALSE);
1677 rc = listen(s1, 1);
1678 ok(!rc, "listen() failed with error: %d\n", WSAGetLastError());
1679 rc = listen(s2, 1);
1680 ok(!rc, "listen() failed with error: %d\n", WSAGetLastError());
1681 rc = connect(s3, (struct sockaddr*)&saddr, sizeof(saddr));
1682 ok(!rc, "connecting to accepting socket failed %d\n", WSAGetLastError());
1683
1684 /* the delivery of the connection is random so we need to try on both sockets */
1685 size = sizeof(saddr);
1686 s4 = accept(s1, (struct sockaddr*)&saddr, &size);
1687 if(s4 == INVALID_SOCKET)
1688 s4 = accept(s2, (struct sockaddr*)&saddr, &size);
1689 ok(s4 != INVALID_SOCKET, "none of the listening sockets could get the connection\n");
1690
1691 closesocket(s1);
1692 closesocket(s3);
1693 closesocket(s4);
1694 }
1695 else
1696 {
1697 trace(">= Win 2003 behavior of SO_REUSEADDR\n");
1698 err = WSAGetLastError();
1699 ok(err==WSAEACCES, "expected 10013, got %d\n", err);
1700
1701 closesocket(s1);
1702 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1703 ok(rc==0, "bind() failed error: %d\n", WSAGetLastError());
1704 }
1705
1706 closesocket(s2);
1707 }
1708
1709 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1710
1711 static void test_ip_pktinfo(void)
1712 {
1713 ULONG addresses[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY)};
1714 char recvbuf[10], pktbuf[512], msg[] = "HELLO";
1715 struct sockaddr_in s1addr, s2addr, s3addr;
1716 GUID WSARecvMsg_GUID = WSAID_WSARECVMSG;
1717 LPFN_WSARECVMSG pWSARecvMsg = NULL;
1718 unsigned int rc, yes = 1;
1719 BOOL foundhdr;
1720 DWORD dwBytes, dwSize, dwFlags;
1721 socklen_t addrlen;
1722 WSACMSGHDR *cmsg;
1723 WSAOVERLAPPED ov;
1724 WSABUF iovec[1];
1725 SOCKET s1, s2;
1726 WSAMSG hdr;
1727 int i, err;
1728
1729 memset(&ov, 0, sizeof(ov));
1730 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1731 if (ov.hEvent == INVALID_HANDLE_VALUE)
1732 {
1733 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
1734 return;
1735 }
1736
1737 memset(&hdr, 0x00, sizeof(hdr));
1738 s1addr.sin_family = AF_INET;
1739 s1addr.sin_port = htons(0);
1740 /* Note: s1addr.sin_addr is set below */
1741 iovec[0].buf = recvbuf;
1742 iovec[0].len = sizeof(recvbuf);
1743 hdr.name = (struct sockaddr*)&s3addr;
1744 hdr.namelen = sizeof(s3addr);
1745 hdr.lpBuffers = &iovec[0];
1746 hdr.dwBufferCount = 1;
1747 hdr.Control.buf = pktbuf;
1748 /* Note: hdr.Control.len is set below */
1749 hdr.dwFlags = 0;
1750
1751 for (i=0;i<sizeof(addresses)/sizeof(UINT32);i++)
1752 {
1753 s1addr.sin_addr.s_addr = addresses[i];
1754
1755 /* Build "server" side socket */
1756 s1=socket(AF_INET, SOCK_DGRAM, 0);
1757 if (s1 == INVALID_SOCKET)
1758 {
1759 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1760 goto cleanup;
1761 }
1762
1763 /* Obtain the WSARecvMsg function */
1764 WSAIoctl(s1, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
1765 &pWSARecvMsg, sizeof(pWSARecvMsg), &dwBytes, NULL, NULL);
1766 if (!pWSARecvMsg)
1767 {
1768 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
1769 closesocket(s1);
1770 goto cleanup;
1771 }
1772
1773 /* Setup the server side socket */
1774 rc=bind(s1, (struct sockaddr*)&s1addr, sizeof(s1addr));
1775 ok(rc != SOCKET_ERROR, "bind() failed error: %d\n", WSAGetLastError());
1776 rc=setsockopt(s1, IPPROTO_IP, IP_PKTINFO, (const char*)&yes, sizeof(yes));
1777 ok(rc == 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1778
1779 /* Build "client" side socket */
1780 addrlen = sizeof(s2addr);
1781 if (getsockname(s1, (struct sockaddr *) &s2addr, &addrlen) != 0)
1782 {
1783 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
1784 closesocket(s1);
1785 goto cleanup;
1786 }
1787 s2addr.sin_addr.s_addr = addresses[0]; /* Always target the local adapter address */
1788 s2=socket(AF_INET, SOCK_DGRAM, 0);
1789 if (s2 == INVALID_SOCKET)
1790 {
1791 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1792 closesocket(s1);
1793 goto cleanup;
1794 }
1795
1796 /* Test an empty message header */
1797 rc=pWSARecvMsg(s1, NULL, NULL, NULL, NULL);
1798 err=WSAGetLastError();
1799 ok(rc == SOCKET_ERROR && err == WSAEFAULT, "WSARecvMsg() failed error: %d (ret = %d)\n", err, rc);
1800
1801 /*
1802 * Send a packet from the client to the server and test for specifying
1803 * a short control header.
1804 */
1805 SetLastError(0xdeadbeef);
1806 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1807 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1808 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
1809 hdr.Control.len = 1;
1810 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
1811 err=WSAGetLastError();
1812 ok(rc == SOCKET_ERROR && err == WSAEMSGSIZE && (hdr.dwFlags & MSG_CTRUNC),
1813 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err, rc, hdr.dwFlags);
1814 hdr.dwFlags = 0; /* Reset flags */
1815
1816 /* Perform another short control header test, this time with an overlapped receive */
1817 hdr.Control.len = 1;
1818 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
1819 err=WSAGetLastError();
1820 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
1821 SetLastError(0xdeadbeef);
1822 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1823 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1824 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
1825 if (WaitForSingleObject(ov.hEvent, 100) != WAIT_OBJECT_0)
1826 {
1827 skip("Server side did not receive packet, some tests skipped.\n");
1828 closesocket(s2);
1829 closesocket(s1);
1830 continue;
1831 }
1832 dwFlags = 0;
1833 WSAGetOverlappedResult(s1, &ov, NULL, FALSE, &dwFlags);
1834 ok(dwFlags == 0,
1835 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags);
1836 ok(hdr.dwFlags == MSG_CTRUNC,
1837 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr.dwFlags);
1838 hdr.dwFlags = 0; /* Reset flags */
1839
1840 /*
1841 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1842 * on the server end and check that the returned packet matches what was sent.
1843 */
1844 hdr.Control.len = sizeof(pktbuf);
1845 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
1846 err=WSAGetLastError();
1847 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
1848 ok(hdr.Control.len == sizeof(pktbuf),
1849 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr.Control.len);
1850 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1851 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1852 if (WaitForSingleObject(ov.hEvent, 100) != WAIT_OBJECT_0)
1853 {
1854 skip("Server side did not receive packet, some tests skipped.\n");
1855 closesocket(s2);
1856 closesocket(s1);
1857 continue;
1858 }
1859 dwSize = 0;
1860 WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, NULL);
1861 ok(dwSize == sizeof(msg),
1862 "WSARecvMsg() buffer length does not match transmitted data!\n");
1863 ok(strncmp(iovec[0].buf, msg, sizeof(msg)) == 0,
1864 "WSARecvMsg() buffer does not match transmitted data!\n");
1865 ok(hdr.Control.len == IP_PKTINFO_LEN,
1866 "WSARecvMsg() control length mismatch (%d).\n", hdr.Control.len);
1867
1868 /* Test for the expected IP_PKTINFO return information. */
1869 foundhdr = FALSE;
1870 for (cmsg = WSA_CMSG_FIRSTHDR(&hdr); cmsg != NULL; cmsg = WSA_CMSG_NXTHDR(&hdr, cmsg))
1871 {
1872 if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
1873 {
1874 struct in_pktinfo *pi = (struct in_pktinfo *)WSA_CMSG_DATA(cmsg);
1875
1876 ok(pi->ipi_addr.s_addr == s2addr.sin_addr.s_addr, "destination ip mismatch!\n");
1877 foundhdr = TRUE;
1878 }
1879 }
1880 ok(foundhdr, "IP_PKTINFO header information was not returned!\n");
1881
1882 closesocket(s2);
1883 closesocket(s1);
1884 }
1885
1886 cleanup:
1887 CloseHandle(ov.hEvent);
1888 }
1889
1890 /************* Array containing the tests to run **********/
1891
1892 #define STD_STREAM_SOCKET \
1893 SOCK_STREAM, \
1894 0, \
1895 SERVERIP, \
1896 SERVERPORT
1897
1898 static test_setup tests [] =
1899 {
1900 /* Test 0: synchronous client and server */
1901 {
1902 {
1903 STD_STREAM_SOCKET,
1904 2048,
1905 16,
1906 2
1907 },
1908 simple_server,
1909 {
1910 NULL,
1911 0,
1912 64
1913 },
1914 simple_client,
1915 {
1916 NULL,
1917 0,
1918 128
1919 }
1920 },
1921 /* Test 1: event-driven client, synchronous server */
1922 {
1923 {
1924 STD_STREAM_SOCKET,
1925 2048,
1926 16,
1927 2
1928 },
1929 simple_server,
1930 {
1931 NULL,
1932 0,
1933 64
1934 },
1935 event_client,
1936 {
1937 NULL,
1938 WSA_FLAG_OVERLAPPED,
1939 128
1940 }
1941 },
1942 /* Test 2: synchronous client, non-blocking server via select() */
1943 {
1944 {
1945 STD_STREAM_SOCKET,
1946 2048,
1947 16,
1948 2
1949 },
1950 select_server,
1951 {
1952 NULL,
1953 0,
1954 64
1955 },
1956 simple_client,
1957 {
1958 NULL,
1959 0,
1960 128
1961 }
1962 },
1963 /* Test 3: OOB client, OOB server */
1964 {
1965 {
1966 STD_STREAM_SOCKET,
1967 128,
1968 16,
1969 1
1970 },
1971 oob_server,
1972 {
1973 NULL,
1974 0,
1975 128
1976 },
1977 oob_client,
1978 {
1979 NULL,
1980 0,
1981 128
1982 }
1983 },
1984 /* Test 4: synchronous mixed client and server */
1985 {
1986 {
1987 STD_STREAM_SOCKET,
1988 2048,
1989 16,
1990 2
1991 },
1992 simple_server,
1993 {
1994 NULL,
1995 0,
1996 64
1997 },
1998 simple_mixed_client,
1999 {
2000 NULL,
2001 0,
2002 128
2003 }
2004 }
2005 };
2006
2007 static void test_UDP(void)
2008 {
2009 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2010 possible that this test fails due to dropped packets. */
2011
2012 /* peer 0 receives data from all other peers */
2013 struct sock_info peer[NUM_UDP_PEERS];
2014 char buf[16];
2015 int ss, i, n_recv, n_sent;
2016
2017 memset (buf,0,sizeof(buf));
2018 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
2019 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
2020
2021 peer[i].addr.sin_family = AF_INET;
2022 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
2023
2024 if ( i == 0 ) {
2025 peer[i].addr.sin_port = htons ( SERVERPORT );
2026 } else {
2027 peer[i].addr.sin_port = htons ( 0 );
2028 }
2029
2030 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
2031
2032 /* test getsockname() to get peer's port */
2033 ss = sizeof ( peer[i].addr );
2034 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
2035 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
2036 }
2037
2038 /* test getsockname() */
2039 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
2040
2041 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2042 /* send client's ip */
2043 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
2044 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
2045 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
2046 }
2047
2048 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
2049 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
2050 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
2051 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
2052 }
2053 }
2054
2055 static DWORD WINAPI do_getservbyname( void *param )
2056 {
2057 struct {
2058 const char *name;
2059 const char *proto;
2060 int port;
2061 } serv[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
2062
2063 HANDLE *starttest = param;
2064 int i, j;
2065 struct servent *pserv[2];
2066
2067 ok ( WaitForSingleObject ( *starttest, TEST_TIMEOUT * 1000 ) != WAIT_TIMEOUT,
2068 "test_getservbyname: timeout waiting for start signal\n" );
2069
2070 /* ensure that necessary buffer resizes are completed */
2071 for ( j = 0; j < 2; j++) {
2072 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
2073 }
2074
2075 for ( i = 0; i < NUM_QUERIES / 2; i++ ) {
2076 for ( j = 0; j < 2; j++ ) {
2077 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
2078 ok ( pserv[j] != NULL || broken(pserv[j] == NULL) /* win8, fixed in win81 */,
2079 "getservbyname could not retrieve information for %s: %d\n", serv[j].name, WSAGetLastError() );
2080 if ( !pserv[j] ) continue;
2081 ok ( pserv[j]->s_port == htons(serv[j].port),
2082 "getservbyname returned the wrong port for %s: %d\n", serv[j].name, ntohs(pserv[j]->s_port) );
2083 ok ( !strcmp ( pserv[j]->s_proto, serv[j].proto ),
2084 "getservbyname returned the wrong protocol for %s: %s\n", serv[j].name, pserv[j]->s_proto );
2085 ok ( !strcmp ( pserv[j]->s_name, serv[j].name ),
2086 "getservbyname returned the wrong name for %s: %s\n", serv[j].name, pserv[j]->s_name );
2087 }
2088
2089 ok ( pserv[0] == pserv[1] || broken(pserv[0] != pserv[1]) /* win8, fixed in win81 */,
2090 "getservbyname: winsock resized servent buffer when not necessary\n" );
2091 }
2092
2093 return 0;
2094 }
2095
2096 static void test_getservbyname(void)
2097 {
2098 int i;
2099 HANDLE starttest, thread[NUM_THREADS];
2100 DWORD thread_id[NUM_THREADS];
2101
2102 starttest = CreateEventA ( NULL, 1, 0, "test_getservbyname_starttest" );
2103
2104 /* create threads */
2105 for ( i = 0; i < NUM_THREADS; i++ ) {
2106 thread[i] = CreateThread ( NULL, 0, do_getservbyname, &starttest, 0, &thread_id[i] );
2107 }
2108
2109 /* signal threads to start */
2110 SetEvent ( starttest );
2111
2112 for ( i = 0; i < NUM_THREADS; i++) {
2113 WaitForSingleObject ( thread[i], TEST_TIMEOUT * 1000 );
2114 }
2115 }
2116
2117 static void test_WSASocket(void)
2118 {
2119 SOCKET sock = INVALID_SOCKET;
2120 WSAPROTOCOL_INFOA *pi;
2121 int wsaproviders[] = {IPPROTO_TCP, IPPROTO_IP};
2122 int autoprotocols[] = {IPPROTO_TCP, IPPROTO_UDP};
2123 int items, err, size, socktype, i, j;
2124 UINT pi_size;
2125
2126 SetLastError(0xdeadbeef);
2127 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET,
2128 "WSASocketA should have failed\n");
2129 err = WSAGetLastError();
2130 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2131
2132 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
2133 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2134 closesocket(sock);
2135
2136 sock = WSASocketA(AF_INET, SOCK_STREAM, 0, NULL, 0, 0);
2137 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2138 closesocket(sock);
2139
2140 SetLastError(0xdeadbeef);
2141 ok(WSASocketA(0, SOCK_STREAM, -1, NULL, 0, 0) == INVALID_SOCKET,
2142 "WSASocketA should have failed\n");
2143 err = WSAGetLastError();
2144 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2145
2146 SetLastError(0xdeadbeef);
2147 ok(WSASocketA(0, -1, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2148 "WSASocketA should have failed\n");
2149 err = WSAGetLastError();
2150 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2151
2152 SetLastError(0xdeadbeef);
2153 ok(WSASocketA(0, -1, 0, NULL, 0, 0) == INVALID_SOCKET,
2154 "WSASocketA should have failed\n");
2155 err = WSAGetLastError();
2156 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2157
2158 SetLastError(0xdeadbeef);
2159 ok(WSASocketA(AF_INET, -1, 0, NULL, 0, 0) == INVALID_SOCKET,
2160 "WSASocketA should have failed\n");
2161 err = WSAGetLastError();
2162 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2163
2164 SetLastError(0xdeadbeef);
2165 ok(WSASocketA(AF_INET, 0, -1, NULL, 0, 0) == INVALID_SOCKET,
2166 "WSASocketA should have failed\n");
2167 err = WSAGetLastError();
2168 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2169
2170 SetLastError(0xdeadbeef);
2171 ok(WSASocketA(0, -1, -1, NULL, 0, 0) == INVALID_SOCKET,
2172 "WSASocketA should have failed\n");
2173 err = WSAGetLastError();
2174 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2175
2176 SetLastError(0xdeadbeef);
2177 ok(WSASocketA(-1, SOCK_STREAM, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2178 "WSASocketA should have failed\n");
2179 err = WSAGetLastError();
2180 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2181
2182 sock = WSASocketA(AF_INET, 0, IPPROTO_TCP, NULL, 0, 0);
2183 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2184 closesocket(sock);
2185
2186 SetLastError(0xdeadbeef);
2187 ok(WSASocketA(0, SOCK_STREAM, 0, NULL, 0, 0) == INVALID_SOCKET,
2188 "WSASocketA should have failed\n");
2189 err = WSAGetLastError();
2190 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2191
2192 SetLastError(0xdeadbeef);
2193 ok(WSASocketA(0, 0, 0xdead, NULL, 0, 0) == INVALID_SOCKET,
2194 "WSASocketA should have failed\n");
2195 err = WSAGetLastError();
2196 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2197
2198 SetLastError(0xdeadbeef);
2199 ok(WSASocketA(AF_INET, 0xdead, 0, NULL, 0, 0) == INVALID_SOCKET,
2200 "WSASocketA should have failed\n");
2201 err = WSAGetLastError();
2202 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
2203
2204 SetLastError(0xdeadbeef);
2205 ok(WSASocketA(0, 0xdead, 0, NULL, 0, 0) == INVALID_SOCKET,
2206 "WSASocketA should have failed\n");
2207 err = WSAGetLastError();
2208 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
2209
2210 sock = WSASocketA(0, 0, IPPROTO_TCP, NULL, 0, 0);
2211 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2212 closesocket(sock);
2213
2214 /* SOCK_STREAM does not support IPPROTO_UDP */
2215 SetLastError(0xdeadbeef);
2216 ok(WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
2217 "WSASocketA should have failed\n");
2218 err = WSAGetLastError();
2219 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2220
2221 /* SOCK_DGRAM does not support IPPROTO_TCP */
2222 SetLastError(0xdeadbeef);
2223 ok(WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_TCP, NULL, 0, 0) == INVALID_SOCKET,
2224 "WSASocketA should have failed\n");
2225 err = WSAGetLastError();
2226 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2227
2228 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2229 * to avoid a crash on win98.
2230 */
2231 pi_size = 0;
2232 items = WSAEnumProtocolsA(wsaproviders, NULL, &pi_size);
2233 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2234 items);
2235 err = WSAGetLastError();
2236 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2237 err, WSAENOBUFS);
2238
2239 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
2240 ok(pi != NULL, "Failed to allocate memory\n");
2241 if (pi == NULL) {
2242 skip("Can't continue without memory.\n");
2243 return;
2244 }
2245
2246 items = WSAEnumProtocolsA(wsaproviders, pi, &pi_size);
2247 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
2248 WSAGetLastError());
2249
2250 if (items == 0) {
2251 skip("No protocols enumerated.\n");
2252 HeapFree(GetProcessHeap(), 0, pi);
2253 return;
2254 }
2255
2256 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
2257 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
2258 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2259 WSAGetLastError());
2260 closesocket(sock);
2261
2262 /* find what parameters are used first: plain parameters or protocol info struct */
2263 pi[0].iProtocol = -1;
2264 pi[0].iSocketType = -1;
2265 pi[0].iAddressFamily = -1;
2266 ok(WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0) == INVALID_SOCKET,
2267 "WSASocketA should have failed\n");
2268 err = WSAGetLastError();
2269 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2270
2271 pi[0].iProtocol = 0;
2272 pi[0].iSocketType = 0;
2273 pi[0].iAddressFamily = 0;
2274 sock = WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0);
2275 if(sock != INVALID_SOCKET)
2276 {
2277 win_skip("must work only in OS <= 2003\n");
2278 closesocket(sock);
2279 }
2280 else
2281 {
2282 err = WSAGetLastError();
2283 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
2284 }
2285
2286 pi[0].iProtocol = IPPROTO_UDP;
2287 pi[0].iSocketType = SOCK_DGRAM;
2288 pi[0].iAddressFamily = AF_INET;
2289 sock = WSASocketA(0, 0, 0, &pi[0], 0, 0);
2290 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2291 WSAGetLastError());
2292 size = sizeof(socktype);
2293 socktype = 0xdead;
2294 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2295 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2296 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2297 SOCK_DGRAM, socktype);
2298 closesocket(sock);
2299
2300 sock = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, &pi[0], 0, 0);
2301 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2302 WSAGetLastError());
2303 size = sizeof(socktype);
2304 socktype = 0xdead;
2305 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2306 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2307 ok(socktype == SOCK_STREAM, "Wrong socket type, expected %d received %d\n",
2308 SOCK_STREAM, socktype);
2309 closesocket(sock);
2310
2311 HeapFree(GetProcessHeap(), 0, pi);
2312
2313 pi_size = 0;
2314 items = WSAEnumProtocolsA(NULL, NULL, &pi_size);
2315 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2316 items);
2317 err = WSAGetLastError();
2318 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2319 err, WSAENOBUFS);
2320
2321 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
2322 ok(pi != NULL, "Failed to allocate memory\n");
2323 if (pi == NULL) {
2324 skip("Can't continue without memory.\n");
2325 return;
2326 }
2327
2328 items = WSAEnumProtocolsA(NULL, pi, &pi_size);
2329 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
2330 WSAGetLastError());
2331
2332 /* when no protocol and socket type are specified the first entry
2333 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2334 * is returned */
2335 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
2336 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2337 WSAGetLastError());
2338
2339 size = sizeof(socktype);
2340 socktype = 0xdead;
2341 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2342 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2343 for(i = 0; i < items; i++)
2344 {
2345 if(pi[i].dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)
2346 {
2347 ok(socktype == pi[i].iSocketType, "Wrong socket type, expected %d received %d\n",
2348 pi[i].iSocketType, socktype);
2349 break;
2350 }
2351 }
2352 ok(i != items, "Creating a socket without protocol and socket type didn't work\n");
2353 closesocket(sock);
2354
2355 /* when no socket type is specified the first entry from WSAEnumProtocols
2356 * that matches the protocol is returned */
2357 for (i = 0; i < sizeof(autoprotocols) / sizeof(autoprotocols[0]); i++)
2358 {
2359 sock = WSASocketA(0, 0, autoprotocols[i], NULL, 0, 0);
2360 ok(sock != INVALID_SOCKET, "Failed to create socket for protocol %d, received %d\n",
2361 autoprotocols[i], WSAGetLastError());
2362
2363 size = sizeof(socktype);
2364 socktype = 0xdead;
2365 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2366 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2367
2368 for (err = 1, j = 0; j < items; j++)
2369 {
2370 if (pi[j].iProtocol == autoprotocols[i])
2371 {
2372 if (socktype == pi[j].iSocketType)
2373 err = 0;
2374 else
2375 ok(0, "Wrong socket type, expected %d received %d\n",
2376 pi[j].iSocketType, socktype);
2377 break;
2378 }
2379 }
2380 ok(!err, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols[i]);
2381
2382 closesocket(sock);
2383 }
2384
2385 HeapFree(GetProcessHeap(), 0, pi);
2386
2387 SetLastError(0xdeadbeef);
2388 /* starting on vista the socket function returns error during the socket
2389 creation and no longer in the socket operations (sendto, readfrom) */
2390 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
2391 if (sock == INVALID_SOCKET)
2392 {
2393 err = WSAGetLastError();
2394 ok(err == WSAEACCES, "Expected 10013, received %d\n", err);
2395 skip("SOCK_RAW is not supported\n");
2396 }
2397 else
2398 {
2399 trace("SOCK_RAW is supported\n");
2400
2401 size = sizeof(socktype);
2402 socktype = 0xdead;
2403 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2404 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2405 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2406 SOCK_RAW, socktype);
2407 closesocket(sock);
2408
2409 todo_wine {
2410 sock = WSASocketA(0, 0, IPPROTO_RAW, NULL, 0, 0);
2411 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2412 WSAGetLastError());
2413 size = sizeof(socktype);
2414 socktype = 0xdead;
2415 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2416 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2417 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2418 SOCK_RAW, socktype);
2419 closesocket(sock);
2420 }
2421
2422 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_TCP, NULL, 0, 0);
2423 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2424 WSAGetLastError());
2425 size = sizeof(socktype);
2426 socktype = 0xdead;
2427 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2428 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2429 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2430 SOCK_RAW, socktype);
2431 closesocket(sock);
2432 }
2433
2434 /* IPX socket tests */
2435
2436 SetLastError(0xdeadbeef);
2437 sock = WSASocketA(AF_IPX, SOCK_DGRAM, NSPROTO_IPX, NULL, 0, 0);
2438 if (sock == INVALID_SOCKET)
2439 {
2440 err = WSAGetLastError();
2441 ok(err == WSAEAFNOSUPPORT || broken(err == WSAEPROTONOSUPPORT), "Expected 10047, received %d\n", err);
2442 skip("IPX is not supported\n");
2443 }
2444 else
2445 {
2446 WSAPROTOCOL_INFOA info;
2447 closesocket(sock);
2448
2449 trace("IPX is supported\n");
2450
2451 sock = WSASocketA(0, 0, NSPROTO_IPX, NULL, 0, 0);
2452 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2453 WSAGetLastError());
2454
2455 size = sizeof(socktype);
2456 socktype = 0xdead;
2457 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2458 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2459 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2460 SOCK_DGRAM, socktype);
2461
2462 /* check socket family, type and protocol */
2463 size = sizeof(WSAPROTOCOL_INFOA);
2464 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &info, &size);
2465 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2466 ok(info.iProtocol == NSPROTO_IPX, "expected protocol %d, received %d\n",
2467 NSPROTO_IPX, info.iProtocol);
2468 ok(info.iAddressFamily == AF_IPX, "expected family %d, received %d\n",
2469 AF_IPX, info.iProtocol);
2470 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2471 SOCK_DGRAM, info.iSocketType);
2472 closesocket(sock);
2473
2474 /* SOCK_STREAM does not support NSPROTO_IPX */
2475 SetLastError(0xdeadbeef);
2476 ok(WSASocketA(AF_IPX, SOCK_STREAM, NSPROTO_IPX, NULL, 0, 0) == INVALID_SOCKET,
2477 "WSASocketA should have failed\n");
2478 err = WSAGetLastError();
2479 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2480
2481 /* test extended IPX support - that is adding any number between 0 and 255
2482 * to the IPX protocol value will make it be used as IPX packet type */
2483 for(i = 0;i <= 255;i += 17)
2484 {
2485 SetLastError(0xdeadbeef);
2486 sock = WSASocketA(0, 0, NSPROTO_IPX + i, NULL, 0, 0);
2487 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2488 WSAGetLastError());
2489
2490 size = sizeof(int);
2491 socktype = -1;
2492 err = getsockopt(sock, NSPROTO_IPX, IPX_PTYPE, (char *) &socktype, &size);
2493 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2494 ok(socktype == i, "Wrong IPX packet type, expected %d received %d\n",
2495 i, socktype);
2496
2497 closesocket(sock);
2498 }
2499 }
2500 }
2501
2502 static void test_WSADuplicateSocket(void)
2503 {
2504 SOCKET source, dupsock;
2505 WSAPROTOCOL_INFOA info;
2506 DWORD err;
2507 struct sockaddr_in addr;
2508 int socktype, size, addrsize, ret;
2509 char teststr[] = "TEST", buffer[16];
2510
2511 source = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
2512 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2513
2514 /* test invalid parameters */
2515 SetLastError(0xdeadbeef);
2516 ok(WSADuplicateSocketA(0, 0, NULL), "WSADuplicateSocketA should have failed\n");
2517 err = WSAGetLastError();
2518 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2519
2520 SetLastError(0xdeadbeef);
2521 ok(WSADuplicateSocketA(source, 0, NULL),
2522 "WSADuplicateSocketA should have failed\n");
2523 err = WSAGetLastError();
2524 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2525
2526 SetLastError(0xdeadbeef);
2527 ok(WSADuplicateSocketA(source, ~0, &info),
2528 "WSADuplicateSocketA should have failed\n");
2529 err = WSAGetLastError();
2530 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2531
2532 SetLastError(0xdeadbeef);
2533 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info),
2534 "WSADuplicateSocketA should have failed\n");
2535 err = WSAGetLastError();
2536 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2537
2538 SetLastError(0xdeadbeef);
2539 ok(WSADuplicateSocketA(source, GetCurrentProcessId(), NULL),
2540 "WSADuplicateSocketA should have failed\n");
2541 err = WSAGetLastError();
2542 ok(err == WSAEFAULT, "expected 10014, received %d\n", err);
2543
2544 /* test returned structure */
2545 memset(&info, 0, sizeof(info));
2546 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2547 "WSADuplicateSocketA should have worked\n");
2548
2549 ok(info.iProtocol == IPPROTO_TCP, "expected protocol %d, received %d\n",
2550 IPPROTO_TCP, info.iProtocol);
2551 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2552 AF_INET, info.iProtocol);
2553 ok(info.iSocketType == SOCK_STREAM, "expected type %d, received %d\n",
2554 SOCK_STREAM, info.iSocketType);
2555
2556 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2557 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2558
2559 closesocket(dupsock);
2560 closesocket(source);
2561
2562 /* create a socket, bind it, duplicate it then send data on source and
2563 * receve in the duplicated socket */
2564 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2565 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2566
2567 memset(&info, 0, sizeof(info));
2568 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2569 "WSADuplicateSocketA should have worked\n");
2570
2571 ok(info.iProtocol == IPPROTO_UDP, "expected protocol %d, received %d\n",
2572 IPPROTO_UDP, info.iProtocol);
2573 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2574 AF_INET, info.iProtocol);
2575 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2576 SOCK_DGRAM, info.iSocketType);
2577
2578 memset(&addr, 0, sizeof(addr));
2579 addr.sin_family = AF_INET;
2580 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2581 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2582 "bind should have worked\n");
2583
2584 /* read address to find out the port number to be used in sendto */
2585 memset(&addr, 0, sizeof(addr));
2586 addrsize = sizeof(addr);
2587 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2588 "getsockname should have worked\n");
2589 ok(addr.sin_port, "socket port should be != 0\n");
2590
2591 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2592 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2593
2594 size = sizeof(int);
2595 ret = getsockopt(dupsock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2596 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
2597 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2598 SOCK_DGRAM, socktype);
2599
2600 set_blocking(source, TRUE);
2601
2602 /* send data on source socket */
2603 addrsize = sizeof(addr);
2604 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2605 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2606
2607 /* receive on duplicated socket */
2608 addrsize = sizeof(addr);
2609 memset(buffer, 0, sizeof(buffer));
2610 size = recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize);
2611 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2612 buffer[sizeof(teststr) - 1] = 0;
2613 ok(!strcmp(buffer, teststr), "expected '%s', received '%s'\n", teststr, buffer);
2614
2615 closesocket(dupsock);
2616 closesocket(source);
2617
2618 /* show that the source socket need to be bound before the duplicated
2619 * socket is created */
2620 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2621 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2622
2623 memset(&info, 0, sizeof(info));
2624 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2625 "WSADuplicateSocketA should have worked\n");
2626
2627 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2628 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2629
2630 memset(&addr, 0, sizeof(addr));
2631 addr.sin_family = AF_INET;
2632 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2633 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2634 "bind should have worked\n");
2635
2636 /* read address to find out the port number to be used in sendto */
2637 memset(&addr, 0, sizeof(addr));
2638 addrsize = sizeof(addr);
2639 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2640 "getsockname should have worked\n");
2641 ok(addr.sin_port, "socket port should be != 0\n");
2642
2643 set_blocking(source, TRUE);
2644
2645 addrsize = sizeof(addr);
2646 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2647 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2648
2649 SetLastError(0xdeadbeef);
2650 addrsize = sizeof(addr);
2651 memset(buffer, 0, sizeof(buffer));
2652 todo_wine {
2653 ok(recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize) == -1,
2654 "recvfrom should have failed\n");
2655 err = WSAGetLastError();
2656 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2657 }
2658
2659 closesocket(dupsock);
2660 closesocket(source);
2661 }
2662
2663 static void test_WSAEnumNetworkEvents(void)
2664 {
2665 SOCKET s, s2;
2666 int sock_type[] = {SOCK_STREAM, SOCK_DGRAM, SOCK_STREAM}, i, j, k, l;
2667 struct sockaddr_in address;
2668 HANDLE event;
2669 WSANETWORKEVENTS net_events;
2670 /* Windows 2000 Pro without SP installed (testbot) will crash if
2671 * WSAEnumNetworkEvents have a NULL event, so skip this test in <= 2000 */
2672 DWORD ver = GetVersion() & 0xFFFF;
2673 BOOL supports_null = ((ver & 0xFF) << 8 | (ver >> 8)) > 0x0500;
2674
2675 memset(&address, 0, sizeof(address));
2676 address.sin_addr.s_addr = htonl(INADDR_ANY);
2677 address.sin_family = AF_INET;
2678
2679 /* This test follows the steps from bugs 10204 and 24946 */
2680 for (l = 0; l < 2; l++)
2681 {
2682 if (l == 1 && !supports_null && broken(1)) continue;
2683
2684 for (i = 0; i < sizeof(sock_type) / sizeof(sock_type[0]); i++)
2685 {
2686 if (i == 2)
2687 ok(!tcp_socketpair(&s, &s2), "Test[%d]: creating socket pair failed\n", i);
2688 else
2689 {
2690 s = socket(AF_INET, sock_type[i], 0);
2691 ok (s != SOCKET_ERROR, "Test[%d]: failed to create socket\n", i);
2692 ok (!bind(s, (struct sockaddr*) &address, sizeof(address)), "Test[%d]: bind failed\n", i);
2693 }
2694 event = WSACreateEvent();
2695 ok (event != NULL, "Test[%d]: failed to create event\n", i);
2696 for (j = 0; j < 5; j++) /* Repeat sometimes and the result must be the same */
2697 {
2698 /* When the TCP socket is not connected NO events will be returned.
2699 * When connected and no data pending it will get the write event.
2700 * UDP sockets don't have connections so as soon as they are bound
2701 * they can read/write data. Since nobody is sendind us data only
2702 * the write event will be returned and ONLY once.
2703 */
2704 ok (!WSAEventSelect(s, event, FD_READ | FD_WRITE), "Test[%d]: WSAEventSelect failed\n", i);
2705 memset(&net_events, 0xAB, sizeof(net_events));
2706 ok (!WSAEnumNetworkEvents(s, l == 0 ? event : NULL, &net_events),
2707 "Test[%d]: WSAEnumNetworkEvents failed\n", i);
2708 if (i >= 1 && j == 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
2709 {
2710 if (i == 0) /* Remove when fixed */
2711 {
2712 todo_wine
2713 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %d\n",
2714 i, net_events.lNetworkEvents);
2715 }
2716 else
2717 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %d\n",
2718 i, net_events.lNetworkEvents);
2719 }
2720 else
2721 {
2722 if (i != 0) /* Remove when fixed */
2723 {
2724 todo_wine
2725 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %d\n",
2726 i, net_events.lNetworkEvents);
2727 }
2728 else
2729 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %d\n",
2730 i, net_events.lNetworkEvents);
2731 }
2732 for (k = 0; k < FD_MAX_EVENTS; k++)
2733 {
2734 if (i >= 1 && j == 0 && k == 1) /* first UDP and connected TCP test, FD_WRITE bit no error*/
2735 {
2736 ok (net_events.iErrorCode[k] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
2737 i, k, net_events.iErrorCode[k]);
2738 }
2739 else
2740 {
2741 /* Bits that are not set in lNetworkEvents MUST not be changed */
2742 todo_wine
2743 ok (net_events.iErrorCode[k] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
2744 i, k, net_events.iErrorCode[k]);
2745 }
2746 }
2747 }
2748 closesocket(s);
2749 WSACloseEvent(event);
2750 if (i == 2) closesocket(s2);
2751 }
2752 }
2753 }
2754
2755 static void test_WSAAddressToStringA(void)
2756 {
2757 SOCKET v6 = INVALID_SOCKET;
2758 INT ret;
2759 DWORD len;
2760 int GLE;
2761 SOCKADDR_IN sockaddr;
2762 CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2763
2764 CHAR expect1[] = "0.0.0.0";
2765 CHAR expect2[] = "255.255.255.255";
2766 CHAR expect3[] = "0.0.0.0:65535";
2767 CHAR expect4[] = "255.255.255.255:65535";
2768
2769 SOCKADDR_IN6 sockaddr6;
2770 CHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2771
2772 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2773 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2774 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2775
2776 CHAR expect6_1[] = "::1";
2777 CHAR expect6_2[] = "20ab::1";
2778 CHAR expect6_3[] = "[20ab::2001]:33274";
2779 CHAR expect6_3_nt[] = "20ab::2001@33274";
2780 CHAR expect6_3_w2k[] = "20ab::2001";
2781 CHAR expect6_3_2[] = "[20ab::2001%4660]:33274";
2782 CHAR expect6_3_2_nt[] = "4660/20ab::2001@33274";
2783 CHAR expect6_3_2_w2k[] = "20ab::2001%4660";
2784 CHAR expect6_3_3[] = "20ab::2001%4660";
2785 CHAR expect6_3_3_nt[] = "4660/20ab::2001";
2786
2787 len = 0;
2788
2789 sockaddr.sin_family = AF_INET;
2790 sockaddr.sin_port = 0;
2791 sockaddr.sin_addr.s_addr = 0;
2792
2793 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2794 GLE = WSAGetLastError();
2795 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
2796 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2797 GLE, ret );
2798
2799 len = sizeof(address);
2800
2801 sockaddr.sin_family = AF_INET;
2802 sockaddr.sin_port = 0;
2803 sockaddr.sin_addr.s_addr = 0;
2804
2805 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2806 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2807
2808 ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
2809 ok( len == sizeof( expect1 ), "Got size %d\n", len);
2810
2811 len = sizeof(address);
2812
2813 sockaddr.sin_family = AF_INET;
2814 sockaddr.sin_port = 0;
2815 sockaddr.sin_addr.s_addr = 0xffffffff;
2816
2817 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2818 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2819
2820 ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
2821
2822 len = sizeof(address);
2823
2824 sockaddr.sin_family = AF_INET;
2825 sockaddr.sin_port = 0xffff;
2826 sockaddr.sin_addr.s_addr = 0;
2827
2828 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2829 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2830
2831 ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
2832
2833 len = sizeof(address);
2834
2835 sockaddr.sin_family = AF_INET;
2836 sockaddr.sin_port = 0xffff;
2837 sockaddr.sin_addr.s_addr = 0xffffffff;
2838
2839 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2840 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2841
2842 ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
2843 ok( len == sizeof( expect4 ), "Got size %d\n", len);
2844
2845 /*check to see it IPv6 is available */
2846 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
2847 if (v6 == INVALID_SOCKET) {
2848 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2849 WSAGetLastError(), WSAEAFNOSUPPORT);
2850 goto end;
2851 }
2852 /* Test a short IPv6 address */
2853 len = sizeof(address6);
2854
2855 sockaddr6.sin6_family = AF_INET6;
2856 sockaddr6.sin6_port = 0x0000;
2857 sockaddr6.sin6_scope_id = 0;
2858 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
2859
2860 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2861 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2862 ok( !strcmp( address6, expect6_1 ), "Expected: %s, got: %s\n", expect6_1, address6 );
2863 ok( len == sizeof(expect6_1), "Got size %d\n", len);
2864
2865 /* Test a longer IPv6 address */
2866 len = sizeof(address6);
2867
2868 sockaddr6.sin6_family = AF_INET6;
2869 sockaddr6.sin6_port = 0x0000;
2870 sockaddr6.sin6_scope_id = 0;
2871 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
2872
2873 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2874 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2875 ok( !strcmp( address6, expect6_2 ), "Expected: %s, got: %s\n", expect6_2, address6 );
2876 ok( len == sizeof(expect6_2), "Got size %d\n", len);
2877
2878 /* Test IPv6 address and port number */
2879 len = sizeof(address6);
2880
2881 sockaddr6.sin6_family = AF_INET6;
2882 sockaddr6.sin6_port = 0xfa81;
2883 sockaddr6.sin6_scope_id = 0;
2884 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2885
2886 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2887 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2888 ok( !strcmp( address6, expect6_3 ) ||
2889 broken( !strcmp( address6, expect6_3_nt ) ) || /* NT4 */
2890 broken( !strcmp( address6, expect6_3_w2k ) ), /* Win2000 */
2891 "Expected: %s, got: %s\n", expect6_3, address6 );
2892 ok( len == sizeof(expect6_3) ||
2893 broken( len == sizeof(expect6_3_nt) ) || /* NT4 */
2894 broken( len == sizeof(expect6_3_w2k) ), /* Win2000 */
2895 "Got size %d\n", len);
2896
2897 /* Test IPv6 address, port number and scope_id */
2898 len = sizeof(address6);
2899
2900 sockaddr6.sin6_family = AF_INET6;
2901 sockaddr6.sin6_port = 0xfa81;
2902 sockaddr6.sin6_scope_id = 0x1234;
2903 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2904
2905 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2906 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2907 ok( !strcmp( address6, expect6_3_2 ) ||
2908 broken( !strcmp( address6, expect6_3_2_nt ) ) || /* NT4 */
2909 broken( !strcmp( address6, expect6_3_2_w2k ) ), /* Win2000 */
2910 "Expected: %s, got: %s\n", expect6_3_2, address6 );
2911 ok( len == sizeof(expect6_3_2) ||
2912 broken( len == sizeof(expect6_3_2_nt) ) || /* NT4 */
2913 broken( len == sizeof(expect6_3_2_w2k) ), /* Win2000 */
2914 "Got size %d\n", len);
2915
2916 /* Test IPv6 address and scope_id */
2917 len = sizeof(address6);
2918
2919 sockaddr6.sin6_family = AF_INET6;
2920 sockaddr6.sin6_port = 0x0000;
2921 sockaddr6.sin6_scope_id = 0x1234;
2922 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2923
2924 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2925 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2926 ok( !strcmp( address6, expect6_3_3 ) ||
2927 broken( !strcmp( address6, expect6_3_3_nt ) ), /* NT4 */
2928 "Expected: %s, got: %s\n", expect6_3_3, address6 );
2929 ok( len == sizeof(expect6_3_3) ||
2930 broken( len == sizeof(expect6_3_3_nt) ), /* NT4 */
2931 "Got size %d\n", len);
2932
2933 end:
2934 if (v6 != INVALID_SOCKET)
2935 closesocket(v6);
2936 }
2937
2938 static void test_WSAAddressToStringW(void)
2939 {
2940 SOCKET v6 = INVALID_SOCKET;
2941 INT ret;
2942 DWORD len;
2943 int GLE;
2944 SOCKADDR_IN sockaddr;
2945 WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2946
2947 WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
2948 WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
2949 WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
2950 WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
2951 '6', '5', '5', '3', '5', 0 };
2952
2953 SOCKADDR_IN6 sockaddr6;
2954 WCHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2955
2956 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2957 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2958 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2959
2960 WCHAR expect6_1[] = {':',':','1',0};
2961 WCHAR expect6_2[] = {'2','0','a','b',':',':','1',0};
2962 WCHAR expect6_3[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
2963 WCHAR expect6_3_nt[] = {'2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
2964 WCHAR expect6_3_w2k[] = {'2','0','a','b',':',':','2','0','0','1',0};
2965 WCHAR expect6_3_2[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
2966 WCHAR expect6_3_2_nt[] = {'4','6','6','0','/','2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
2967 WCHAR expect6_3_2_w2k[] = {'2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',0};
2968 WCHAR expect6_3_3[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
2969 WCHAR expect6_3_3_nt[] = {'6','5','5','3','4','/','2','0','a','b',':',':','2','0','0','1',0};
2970
2971 len = 0;
2972
2973 sockaddr.sin_family = AF_INET;
2974 sockaddr.sin_port = 0;
2975 sockaddr.sin_addr.s_addr = 0;
2976
2977 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2978 GLE = WSAGetLastError();
2979 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
2980 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2981 GLE, ret );
2982
2983 len = sizeof(address);
2984
2985 sockaddr.sin_family = AF_INET;
2986 sockaddr.sin_port = 0;
2987 sockaddr.sin_addr.s_addr = 0;
2988
2989 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2990 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2991
2992 ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
2993 ok( len == sizeof( expect1 )/sizeof( WCHAR ), "Got size %d\n", len);
2994
2995 len = sizeof(address);
2996
2997 sockaddr.sin_family = AF_INET;
2998 sockaddr.sin_port = 0;
2999 sockaddr.sin_addr.s_addr = 0xffffffff;
3000
3001 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3002 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3003
3004 ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
3005
3006 len = sizeof(address);
3007
3008 sockaddr.sin_family = AF_INET;
3009 sockaddr.sin_port = 0xffff;
3010 sockaddr.sin_addr.s_addr = 0;
3011
3012 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3013 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3014
3015 ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
3016
3017 len = sizeof(address);
3018
3019 sockaddr.sin_family = AF_INET;
3020 sockaddr.sin_port = 0xffff;
3021 sockaddr.sin_addr.s_addr = 0xffffffff;
3022
3023 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3024 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3025
3026 ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
3027 ok( len == sizeof( expect4 )/sizeof( WCHAR ), "Got %d\n", len);
3028
3029 /*check to see it IPv6 is available */
3030 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
3031 if (v6 == INVALID_SOCKET) {
3032 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3033 WSAGetLastError(), WSAEAFNOSUPPORT);
3034 goto end;
3035 }
3036
3037 /* Test a short IPv6 address */
3038 len = sizeof(address6)/sizeof(WCHAR);
3039
3040 sockaddr6.sin6_family = AF_INET6;
3041 sockaddr6.sin6_port = 0x0000;
3042 sockaddr6.sin6_scope_id = 0;
3043 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
3044
3045 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3046 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3047 ok( !lstrcmpW( address6, expect6_1 ), "Wrong string returned\n" );
3048 ok( len == sizeof(expect6_1)/sizeof(WCHAR), "Got %d\n", len);
3049
3050 /* Test a longer IPv6 address */
3051 len = sizeof(address6)/sizeof(WCHAR);
3052
3053 sockaddr6.sin6_family = AF_INET6;
3054 sockaddr6.sin6_port = 0x0000;
3055 sockaddr6.sin6_scope_id = 0;
3056 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
3057
3058 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3059 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3060
3061 ok( !lstrcmpW( address6, expect6_2 ), "Wrong string returned\n" );
3062 ok( len == sizeof(expect6_2)/sizeof(WCHAR), "Got %d\n", len);
3063
3064 /* Test IPv6 address and port number */
3065 len = sizeof(address6)/sizeof(WCHAR);
3066
3067 sockaddr6.sin6_family = AF_INET6;
3068 sockaddr6.sin6_port = 0xfa81;
3069 sockaddr6.sin6_scope_id = 0;
3070 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3071
3072 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3073 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3074 ok( !lstrcmpW( address6, expect6_3 ) ||
3075 broken( !lstrcmpW( address6, expect6_3_nt ) ) || /* NT4 */
3076 broken( !lstrcmpW( address6, expect6_3_w2k ) ), /* Win2000 */
3077 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3),
3078 wine_dbgstr_w(address6) );
3079 ok( len == sizeof(expect6_3)/sizeof(WCHAR) ||
3080 broken(len == sizeof(expect6_3_nt)/sizeof(WCHAR) ) || /* NT4 */
3081 broken(len == sizeof(expect6_3_w2k)/sizeof(WCHAR) ), /* Win2000 */
3082 "Got %d\n", len);
3083
3084 /* Test IPv6 address, port number and scope_id */
3085 len = sizeof(address6)/sizeof(WCHAR);
3086
3087 sockaddr6.sin6_family = AF_INET6;
3088 sockaddr6.sin6_port = 0xfa81;
3089 sockaddr6.sin6_scope_id = 0x1234;
3090 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3091
3092 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3093 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3094 ok( !lstrcmpW( address6, expect6_3_2 ) ||
3095 broken( !lstrcmpW( address6, expect6_3_2_nt ) ) || /* NT4 */
3096 broken( !lstrcmpW( address6, expect6_3_2_w2k ) ), /* Win2000 */
3097 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2),
3098 wine_dbgstr_w(address6) );
3099 ok( len == sizeof(expect6_3_2)/sizeof(WCHAR) ||
3100 broken( len == sizeof(expect6_3_2_nt)/sizeof(WCHAR) ) || /* NT4 */
3101 broken( len == sizeof(expect6_3_2_w2k)/sizeof(WCHAR) ), /* Win2000 */
3102 "Got %d\n", len);
3103
3104 /* Test IPv6 address and scope_id */
3105 len = sizeof(address6)/sizeof(WCHAR);
3106
3107 sockaddr6.sin6_family = AF_INET6;
3108 sockaddr6.sin6_port = 0x0000;
3109 sockaddr6.sin6_scope_id = 0xfffe;
3110 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3111
3112 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3113 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3114 ok( !lstrcmpW( address6, expect6_3_3 ) ||
3115 broken( !lstrcmpW( address6, expect6_3_3_nt ) ), /* NT4 */
3116 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3),
3117 wine_dbgstr_w(address6) );
3118 ok( len == sizeof(expect6_3_3)/sizeof(WCHAR) ||
3119 broken( len == sizeof(expect6_3_3_nt)/sizeof(WCHAR) ), /* NT4 */
3120 "Got %d\n", len);
3121
3122 end:
3123 if (v6 != INVALID_SOCKET)
3124 closesocket(v6);
3125 }
3126
3127 static void test_WSAStringToAddressA(void)
3128 {
3129 INT ret, len;
3130 SOCKADDR_IN sockaddr;
3131 SOCKADDR_IN6 sockaddr6;
3132 int GLE;
3133
3134 CHAR address1[] = "0.0.0.0";
3135 CHAR address2[] = "127.127.127.127";
3136 CHAR address3[] = "255.255.255.255";
3137 CHAR address4[] = "127.127.127.127:65535";
3138 CHAR address5[] = "255.255.255.255:65535";
3139 CHAR address6[] = "::1";
3140 CHAR address7[] = "[::1]";
3141 CHAR address8[] = "[::1]:65535";
3142 CHAR address9[] = "2001::1";
3143
3144 len = 0;
3145 sockaddr.sin_family = AF_INET;
3146
3147 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3148 ok( ret == SOCKET_ERROR, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
3149 WSAGetLastError() );
3150
3151 len = sizeof(sockaddr);
3152 sockaddr.sin_port = 0;
3153 sockaddr.sin_addr.s_addr = 0;
3154
3155 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3156 ok( !ret && sockaddr.sin_addr.s_addr == 0,
3157 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3158
3159 len = sizeof(sockaddr);
3160 sockaddr.sin_port = 0;
3161 sockaddr.sin_addr.s_addr = 0;
3162
3163 ret = WSAStringToAddressA( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3164 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
3165 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3166
3167 len = sizeof(sockaddr);
3168 sockaddr.sin_port = 0;
3169 sockaddr.sin_addr.s_addr = 0;
3170
3171 ret = WSAStringToAddressA( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3172 GLE = WSAGetLastError();
3173 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
3174 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3175 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
3176
3177 len = sizeof(sockaddr);
3178 sockaddr.sin_port = 0;
3179 sockaddr.sin_addr.s_addr = 0;
3180
3181 ret = WSAStringToAddressA( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3182 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
3183 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3184
3185 len = sizeof(sockaddr);
3186 sockaddr.sin_port = 0;
3187 sockaddr.sin_addr.s_addr = 0;
3188
3189 ret = WSAStringToAddressA( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3190 GLE = WSAGetLastError();
3191 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
3192 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3193 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
3194
3195 len = sizeof(sockaddr6);
3196 memset(&sockaddr6, 0, len);
3197 sockaddr6.sin6_family = AF_INET6;
3198
3199 ret = WSAStringToAddressA( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3200 &len );
3201 GLE = WSAGetLastError();
3202 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3203 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3204
3205 len = sizeof(sockaddr6);
3206 memset(&sockaddr6, 0, len);
3207 sockaddr6.sin6_family = AF_INET6;
3208
3209 ret = WSAStringToAddressA( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3210 &len );
3211 GLE = WSAGetLastError();
3212 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3213 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3214
3215 len = sizeof(sockaddr6);
3216 memset(&sockaddr6, 0, len);
3217 sockaddr6.sin6_family = AF_INET6;
3218
3219 ret = WSAStringToAddressA( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3220 &len );
3221 GLE = WSAGetLastError();
3222 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
3223 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3224 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3225
3226 len = sizeof(sockaddr);
3227
3228 ret = WSAStringToAddressA( address9, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3229 GLE = WSAGetLastError();
3230 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3231 "WSAStringToAddressA() should have failed with %d\n", GLE );
3232 }
3233
3234 static void test_WSAStringToAddressW(void)
3235 {
3236 INT ret, len;
3237 SOCKADDR_IN sockaddr, *sin;
3238 SOCKADDR_IN6 sockaddr6;
3239 SOCKADDR_STORAGE sockaddr_storage;
3240 int GLE;
3241
3242 WCHAR address1[] = { '0','.','0','.','0','.','0', 0 };
3243 WCHAR address2[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
3244 WCHAR address3[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3245 WCHAR address4[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
3246 ':', '6', '5', '5', '3', '5', 0 };
3247 WCHAR address5[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3248 '6', '5', '5', '3', '5', 0 };
3249 WCHAR address6[] = {':',':','1','\0'};
3250 WCHAR address7[] = {'[',':',':','1',']','\0'};
3251 WCHAR address8[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
3252 WCHAR address9[] = {'2','0','0','1',':',':','1','\0'};
3253
3254 len = 0;
3255 sockaddr.sin_family = AF_INET;
3256
3257 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3258 ok( ret == SOCKET_ERROR, "WSAStringToAddressW() failed unexpectedly: %d\n",
3259 WSAGetLastError() );
3260
3261 len = sizeof(sockaddr);
3262 sockaddr.sin_port = 0;
3263 sockaddr.sin_addr.s_addr = 0;
3264
3265 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3266 ok( !ret && sockaddr.sin_addr.s_addr == 0,
3267 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3268
3269 len = sizeof(sockaddr);
3270 sockaddr.sin_port = 0;
3271 sockaddr.sin_addr.s_addr = 0;
3272
3273 ret = WSAStringToAddressW( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3274 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
3275 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3276
3277 len = sizeof(sockaddr);
3278 sockaddr.sin_port = 0;
3279 sockaddr.sin_addr.s_addr = 0;
3280
3281 ret = WSAStringToAddressW( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3282 GLE = WSAGetLastError();
3283 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
3284 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3285 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3286
3287 len = sizeof(sockaddr);
3288 sockaddr.sin_port = 0;
3289 sockaddr.sin_addr.s_addr = 0;
3290
3291 ret = WSAStringToAddressW( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3292 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
3293 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3294
3295 len = sizeof(sockaddr);
3296 sockaddr.sin_port = 0;
3297 sockaddr.sin_addr.s_addr = 0;
3298
3299 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3300 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
3301 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3302 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3303
3304 /* Test with a larger buffer than necessary */
3305 len = sizeof(sockaddr_storage);
3306 sin = (SOCKADDR_IN *)&sockaddr_storage;
3307 sin->sin_port = 0;
3308 sin->sin_addr.s_addr = 0;
3309
3310 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)sin, &len );
3311 ok( (ret == 0 && sin->sin_addr.s_addr == 0xffffffff && sin->sin_port == 0xffff) ||
3312 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3313 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3314 ok( len == sizeof(SOCKADDR_IN) ||
3315 broken(len == sizeof(SOCKADDR_STORAGE)) /* NT4/2k */,
3316 "unexpected length %d\n", len );
3317
3318 len = sizeof(sockaddr6);
3319 memset(&sockaddr6, 0, len);
3320 sockaddr6.sin6_family = AF_INET6;
3321
3322 ret = WSAStringToAddressW( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3323 &len );
3324 GLE = WSAGetLastError();
3325 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3326 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3327
3328 len = sizeof(sockaddr6);
3329 memset(&sockaddr6, 0, len);
3330 sockaddr6.sin6_family = AF_INET6;
3331
3332 ret = WSAStringToAddressW( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3333 &len );
3334 GLE = WSAGetLastError();
3335 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3336 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3337
3338 len = sizeof(sockaddr6);
3339 memset(&sockaddr6, 0, len);
3340 sockaddr6.sin6_family = AF_INET6;
3341
3342 ret = WSAStringToAddressW( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3343 &len );
3344 GLE = WSAGetLastError();
3345 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
3346 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3347 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3348
3349 len = sizeof(sockaddr);
3350
3351 ret = WSAStringToAddressW( address9, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3352 GLE = WSAGetLastError();
3353 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3354 "WSAStringToAddressW() should have failed with %d\n", GLE );
3355 }
3356
3357 static DWORD WINAPI SelectReadThread(void *param)
3358 {
3359 select_thread_params *par = param;
3360 fd_set readfds;
3361 int ret;
3362 struct sockaddr_in addr;
3363 struct timeval select_timeout;
3364
3365 FD_ZERO(&readfds);
3366 FD_SET(par->s, &readfds);
3367 select_timeout.tv_sec=5;
3368 select_timeout.tv_usec=0;
3369 addr.sin_family = AF_INET;
3370 addr.sin_addr.s_addr = inet_addr(SERVERIP);
3371 addr.sin_port = htons(SERVERPORT);
3372
3373 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
3374 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
3375
3376 SetEvent(server_ready);
3377 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
3378 par->ReadKilled = (ret == 1);
3379
3380 return 0;
3381 }
3382
3383 static DWORD WINAPI SelectCloseThread(void *param)
3384 {
3385 SOCKET s = *(SOCKET*)param;
3386 Sleep(500);
3387 closesocket(s);
3388 return 0;
3389 }
3390
3391 static void test_errors(void)
3392 {
3393 SOCKET sock;
3394 SOCKADDR_IN SockAddr;
3395 int ret, err;
3396
3397 WSASetLastError(NO_ERROR);
3398 sock = socket(PF_INET, SOCK_STREAM, 0);
3399 ok( (sock != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3400 memset(&SockAddr, 0, sizeof(SockAddr));
3401 SockAddr.sin_family = AF_INET;
3402 SockAddr.sin_port = htons(6924);
3403 SockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
3404
3405 ret = connect(sock, (PSOCKADDR)&SockAddr, sizeof(SockAddr));
3406 ok( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got: %d\n", ret );
3407 if (ret == SOCKET_ERROR)
3408 {
3409 err = WSAGetLastError();
3410 ok( (err == WSAECONNREFUSED), "expected WSAECONNREFUSED, got: %d\n", err );
3411 }
3412
3413 {
3414 TIMEVAL timeval;
3415 fd_set set = {1, {sock}};
3416
3417 timeval.tv_sec = 0;
3418 timeval.tv_usec = 50000;
3419
3420 ret = select(1, NULL, &set, NULL, &timeval);
3421 ok( (ret == 0), "expected 0 (timeout), got: %d\n", ret );
3422 }
3423
3424 ret = closesocket(sock);
3425 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3426 }
3427
3428 static void test_listen(void)
3429 {
3430 SOCKET fdA, fdB;
3431 int ret, acceptc, olen = sizeof(acceptc);
3432 struct sockaddr_in address;
3433
3434 memset(&address, 0, sizeof(address));
3435 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3436 address.sin_family = AF_INET;
3437 address.sin_port = htons(SERVERPORT);
3438
3439 /* invalid socket tests */
3440 SetLastError(0xdeadbeef);
3441 ok ((listen(0, 0) == SOCKET_ERROR), "listen did not fail\n");
3442 ret = WSAGetLastError();
3443 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3444
3445 SetLastError(0xdeadbeef);
3446 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR), "listen did not fail\n");
3447 ret = WSAGetLastError();
3448 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3449
3450 /* tcp tests */
3451 fdA = socket(AF_INET, SOCK_STREAM, 0);
3452 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3453
3454 fdB = socket(AF_INET, SOCK_STREAM, 0);
3455 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3456
3457 SetLastError(0xdeadbeef);
3458 ok ((listen(fdA, -2) == SOCKET_ERROR), "listen did not fail\n");
3459 ret = WSAGetLastError();
3460 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3461
3462 SetLastError(0xdeadbeef);
3463 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
3464 ret = WSAGetLastError();
3465 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3466
3467 SetLastError(0xdeadbeef);
3468 ok ((listen(fdA, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3469 ret = WSAGetLastError();
3470 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3471
3472 ok (!bind(fdA, (struct sockaddr*) &address, sizeof(address)), "bind failed\n");
3473
3474 SetLastError(0xdeadbeef);
3475 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3476 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3477
3478 acceptc = 0xdead;
3479 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3480 ok (!ret, "getsockopt failed\n");
3481 ok (acceptc == 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc);
3482
3483 ok (!listen(fdA, 0), "listen failed\n");
3484 ok (!listen(fdA, SOMAXCONN), "double listen failed\n");
3485
3486 acceptc = 0xdead;
3487 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3488 ok (!ret, "getsockopt failed\n");
3489 ok (acceptc == 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc);
3490
3491 SetLastError(0xdeadbeef);
3492 ok ((listen(fdB, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3493 ret = WSAGetLastError();
3494 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3495
3496 ret = closesocket(fdB);
3497 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3498
3499 fdB = socket(AF_INET, SOCK_STREAM, 0);
3500 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3501
3502 SetLastError(0xdeadbeef);
3503 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3504 ret = WSAGetLastError();
3505 ok (ret == WSAEADDRINUSE, "expected 10048, received %d\n", ret);
3506
3507 ret = closesocket(fdA);
3508 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3509 ret = closesocket(fdB);
3510 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3511 }
3512
3513 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
3514 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
3515 static void test_select(void)
3516 {
3517 static char tmp_buf[1024];
3518
3519 SOCKET fdListen, fdRead, fdWrite;
3520 fd_set readfds, writefds, exceptfds;
3521 unsigned int maxfd;
3522 int ret, len;
3523 char buffer;
3524 struct timeval select_timeout;
3525 struct sockaddr_in address;
3526 select_thread_params thread_params;
3527 HANDLE thread_handle;
3528 DWORD ticks, id;
3529
3530 fdRead = socket(AF_INET, SOCK_STREAM, 0);
3531 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3532 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
3533 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3534
3535 maxfd = fdRead;
3536 if (fdWrite > maxfd)
3537 maxfd = fdWrite;
3538
3539 FD_ZERO_ALL();
3540 FD_SET_ALL(fdRead);
3541 FD_SET_ALL(fdWrite);
3542 select_timeout.tv_sec=0;
3543 select_timeout.tv_usec=0;
3544
3545 ticks = GetTickCount();
3546 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3547 ticks = GetTickCount() - ticks;
3548 ok(ret == 0, "select should not return any socket handles\n");
3549 ok(ticks < 10, "select was blocking for %u ms, expected < 10 ms\n", ticks);
3550 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3551 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3552 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3553 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3554
3555 FD_ZERO_ALL();
3556 FD_SET_ALL(fdRead);
3557 FD_SET_ALL(fdWrite);
3558 select_timeout.tv_sec=0;
3559 select_timeout.tv_usec=500;
3560
3561 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3562 ok(ret == 0, "select should not return any socket handles\n");
3563 ok(!FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3564 ok(!FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3565 ok(!FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3566 ok(!FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3567
3568 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3569 ret = closesocket(fdWrite);
3570 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3571
3572 thread_params.s = fdRead;
3573 thread_params.ReadKilled = FALSE;
3574 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
3575 thread_handle = CreateThread (NULL, 0, SelectReadThread, &thread_params, 0, &id );
3576 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
3577
3578 WaitForSingleObject (server_ready, INFINITE);
3579 Sleep(200);
3580 ret = closesocket(fdRead);
3581 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3582
3583 WaitForSingleObject (thread_handle, 1000);
3584 ok ( (thread_params.ReadKilled) ||
3585 broken(thread_params.ReadKilled == 0), /*Win98*/
3586 "closesocket did not wakeup select\n");
3587 ret = recv(fdRead, &buffer, 1, MSG_PEEK);
3588 ok( (ret == -1), "peek at closed socket expected -1 got %d\n", ret);
3589
3590 /* Test selecting invalid handles */
3591 FD_ZERO_ALL();
3592
3593 SetLastError(0);
3594 ret = select(maxfd+1, 0, 0, 0, &select_timeout);
3595 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3596 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3597
3598 SetLastError(0);
3599 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3600 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3601 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3602
3603 FD_SET(INVALID_SOCKET, &readfds);
3604 SetLastError(0);
3605 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3606 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3607 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3608 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3609
3610 FD_ZERO(&readfds);
3611 FD_SET(INVALID_SOCKET, &writefds);
3612 SetLastError(0);
3613 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3614 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3615 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3616 ok ( !FD_ISSET(fdRead, &writefds), "FD should not be set\n");
3617
3618 FD_ZERO(&writefds);
3619 FD_SET(INVALID_SOCKET, &exceptfds);
3620 SetLastError(0);
3621 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3622 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3623 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3624 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3625
3626 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3627 maxfd = fdRead;
3628 if(fdWrite > maxfd) maxfd = fdWrite;
3629
3630 FD_ZERO(&readfds);
3631 FD_SET(fdRead, &readfds);
3632 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3633 ok(!ret, "select returned %d\n", ret);
3634
3635 FD_ZERO(&writefds);
3636 FD_SET(fdWrite, &writefds);
3637 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3638 ok(ret == 1, "select returned %d\n", ret);
3639 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3640
3641 /* tests for overlapping fd_set pointers */
3642 FD_ZERO(&readfds);
3643 FD_SET(fdWrite, &readfds);
3644 ret = select(fdWrite+1, &readfds, &readfds, NULL, &select_timeout);
3645 ok(ret == 1, "select returned %d\n", ret);
3646 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3647
3648 FD_ZERO(&readfds);
3649 FD_SET(fdWrite, &readfds);
3650 FD_SET(fdRead, &readfds);
3651 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3652 ok(ret == 2, "select returned %d\n", ret);
3653 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3654 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3655
3656 ok(send(fdWrite, "test", 4, 0) == 4, "failed to send data\n");
3657 FD_ZERO(&readfds);
3658 FD_SET(fdRead, &readfds);
3659 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3660 ok(ret == 1, "select returned %d\n", ret);
3661 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3662
3663 FD_ZERO(&readfds);
3664 FD_SET(fdWrite, &readfds);
3665 FD_SET(fdRead, &readfds);
3666 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3667 ok(ret == 2, "select returned %d\n", ret);
3668 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3669 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3670
3671 while(1) {
3672 FD_ZERO(&writefds);
3673 FD_SET(fdWrite, &writefds);
3674 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3675 if(!ret) break;
3676 ok(send(fdWrite, tmp_buf, sizeof(tmp_buf), 0) > 0, "failed to send data\n");
3677 }
3678 FD_ZERO(&readfds);
3679 FD_SET(fdWrite, &readfds);
3680 FD_SET(fdRead, &readfds);
3681 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3682 ok(ret == 1, "select returned %d\n", ret);
3683 ok(!FD_ISSET(fdWrite, &readfds), "fdWrite socket is in the set\n");
3684 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3685
3686 ok(send(fdRead, "test", 4, 0) == 4, "failed to send data\n");
3687 Sleep(100);
3688 FD_ZERO(&readfds);
3689 FD_SET(fdWrite, &readfds);
3690 FD_SET(fdRead, &readfds);
3691 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3692 ok(ret == 2, "select returned %d\n", ret);
3693 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3694 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3695
3696 closesocket(fdRead);
3697 closesocket(fdWrite);
3698
3699 /* select() works in 3 distinct states:
3700 * - to check if a connection attempt ended with success or error;
3701 * - to check if a pending connection is waiting for acceptance;
3702 * - to check for data to read, availability for write and OOB data
3703 *
3704 * The tests below ensure that all conditions are tested.
3705 */
3706 memset(&address, 0, sizeof(address));
3707 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3708 address.sin_family = AF_INET;
3709 len = sizeof(address);
3710 fdListen = setup_server_socket(&address, &len);
3711 select_timeout.tv_sec = 1;
3712 select_timeout.tv_usec = 250000;
3713
3714 /* When no events are pending select returns 0 with no error */
3715 FD_ZERO_ALL();
3716 FD_SET_ALL(fdListen);
3717 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3718 ok(ret == 0, "expected 0, got %d\n", ret);
3719
3720 /* When a socket is attempting to connect the listening socket receives the read descriptor */
3721 fdWrite = setup_connector_socket(&address, len, TRUE);
3722 FD_ZERO_ALL();
3723 FD_SET_ALL(fdListen);
3724 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3725 ok(ret == 1, "expected 1, got %d\n", ret);
3726 ok(FD_ISSET(fdListen, &readfds), "fdListen socket is not in the set\n");
3727 len = sizeof(address);
3728 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
3729 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
3730
3731 /* The connector is signaled through the write descriptor */
3732 FD_ZERO_ALL();
3733 FD_SET_ALL(fdListen);
3734 FD_SET_ALL(fdRead);
3735 FD_SET_ALL(fdWrite);
3736 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3737 ok(ret == 2, "expected 2, got %d\n", ret);
3738 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3739 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
3740 len = sizeof(id);
3741 id = 0xdeadbeef;
3742 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
3743 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3744 ok(id == 0, "expected 0, got %d\n", id);
3745
3746 /* When data is received the receiver gets the read descriptor */
3747 ret = send(fdWrite, "1234", 4, 0);
3748 ok(ret == 4, "expected 4, got %d\n", ret);
3749 FD_ZERO_ALL();
3750 FD_SET_ALL(fdListen);
3751 FD_SET(fdRead, &readfds);
3752 FD_SET(fdRead, &exceptfds);
3753 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3754 ok(ret == 1, "expected 1, got %d\n", ret);
3755 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3756 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
3757 ok(ret == 4, "expected 4, got %d\n", ret);
3758 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
3759
3760 /* When OOB data is received the socket is set in the except descriptor */
3761 ret = send(fdWrite, "A", 1, MSG_OOB);
3762 ok(ret == 1, "expected 1, got %d\n", ret);
3763 FD_ZERO_ALL();
3764 FD_SET_ALL(fdListen);
3765 FD_SET(fdRead, &readfds);
3766 FD_SET(fdRead, &exceptfds);
3767 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3768 ok(ret == 1, "expected 1, got %d\n", ret);
3769 ok(FD_ISSET(fdRead, &exceptfds), "fdRead socket is not in the set\n");
3770 tmp_buf[0] = 0xAF;
3771 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
3772 ok(ret == 1, "expected 1, got %d\n", ret);
3773 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
3774
3775 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
3776 ret = 1;
3777 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
3778 ok(ret == 0, "expected 0, got %d\n", ret);
3779 ret = send(fdWrite, "A", 1, MSG_OOB);
3780 ok(ret == 1, "expected 1, got %d\n", ret);
3781 FD_ZERO_ALL();
3782 FD_SET_ALL(fdListen);
3783 FD_SET(fdRead, &readfds);
3784 FD_SET(fdRead, &exceptfds);
3785 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3786 ok(ret == 1, "expected 1, got %d\n", ret);
3787 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3788 tmp_buf[0] = 0xAF;
3789 SetLastError(0xdeadbeef);
3790 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
3791 if (ret == SOCKET_ERROR) /* can't recv with MSG_OOB if OOBINLINED */
3792 {
3793 ok(GetLastError() == WSAEINVAL, "expected 10022, got %d\n", GetLastError());
3794 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
3795 ok(ret == 1, "expected 1, got %d\n", ret);
3796 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
3797 }
3798 else ok(broken(ret == 1) /* <= NT4 */, "expected error, got 1\n");
3799
3800 /* When the connection is closed the socket is set in the read descriptor */
3801 ret = closesocket(fdRead);
3802 ok(ret == 0, "expected 0, got %d\n", ret);
3803 FD_ZERO_ALL();
3804 FD_SET_ALL(fdListen);
3805 FD_SET(fdWrite, &readfds);
3806 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3807 ok(ret == 1, "expected 1, got %d\n", ret);
3808 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3809 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
3810 ok(ret == 0, "expected 0, got %d\n", ret);
3811
3812 /* When a connection is attempted to a non-listening socket it will get to the except descriptor */
3813 ret = closesocket(fdWrite);
3814 ok(ret == 0, "expected 0, got %d\n", ret);
3815 ret = closesocket(fdListen);
3816 ok(ret == 0, "expected 0, got %d\n", ret);
3817 len = sizeof(address);
3818 fdWrite = setup_connector_socket(&address, len, TRUE);
3819 FD_ZERO_ALL();
3820 FD_SET(fdWrite, &writefds);
3821 FD_SET(fdWrite, &exceptfds);
3822 select_timeout.tv_sec = 2; /* requires more time to realize it will not connect */
3823 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3824 ok(ret == 1, "expected 1, got %d\n", ret);
3825 len = sizeof(id);
3826 id = 0xdeadbeef;
3827 ret = getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len);
3828 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
3829 ok(id == WSAECONNREFUSED, "expected 10061, got %d\n", id);
3830 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
3831 ok(select_timeout.tv_usec == 250000, "select timeout should not have changed\n");
3832 closesocket(fdWrite);
3833
3834 /* Try select() on a closed socket after connection */
3835 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3836 closesocket(fdRead);
3837 FD_ZERO_ALL();
3838 FD_SET_ALL(fdWrite);
3839 FD_SET_ALL(fdRead);
3840 SetLastError(0xdeadbeef);
3841 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
3842 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
3843 todo_wine
3844 ok(GetLastError() == WSAENOTSOCK, "expected 10038, got %d\n", GetLastError());
3845 /* descriptor sets are unchanged */
3846 ok(readfds.fd_count == 2, "expected 2, got %d\n", readfds.fd_count);
3847 ok(exceptfds.fd_count == 2, "expected 2, got %d\n", exceptfds.fd_count);
3848 closesocket(fdWrite);
3849
3850 /* Close the socket currently being selected in a thread - bug 38399 */
3851 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3852 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
3853 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
3854 FD_ZERO_ALL();
3855 FD_SET_ALL(fdWrite);
3856 ret = select(0, &readfds, NULL, &exceptfds, &select_timeout);
3857 ok(ret == 1, "expected 1, got %d\n", ret);
3858 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3859 WaitForSingleObject (thread_handle, 1000);
3860 closesocket(fdRead);
3861 /* test again with only the except descriptor */
3862 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3863 thread_handle = CreateThread(NULL, 0, SelectCloseThread, &fdWrite, 0, &id);
3864 ok(thread_handle != NULL, "CreateThread failed unexpectedly: %d\n", GetLastError());
3865 FD_ZERO_ALL();
3866 FD_SET(fdWrite, &exceptfds);
3867 SetLastError(0xdeadbeef);
3868 ret = select(0, NULL, NULL, &exceptfds, &select_timeout);
3869 todo_wine
3870 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
3871 todo_wine
3872 ok(GetLastError() == WSAENOTSOCK, "expected 10038, got %d\n", GetLastError());
3873 WaitForSingleObject (thread_handle, 1000);
3874 closesocket(fdRead);
3875
3876 /* test UDP behavior of unbound sockets */
3877 select_timeout.tv_sec = 0;
3878 select_timeout.tv_usec = 250000;
3879 fdWrite = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
3880 ok(fdWrite != INVALID_SOCKET, "socket call failed\n");
3881 FD_ZERO_ALL();
3882 FD_SET_ALL(fdWrite);
3883 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3884 ok(ret == 1, "expected 1, got %d\n", ret);
3885 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3886 closesocket(fdWrite);
3887 }
3888 #undef FD_SET_ALL
3889 #undef FD_ZERO_ALL
3890
3891 static DWORD WINAPI AcceptKillThread(void *param)
3892 {
3893 select_thread_params *par = param;
3894 struct sockaddr_in address;
3895 int len = sizeof(address);
3896 SOCKET client_socket;
3897
3898 SetEvent(server_ready);
3899 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
3900 if (client_socket != INVALID_SOCKET)
3901 closesocket(client_socket);
3902 par->ReadKilled = (client_socket == INVALID_SOCKET);
3903 return 0;
3904 }
3905
3906
3907 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
3908 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
3909 GROUP *g, DWORD_PTR dwCallbackData)
3910 {
3911 return CF_DEFER;
3912 }
3913
3914 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len)
3915 {
3916 int ret, val;
3917 SOCKET server_socket;
3918
3919 server_socket = socket(AF_INET, SOCK_STREAM, 0);
3920 if (server_socket == INVALID_SOCKET)
3921 {
3922 trace("error creating server socket: %d\n", WSAGetLastError());
3923 return INVALID_SOCKET;
3924 }
3925
3926 val = 1;
3927 ret = setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
3928 if (ret)
3929 {
3930 trace("error setting SO_REUSEADDR: %d\n", WSAGetLastError());
3931 closesocket(server_socket);
3932 return INVALID_SOCKET;
3933 }
3934
3935 ret = bind(server_socket, (struct sockaddr *)addr, *len);
3936 if (ret)
3937 {
3938 trace("error binding server socket: %d\n", WSAGetLastError());
3939 }
3940
3941 ret = getsockname(server_socket, (struct sockaddr *)addr, len);
3942 if (ret)
3943 {
3944 skip("failed to lookup bind address: %d\n", WSAGetLastError());
3945 closesocket(server_socket);
3946 return INVALID_SOCKET;
3947 }
3948
3949 ret = listen(server_socket, 5);
3950 if (ret)
3951 {
3952 trace("error making server socket listen: %d\n", WSAGetLastError());
3953 closesocket(server_socket);
3954 return INVALID_SOCKET;
3955 }
3956
3957 return server_socket;
3958 }
3959
3960 static SOCKET setup_connector_socket(struct sockaddr_in *addr, int len, BOOL nonblock)
3961 {
3962 int ret;
3963 SOCKET connector;
3964
3965 connector = socket(AF_INET, SOCK_STREAM, 0);
3966 ok(connector != INVALID_SOCKET, "failed to create connector socket %d\n", WSAGetLastError());
3967
3968 if (nonblock)
3969 set_blocking(connector, !nonblock);
3970
3971 ret = connect(connector, (struct sockaddr *)addr, len);
3972 if (!nonblock)
3973 ok(!ret, "connecting to accepting socket failed %d\n", WSAGetLastError());
3974 else if (ret == SOCKET_ERROR)
3975 {
3976 DWORD error = WSAGetLastError();
3977 ok(error == WSAEWOULDBLOCK || error == WSAEINPROGRESS,
3978 "expected 10035 or 10036, got %d\n", error);
3979 }
3980
3981 return connector;
3982 }
3983
3984 static void test_accept(void)
3985 {
3986 int ret;
3987 SOCKET server_socket, accepted = INVALID_SOCKET, connector;
3988 struct sockaddr_in address;
3989 SOCKADDR_STORAGE ss;
3990 int socklen;
3991 select_thread_params thread_params;
3992 HANDLE thread_handle = NULL;
3993 DWORD id;
3994
3995 memset(&address, 0, sizeof(address));
3996 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3997 address.sin_family = AF_INET;
3998
3999 socklen = sizeof(address);
4000 server_socket = setup_server_socket(&address, &socklen);
4001 if (server_socket == INVALID_SOCKET)
4002 {
4003 trace("error creating server socket: %d\n", WSAGetLastError());
4004 return;
4005 }
4006
4007 connector = setup_connector_socket(&address, socklen, FALSE);
4008 if (connector == INVALID_SOCKET) goto done;
4009
4010 trace("Blocking accept next\n");
4011
4012 accepted = WSAAccept(server_socket, NULL, NULL, AlwaysDeferConditionFunc, 0);
4013 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
4014
4015 accepted = accept(server_socket, NULL, 0);
4016 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
4017
4018 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
4019 if (server_ready == INVALID_HANDLE_VALUE)
4020 {
4021 trace("error creating event: %d\n", GetLastError());
4022 goto done;
4023 }
4024
4025 thread_params.s = server_socket;
4026 thread_params.ReadKilled = FALSE;
4027 thread_handle = CreateThread(NULL, 0, AcceptKillThread, &thread_params, 0, &id);
4028 if (thread_handle == NULL)
4029 {
4030 trace("error creating thread: %d\n", GetLastError());
4031 goto done;
4032 }
4033
4034 WaitForSingleObject(server_ready, INFINITE);
4035 Sleep(200);
4036 ret = closesocket(server_socket);
4037 if (ret != 0)
4038 {
4039 trace("closesocket failed: %d\n", WSAGetLastError());
4040 goto done;
4041 }
4042
4043 WaitForSingleObject(thread_handle, 1000);
4044 ok(thread_params.ReadKilled || broken(!thread_params.ReadKilled) /* Win98/ME, after accept */,
4045 "closesocket did not wakeup accept\n");
4046
4047 closesocket(accepted);
4048 closesocket(connector);
4049 accepted = connector = INVALID_SOCKET;
4050
4051 socklen = sizeof(address);
4052 server_socket = setup_server_socket(&address, &socklen);
4053 if (server_socket == INVALID_SOCKET) goto done;
4054
4055 connector = setup_connector_socket(&address, socklen, FALSE);
4056 if (connector == INVALID_SOCKET) goto done;
4057
4058 socklen = 0;
4059 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4060 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4061 ok(!socklen, "got %d\n", socklen);
4062 closesocket(connector);
4063 connector = INVALID_SOCKET;
4064
4065 socklen = sizeof(address);
4066 connector = setup_connector_socket(&address, socklen, FALSE);
4067 if (connector == INVALID_SOCKET) goto done;
4068
4069 accepted = WSAAccept(server_socket, NULL, NULL, NULL, 0);
4070 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4071 closesocket(accepted);
4072 closesocket(connector);
4073 accepted = connector = INVALID_SOCKET;
4074
4075 socklen = sizeof(address);
4076 connector = setup_connector_socket(&address, socklen, FALSE);
4077 if (connector == INVALID_SOCKET) goto done;
4078
4079 socklen = sizeof(ss);
4080 memset(&ss, 0, sizeof(ss));
4081 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
4082 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4083 ok(socklen != sizeof(ss), "unexpected length\n");
4084 ok(ss.ss_family, "family not set\n");
4085 closesocket(accepted);
4086 closesocket(connector);
4087 accepted = connector = INVALID_SOCKET;
4088
4089 socklen = sizeof(address);
4090 connector = setup_connector_socket(&address, socklen, FALSE);
4091 if (connector == INVALID_SOCKET) goto done;
4092
4093 socklen = 0;
4094 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4095 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4096 ok(!socklen, "got %d\n", socklen);
4097 closesocket(connector);
4098 accepted = connector = INVALID_SOCKET;
4099
4100 socklen = sizeof(address);
4101 connector = setup_connector_socket(&address, socklen, FALSE);
4102 if (connector == INVALID_SOCKET) goto done;
4103
4104 accepted = accept(server_socket, NULL, NULL);
4105 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4106 closesocket(accepted);
4107 closesocket(connector);
4108 accepted = connector = INVALID_SOCKET;
4109
4110 socklen = sizeof(address);
4111 connector = setup_connector_socket(&address, socklen, FALSE);
4112 if (connector == INVALID_SOCKET) goto done;
4113
4114 socklen = sizeof(ss);
4115 memset(&ss, 0, sizeof(ss));
4116 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4117 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4118 ok(socklen != sizeof(ss), "unexpected length\n");
4119 ok(ss.ss_family, "family not set\n");
4120
4121 done:
4122 if (accepted != INVALID_SOCKET)
4123 closesocket(accepted);
4124 if (connector != INVALID_SOCKET)
4125 closesocket(connector);
4126 if (thread_handle != NULL)
4127 CloseHandle(thread_handle);
4128 if (server_ready != INVALID_HANDLE_VALUE)
4129 CloseHandle(server_ready);
4130 if (server_socket != INVALID_SOCKET)
4131 closesocket(server_socket);
4132 }
4133
4134 static void test_extendedSocketOptions(void)
4135 {
4136 WSADATA wsa;
4137 SOCKET sock;
4138 struct sockaddr_in sa;
4139 int sa_len = sizeof(struct sockaddr_in);
4140 int optval, optlen = sizeof(int), ret;
4141 BOOL bool_opt_val;
4142 LINGER linger_val;
4143
4144 if(WSAStartup(MAKEWORD(2,0), &wsa)){
4145 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4146 return;
4147 }
4148
4149 memset(&sa, 0, sa_len);
4150
4151 sa.sin_family = AF_INET;
4152 sa.sin_port = htons(0);
4153 sa.sin_addr.s_addr = htonl(INADDR_ANY);
4154
4155 if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) == INVALID_SOCKET) {
4156 trace("Creating the socket failed: %d\n", WSAGetLastError());
4157 WSACleanup();
4158 return;
4159 }
4160
4161 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
4162 trace("Failed to bind socket: %d\n", WSAGetLastError());
4163 closesocket(sock);
4164 WSACleanup();
4165 return;
4166 }
4167
4168 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4169
4170 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
4171 ok((optval == 65507) || (optval == 65527),
4172 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
4173
4174 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
4175 SetLastError(0xdeadbeef);
4176 optval = 0xdeadbeef;
4177 optlen = sizeof(int);
4178 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4179 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4180 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4181 ret, WSAGetLastError(), optval, optval);
4182
4183 /* more invalid values for level */
4184 SetLastError(0xdeadbeef);
4185 optval = 0xdeadbeef;
4186 optlen = sizeof(int);
4187 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4188 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4189 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4190 ret, WSAGetLastError(), optval, optval);
4191
4192 SetLastError(0xdeadbeef);
4193 optval = 0xdeadbeef;
4194 optlen = sizeof(int);
4195 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4196 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4197 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4198 ret, WSAGetLastError(), optval, optval);
4199
4200 SetLastError(0xdeadbeef);
4201 optval = 0xdeadbeef;
4202 optlen = sizeof(int);
4203 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4204 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4205 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4206 ret, WSAGetLastError(), optval, optval);
4207
4208 SetLastError(0xdeadbeef);
4209 optval = 0xdeadbeef;
4210 optlen = sizeof(int);
4211 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4212 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4213 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4214 ret, WSAGetLastError(), optval, optval);
4215
4216 SetLastError(0xdeadbeef);
4217 optlen = sizeof(LINGER);
4218 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4219 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAENOPROTOOPT),
4220 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
4221 ret, WSAGetLastError());
4222 closesocket(sock);
4223
4224 if((sock = socket(PF_INET, SOCK_STREAM, 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_LINGER, (char *)&linger_val, &optlen);
4238 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
4239
4240 optlen = sizeof(BOOL);
4241 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
4242 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
4243 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
4244 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
4245 bool_opt_val, linger_val.l_onoff);
4246
4247 closesocket(sock);
4248 WSACleanup();
4249 }
4250
4251 static void test_getsockname(void)
4252 {
4253 WSADATA wsa;
4254 SOCKET sock;
4255 struct sockaddr_in sa_set, sa_get;
4256 int sa_set_len = sizeof(struct sockaddr_in);
4257 int sa_get_len = sa_set_len;
4258 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
4259 int ret;
4260 struct hostent *h;
4261
4262 if(WSAStartup(MAKEWORD(2,0), &wsa)){
4263 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4264 return;
4265 }
4266
4267 memset(&sa_set, 0, sa_set_len);
4268
4269 sa_set.sin_family = AF_INET;
4270 sa_set.sin_port = htons(0);
4271 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
4272
4273 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
4274 trace("Creating the socket failed: %d\n", WSAGetLastError());
4275 WSACleanup();
4276 return;
4277 }
4278
4279 sa_get = sa_set;
4280 if (getsockname(sock, (struct sockaddr*) &sa_get, &sa_get_len) == 0)
4281 ok(0, "getsockname on unbound socket should fail\n");
4282 else {
4283 ok(WSAGetLastError() == WSAEINVAL, "getsockname on unbound socket "
4284 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL);
4285 ok(memcmp(&sa_get, &sa_set, sizeof(sa_get)) == 0,
4286 "failed getsockname modified sockaddr when it shouldn't\n");
4287 }
4288
4289 if(bind(sock, (struct sockaddr *) &sa_set, sa_set_len) < 0){
4290 trace("Failed to bind socket: %d\n", WSAGetLastError());
4291 closesocket(sock);
4292 WSACleanup();
4293 return;
4294 }
4295
4296 if(getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len) != 0){
4297 trace("Failed to call getsockname: %d\n", WSAGetLastError());
4298 closesocket(sock);
4299 WSACleanup();
4300 return;
4301 }
4302
4303 ret = memcmp(sa_get.sin_zero, null_padding, 8);
4304 ok(ret == 0 || broken(ret != 0), /* NT4 */
4305 "getsockname did not zero the sockaddr_in structure\n");
4306
4307 closesocket(sock);
4308
4309 h = gethostbyname("");
4310 if (h && h->h_length == 4) /* this test is only meaningful in IPv4 */
4311 {
4312 int i;
4313 for (i = 0; h->h_addr_list[i]; i++)
4314 {
4315 char ipstr[32];
4316 struct in_addr ip;
4317 ip.s_addr = *(ULONG *) h->h_addr_list[i];
4318
4319 sock = socket(AF_INET, SOCK_DGRAM, 0);
4320 ok(sock != INVALID_SOCKET, "socket failed with %d\n", GetLastError());
4321
4322 memset(&sa_set, 0, sizeof(sa_set));
4323 sa_set.sin_family = AF_INET;
4324 sa_set.sin_addr.s_addr = ip.s_addr;
4325 /* The same address we bind must be the same address we get */
4326 ret = bind(sock, (struct sockaddr*)&sa_set, sizeof(sa_set));
4327 ok(ret == 0, "bind failed with %d\n", GetLastError());
4328 sa_get_len = sizeof(sa_get);
4329 ret = getsockname(sock, (struct sockaddr*)&sa_get, &sa_get_len);
4330 ok(ret == 0, "getsockname failed with %d\n", GetLastError());
4331 strcpy(ipstr, inet_ntoa(sa_get.sin_addr));
4332 trace("testing bind on interface %s\n", ipstr);
4333 ok(sa_get.sin_addr.s_addr == sa_set.sin_addr.s_addr,
4334 "address does not match: %s != %s\n", ipstr, inet_ntoa(sa_set.sin_addr));
4335
4336 closesocket(sock);
4337 }
4338 }
4339
4340 WSACleanup();
4341 }
4342
4343 static void test_dns(void)
4344 {
4345 struct hostent *h;
4346 union memaddress
4347 {
4348 char *chr;
4349 void *mem;
4350 } addr;
4351 char **ptr;
4352 int acount;
4353
4354 h = gethostbyname("");
4355 ok(h != NULL, "gethostbyname(\"\") failed with %d\n", h_errno);
4356
4357 /* Use an address with valid alias names if possible */
4358 h = gethostbyname("source.winehq.org");
4359 if(!h)
4360 {
4361 skip("Can't test the hostent structure because gethostbyname failed\n");
4362 return;
4363 }
4364
4365 /* The returned struct must be allocated in a very strict way. First we need to
4366 * count how many aliases there are because they must be located right after
4367 * the struct hostent size. Knowing the amount of aliases we know the exact
4368 * location of the first IP returned. Rule valid for >= XP, for older OS's
4369 * it's somewhat the opposite. */
4370 addr.mem = h + 1;
4371 if(h->h_addr_list == addr.mem) /* <= W2K */
4372 {
4373 win_skip("Skipping hostent tests since this OS is unsupported\n");
4374 return;
4375 }
4376
4377 ok(h->h_aliases == addr.mem,
4378 "hostent->h_aliases should be in %p, it is in %p\n", addr.mem, h->h_aliases);
4379
4380 for(ptr = h->h_aliases, acount = 1; *ptr; ptr++) acount++;
4381 addr.chr += sizeof(*ptr) * acount;
4382 ok(h->h_addr_list == addr.mem,
4383 "hostent->h_addr_list should be in %p, it is in %p\n", addr.mem, h->h_addr_list);
4384
4385 for(ptr = h->h_addr_list, acount = 1; *ptr; ptr++) acount++;
4386
4387 addr.chr += sizeof(*ptr) * acount;
4388 ok(h->h_addr_list[0] == addr.mem,
4389 "hostent->h_addr_list[0] should be in %p, it is in %p\n", addr.mem, h->h_addr_list[0]);
4390 }
4391
4392 /* Our winsock headers don't define gethostname because it conflicts with the
4393 * definition in unistd.h. Define it here to get rid of the warning. */
4394
4395 int WINAPI gethostname(char *name, int namelen);
4396
4397 static void test_gethostbyname_hack(void)
4398 {
4399 struct hostent *he;
4400 char name[256];
4401 static BYTE loopback[] = {127, 0, 0, 1};
4402 static BYTE magic_loopback[] = {127, 12, 34, 56};
4403 int ret;
4404
4405 ret = gethostname(name, 256);
4406 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4407
4408 he = gethostbyname("localhost");
4409 ok(he != NULL, "gethostbyname(\"localhost\") failed: %d\n", h_errno);
4410 if(he)
4411 {
4412 if(he->h_length != 4)
4413 {
4414 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
4415 return;
4416 }
4417
4418 ok(memcmp(he->h_addr_list[0], loopback, he->h_length) == 0,
4419 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
4420 he->h_addr_list[0][0], he->h_addr_list[0][1], he->h_addr_list[0][2],
4421 he->h_addr_list[0][3]);
4422 }
4423
4424 if(strcmp(name, "localhost") == 0)
4425 {
4426 skip("hostname seems to be \"localhost\", skipping test.\n");
4427 return;
4428 }
4429
4430 he = gethostbyname(name);
4431 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, h_errno);
4432 if(he)
4433 {
4434 if(he->h_length != 4)
4435 {
4436 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
4437 return;
4438 }
4439
4440 if (he->h_addr_list[0][0] == 127)
4441 {
4442 ok(memcmp(he->h_addr_list[0], magic_loopback, he->h_length) == 0,
4443 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
4444 name, he->h_addr_list[0][0], he->h_addr_list[0][1],
4445 he->h_addr_list[0][2], he->h_addr_list[0][3]);
4446 }
4447 }
4448
4449 gethostbyname("nonexistent.winehq.org");
4450 /* Don't check for the return value, as some braindead ISPs will kindly
4451 * resolve nonexistent host names to addresses of the ISP's spam pages. */
4452 }
4453
4454 static void test_gethostname(void)
4455 {
4456 struct hostent *he;
4457 char name[256];
4458 int ret, len;
4459
4460 WSASetLastError(0xdeadbeef);
4461 ret = gethostname(NULL, 256);
4462 ok(ret == -1, "gethostname() returned %d\n", ret);
4463 ok(WSAGetLastError() == WSAEFAULT, "gethostname with null buffer "
4464 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT);
4465
4466 ret = gethostname(name, sizeof(name));
4467 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4468 he = gethostbyname(name);
4469 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4470
4471 len = strlen(name);
4472 WSASetLastError(0xdeadbeef);
4473 strcpy(name, "deadbeef");
4474 ret = gethostname(name, len);
4475 ok(ret == -1, "gethostname() returned %d\n", ret);
4476 ok(!strcmp(name, "deadbeef"), "name changed unexpected!\n");
4477 ok(WSAGetLastError() == WSAEFAULT, "gethostname with insufficient length "
4478 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT);
4479
4480 len++;
4481 ret = gethostname(name, len);
4482 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4483 he = gethostbyname(name);
4484 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4485 }
4486
4487 static void test_inet_addr(void)
4488 {
4489 u_long addr;
4490
4491 addr = inet_addr(NULL);
4492 ok(addr == INADDR_NONE, "inet_addr succeeded unexpectedly\n");
4493 }
4494
4495 static void test_addr_to_print(void)
4496 {
4497 char dst[16];
4498 char dst6[64];
4499 const char * pdst;
4500 struct in_addr in;
4501 struct in6_addr in6;
4502
4503 u_long addr0_Num = 0x00000000;
4504 PCSTR addr0_Str = "0.0.0.0";
4505 u_long addr1_Num = 0x20201015;
4506 PCSTR addr1_Str = "21.16.32.32";
4507 u_char addr2_Num[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
4508 PCSTR addr2_Str = "::fffe:cc98:bd74";
4509 u_char addr3_Num[16] = {0x20,0x30,0xa4,0xb1};
4510 PCSTR addr3_Str = "2030:a4b1::";
4511 u_char addr4_Num[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
4512 PCSTR addr4_Str = "::204.152.189.116";
4513
4514 /* Test IPv4 addresses */
4515 in.s_addr = addr0_Num;
4516
4517 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
4518 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
4519 ok(!strcmp(pdst, addr0_Str),"Address %s != %s\n", pdst, addr0_Str);
4520
4521 /* Test that inet_ntoa and inet_ntop return the same value */
4522 in.S_un.S_addr = addr1_Num;
4523 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
4524 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
4525 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4526
4527 /* InetNtop became available in Vista and Win2008 */
4528 if (!pInetNtop)
4529 {
4530 win_skip("InetNtop not present, not executing tests\n");
4531 return;
4532 }
4533
4534 /* Second part of test */
4535 pdst = pInetNtop(AF_INET,(void*)&in.s_addr, dst, sizeof(dst));
4536 ok(pdst != NULL, "InetNtop failed %s\n", dst);
4537 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4538
4539 /* Test invalid parm conditions */
4540 pdst = pInetNtop(1, (void*)&in.s_addr, dst, sizeof(dst));
4541 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4542 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "Should be WSAEAFNOSUPPORT\n");
4543
4544 /* Test Null destination */
4545 pdst = NULL;
4546 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, NULL, sizeof(dst));
4547 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4548 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4549 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4550
4551 /* Test zero length passed */
4552 WSASetLastError(0);
4553 pdst = NULL;
4554 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 0);
4555 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4556 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4557 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4558
4559 /* Test length one shorter than the address length */
4560 WSASetLastError(0);
4561 pdst = NULL;
4562 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 6);
4563 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4564 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4565 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4566
4567 /* Test longer length is ok */
4568 WSASetLastError(0);
4569 pdst = NULL;
4570 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, sizeof(dst)+1);
4571 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
4572 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4573
4574 /* Test the IPv6 addresses */
4575
4576 /* Test an zero prefixed IPV6 address */
4577 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
4578 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
4579 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4580 ok(!strcmp(pdst, addr2_Str),"Address %s != %s\n", pdst, addr2_Str);
4581
4582 /* Test an zero suffixed IPV6 address */
4583 memcpy(in6.s6_addr, addr3_Num, sizeof(addr3_Num));
4584 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
4585 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4586 ok(!strcmp(pdst, addr3_Str),"Address %s != %s\n", pdst, addr3_Str);
4587
4588 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
4589 memcpy(in6.s6_addr, addr4_Num, sizeof(addr4_Num));
4590 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, sizeof(dst6));
4591 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4592 ok(!strcmp(pdst, addr4_Str),"Address %s != %s\n", pdst, addr4_Str);
4593
4594 /* Test invalid parm conditions */
4595 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
4596
4597 /* Test Null destination */
4598 pdst = NULL;
4599 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, NULL, sizeof(dst6));
4600 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4601 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4602 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4603
4604 /* Test zero length passed */
4605 WSASetLastError(0);
4606 pdst = NULL;
4607 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 0);
4608 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4609 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4610 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4611
4612 /* Test length one shorter than the address length */
4613 WSASetLastError(0);
4614 pdst = NULL;
4615 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 16);
4616 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4617 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4618 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4619
4620 /* Test longer length is ok */
4621 WSASetLastError(0);
4622 pdst = NULL;
4623 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 18);
4624 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
4625 }
4626 static void test_inet_pton(void)
4627 {
4628 struct TEST_DATA
4629 {
4630 int family, ret;
4631 DWORD err;
4632 const char *printable, *collapsed, *raw_data;
4633 } tests[] = {
4634 {AF_UNSPEC, -1, WSAEFAULT, /* Test 0 */
4635 NULL, NULL, NULL},
4636 {AF_INET, -1, WSAEFAULT,
4637 NULL, NULL, NULL},
4638 {AF_INET6, -1, WSAEFAULT,
4639 NULL, NULL, NULL},
4640 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4641 "127.0.0.1", NULL, NULL},
4642 {AF_INET, 1, 0,
4643 "127.0.0.1", "127.0.0.1",
4644 "\x7f\x00\x00\x01"},
4645 {AF_INET6, 0, 0,
4646 "127.0.0.1", "127.0.0.1", NULL},
4647 {AF_INET, 0, 0,
4648 "::1/128", NULL, NULL},
4649 {AF_INET6, 0, 0,
4650 "::1/128", NULL, NULL},
4651 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4652 "broken", NULL, NULL},
4653 {AF_INET, 0, 0,
4654 "broken", NULL, NULL},
4655 {AF_INET6, 0, 0, /* Test 10 */
4656 "broken", NULL, NULL},
4657 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4658 "177.32.45.20", NULL, NULL},
4659 {AF_INET, 1, 0,
4660 "177.32.45.20", "177.32.45.20",
4661 "\xb1\x20\x2d\x14"},
4662 {AF_INET6, 0, 0,
4663 "177.32.45.20", NULL, NULL},
4664 {AF_INET, 0, 0,
4665 "2607:f0d0:1002:51::4", NULL, NULL},
4666 {AF_INET6, 1, 0,
4667 "2607:f0d0:1002:51::4", "2607:f0d0:1002:51::4",
4668 "\x26\x07\xf0\xd0\x10\x02\x00\x51\x00\x00\x00\x00\x00\x00\x00\x04"},
4669 {AF_INET, 0, 0,
4670 "::177.32.45.20", NULL, NULL},
4671 {AF_INET6, 1, 0,
4672 "::177.32.45.20", "::177.32.45.20",
4673 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x20\x2d\x14"},
4674 {AF_INET, 0, 0,
4675 "fe80::0202:b3ff:fe1e:8329", NULL, NULL},
4676 {AF_INET6, 1, 0,
4677 "fe80::0202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
4678 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
4679 {AF_INET6, 1, 0, /* Test 20 */
4680 "fe80::202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
4681 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
4682 {AF_INET, 0, 0,
4683 "a", NULL, NULL},
4684 {AF_INET, 0, 0,
4685 "a.b", NULL, NULL},
4686 {AF_INET, 0, 0,
4687 "a.b.c", NULL, NULL},
4688 {AF_INET, 0, 0,
4689 "a.b.c.d", NULL, NULL},
4690 {AF_INET6, 1, 0,
4691 "2001:cdba:0000:0000:0000:0000:3257:9652", "2001:cdba::3257:9652",
4692 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
4693 {AF_INET6, 1, 0,
4694 "2001:cdba::3257:9652", "2001:cdba::3257:9652",
4695 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
4696 {AF_INET6, 1, 0,
4697 "2001:cdba:0:0:0:0:3257:9652", "2001:cdba::3257:9652",
4698 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"}
4699 };
4700 int i, ret;
4701 DWORD err;
4702 char buffer[64],str[64];
4703 WCHAR printableW[64];
4704 const char *ptr;
4705
4706 /* InetNtop and InetPton became available in Vista and Win2008 */
4707 if (!pInetNtop || !pInetPtonA || !pInetPtonW)
4708 {
4709 win_skip("InetNtop and/or InetPton not present, not executing tests\n");
4710 return;
4711 }
4712
4713 for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
4714 {
4715 WSASetLastError(0xdeadbeef);
4716 ret = pInetPtonA(tests[i].family, tests[i].printable, buffer);
4717 ok (ret == tests[i].ret, "Test [%d]: Expected %d, got %d\n", i, tests[i].ret, ret);
4718 if (tests[i].ret == -1)
4719 {
4720 err = WSAGetLastError();
4721 ok (tests[i].err == err, "Test [%d]: Expected 0x%x, got 0x%x\n", i, tests[i].err, err);
4722 }
4723 if (tests[i].ret != 1) continue;
4724 ok (memcmp(buffer, tests[i].raw_data,
4725 tests[i].family == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr)) == 0,
4726 "Test [%d]: Expected binary data differs\n", i);
4727
4728 /* Test the result from Pton with Ntop */
4729 strcpy (str, "deadbeef");
4730 ptr = pInetNtop(tests[i].family, buffer, str, sizeof(str));
4731 ok (ptr != NULL, "Test [%d]: Failed with NULL\n", i);
4732 ok (ptr == str, "Test [%d]: Pointers differ (%p != %p)\n", i, ptr, str);
4733 if (!ptr) continue;
4734 ok (strcmp(ptr, tests[i].collapsed) == 0, "Test [%d]: Expected '%s', got '%s'\n",
4735 i, tests[i].collapsed, ptr);
4736 }
4737
4738 for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
4739 {
4740 if (tests[i].printable)
4741 MultiByteToWideChar(CP_ACP, 0, tests[i].printable, -1, printableW,
4742 sizeof(printableW) / sizeof(printableW[0]));
4743 WSASetLastError(0xdeadbeef);
4744 ret = pInetPtonW(tests[i].family, tests[i].printable ? printableW : NULL, buffer);
4745 ok(ret == tests[i].ret, "Test [%d]: Expected %d, got %d\n", i, tests[i].ret, ret);
4746 if (tests[i].ret == -1)
4747 {
4748 err = WSAGetLastError();
4749 ok(tests[i].err == err, "Test [%d]: Expected 0x%x, got 0x%x\n", i, tests[i].err, err);
4750 }
4751 if (tests[i].ret != 1) continue;
4752 ok(memcmp(buffer, tests[i].raw_data,
4753 tests[i].family == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr)) == 0,
4754 "Test [%d]: Expected binary data differs\n", i);
4755 }
4756 }
4757
4758 static void test_ioctlsocket(void)
4759 {
4760 SOCKET sock, src, dst;
4761 struct tcp_keepalive kalive;
4762 int ret, optval;
4763 static const LONG cmds[] = {FIONBIO, FIONREAD, SIOCATMARK};
4764 UINT i, bytes_rec;
4765 char data;
4766 WSABUF bufs;
4767 u_long arg = 0;
4768
4769 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4770 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
4771 if(sock == INVALID_SOCKET)
4772 {
4773 skip("Can't continue without a socket.\n");
4774 return;
4775 }
4776
4777 for(i = 0; i < sizeof(cmds)/sizeof(cmds[0]); i++)
4778 {
4779 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
4780 ret = ioctlsocket(sock, cmds[i], (u_long *)1);
4781 ok(ret == SOCKET_ERROR, "ioctlsocket succeeded unexpectedly\n");
4782 ret = WSAGetLastError();
4783 ok(ret == WSAEFAULT, "expected WSAEFAULT, got %d instead\n", ret);
4784 }
4785
4786 /* A fresh and not connected socket has no urgent data, this test shows
4787 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
4788
4789 ret = ioctlsocket(sock, SIOCATMARK, &arg);
4790 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
4791 ok(arg, "SIOCATMARK expected a non-zero value\n");
4792
4793 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
4794 optval = 1;
4795 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
4796 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
4797 arg = 0;
4798 ret = ioctlsocket(sock, SIOCATMARK, &arg);
4799 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
4800 ok(arg, "SIOCATMARK expected a non-zero value\n");
4801
4802 /* disable SO_OOBINLINE and get the same old behavior */
4803 optval = 0;
4804 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
4805 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
4806 arg = 0;
4807 ret = ioctlsocket(sock, SIOCATMARK, &arg);
4808 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
4809 ok(arg, "SIOCATMARK expected a non-zero value\n");
4810
4811 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &arg, 0, NULL, 0, &arg, NULL, NULL);
4812 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4813 ret = WSAGetLastError();
4814 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
4815
4816 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, NULL, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4817 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4818 ret = WSAGetLastError();
4819 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
4820
4821 /* broken used to catch W95, W98, NT4 */
4822 make_keepalive(kalive, 0, 0, 0);
4823 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4824 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4825
4826 make_keepalive(kalive, 1, 0, 0);
4827 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4828 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4829
4830 make_keepalive(kalive, 1, 1000, 1000);
4831 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4832 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4833
4834 make_keepalive(kalive, 1, 10000, 10000);
4835 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4836 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4837
4838 make_keepalive(kalive, 1, 100, 100);
4839 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4840 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4841
4842 make_keepalive(kalive, 0, 100, 100);
4843 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4844 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4845
4846 closesocket(sock);
4847
4848 if (tcp_socketpair(&src, &dst) != 0)
4849 {
4850 ok(0, "creating socket pair failed, skipping test\n");
4851 return;
4852 }
4853
4854 /* test FIONREAD on TCP sockets */
4855 optval = 0xdeadbeef;
4856 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
4857 ok(ret == 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
4858 ok(optval == 0, "FIONREAD should have returned 0 bytes, got %d instead\n", optval);
4859
4860 optval = 0xdeadbeef;
4861 ok(send(src, "TEST", 4, 0) == 4, "failed to send test data\n");
4862 Sleep(100);
4863 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
4864 ok(ret == 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
4865 ok(optval == 4, "FIONREAD should have returned 4 bytes, got %d instead\n", optval);
4866
4867 /* trying to read from an OOB inlined socket with MSG_OOB results in WSAEINVAL */
4868 set_blocking(dst, FALSE);
4869 i = MSG_OOB;
4870 SetLastError(0xdeadbeef);
4871 ret = recv(dst, &data, 1, i);
4872 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4873 ret = GetLastError();
4874 ok(ret == WSAEWOULDBLOCK, "expected 10035, got %d\n", ret);
4875 bufs.len = sizeof(char);
4876 bufs.buf = &data;
4877 ret = WSARecv(dst, &bufs, 1, &bytes_rec, &i, NULL, NULL);
4878 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4879 ret = GetLastError();
4880 ok(ret == WSAEWOULDBLOCK, "expected 10035, got %d\n", ret);
4881 optval = 1;
4882 ret = setsockopt(dst, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
4883 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
4884 i = MSG_OOB;
4885 SetLastError(0xdeadbeef);
4886 ret = recv(dst, &data, 1, i);
4887 if (ret == SOCKET_ERROR)
4888 {
4889 ret = GetLastError();
4890 ok(ret == WSAEINVAL, "expected 10022, got %d\n", ret);
4891 bufs.len = sizeof(char);
4892 bufs.buf = &data;
4893 ret = WSARecv(dst, &bufs, 1, &bytes_rec, &i, NULL, NULL);
4894 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4895 ret = GetLastError();
4896 ok(ret == WSAEINVAL, "expected 10022, got %d\n", ret);
4897 }
4898 else ok(broken(ret == 1) /* <= NT4 */, "expected error, got 1\n");
4899
4900 closesocket(dst);
4901 optval = 0xdeadbeef;
4902 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
4903 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4904 ok(optval == 0xdeadbeef, "FIONREAD should not have changed last error, got %d instead\n", optval);
4905 closesocket(src);
4906 }
4907
4908 static BOOL drain_pause = FALSE;
4909 static DWORD WINAPI drain_socket_thread(LPVOID arg)
4910 {
4911 char buffer[1024];
4912 SOCKET sock = *(SOCKET*)arg;
4913 int ret;
4914
4915 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
4916 {
4917 if (ret < 0)
4918 {
4919 if (WSAGetLastError() == WSAEWOULDBLOCK)
4920 {
4921 fd_set readset;
4922 FD_ZERO(&readset);
4923 FD_SET(sock, &readset);
4924 select(sock+1, &readset, NULL, NULL, NULL);
4925 while (drain_pause)
4926 Sleep(100);
4927 }
4928 else
4929 break;
4930 }
4931 }
4932 return 0;
4933 }
4934
4935 static void test_send(void)
4936 {
4937 SOCKET src = INVALID_SOCKET;
4938 SOCKET dst = INVALID_SOCKET;
4939 HANDLE hThread = NULL;
4940 const int buflen = 1024*1024;
4941 char *buffer = NULL;
4942 int ret, i, zero = 0;
4943 WSABUF buf;
4944 OVERLAPPED ov;
4945 BOOL bret;
4946 DWORD id, bytes_sent, dwRet;
4947
4948 memset(&ov, 0, sizeof(ov));
4949
4950 if (tcp_socketpair(&src, &dst) != 0)
4951 {
4952 ok(0, "creating socket pair failed, skipping test\n");
4953 return;
4954 }
4955
4956 set_blocking(dst, FALSE);
4957 /* force disable buffering so we can get a pending overlapped request */
4958 ret = setsockopt(dst, SOL_SOCKET, SO_SNDBUF, (char *) &zero, sizeof(zero));
4959 ok(!ret, "setsockopt SO_SNDBUF failed: %d - %d\n", ret, GetLastError());
4960
4961 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
4962 if (hThread == NULL)
4963 {
4964 ok(0, "CreateThread failed, error %d\n", GetLastError());
4965 goto end;
4966 }
4967
4968 buffer = HeapAlloc(GetProcessHeap(), 0, buflen);
4969 if (buffer == NULL)
4970 {
4971 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
4972 goto end;
4973 }
4974
4975 /* fill the buffer with some nonsense */
4976 for (i = 0; i < buflen; ++i)
4977 {
4978 buffer[i] = (char) i;
4979 }
4980
4981 ret = send(src, buffer, buflen, 0);
4982 if (ret >= 0)
4983 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
4984 else
4985 ok(0, "send failed, error %d\n", WSAGetLastError());
4986
4987 buf.buf = buffer;
4988 buf.len = buflen;
4989
4990 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
4991 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
4992 if (!ov.hEvent)
4993 goto end;
4994
4995 bytes_sent = 0;
4996 WSASetLastError(12345);
4997 ret = WSASend(dst, &buf, 1, &bytes_sent, 0, &ov, NULL);
4998 ok((ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING) || broken(bytes_sent == buflen),
4999 "Failed to start overlapped send %d - %d - %d/%d\n", ret, WSAGetLastError(), bytes_sent, buflen);
5000
5001 /* don't check for completion yet, we may need to drain the buffer while still sending */
5002 set_blocking(src, FALSE);
5003 for (i = 0; i < buflen; ++i)
5004 {
5005 int j = 0;
5006
5007 ret = recv(src, buffer, 1, 0);
5008 while (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK && j < 100)
5009 {
5010 j++;
5011 Sleep(50);
5012 ret = recv(src, buffer, 1, 0);
5013 }
5014
5015 ok(ret == 1, "Failed to receive data %d - %d (got %d/%d)\n", ret, GetLastError(), i, buflen);
5016 if (ret != 1)
5017 break;
5018
5019 ok(buffer[0] == (char) i, "Received bad data at position %d\n", i);
5020 }
5021
5022 dwRet = WaitForSingleObject(ov.hEvent, 1000);
5023 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5024 if (dwRet == WAIT_OBJECT_0)
5025 {
5026 bret = GetOverlappedResult((HANDLE)dst, &ov, &bytes_sent, FALSE);
5027 ok((bret && bytes_sent == buflen) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5028 "Got %d instead of %d (%d - %d)\n", bytes_sent, buflen, bret, GetLastError());
5029 }
5030
5031 WSASetLastError(12345);
5032 ret = WSASend(INVALID_SOCKET, &buf, 1, NULL, 0, &ov, NULL);
5033 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
5034 "WSASend failed %d - %d\n", ret, WSAGetLastError());
5035
5036 WSASetLastError(12345);
5037 ret = WSASend(dst, &buf, 1, NULL, 0, &ov, NULL);
5038 ok(ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING,
5039 "Failed to start overlapped send %d - %d\n", ret, WSAGetLastError());
5040
5041 end:
5042 if (src != INVALID_SOCKET)
5043 closesocket(src);
5044 if (dst != INVALID_SOCKET)
5045 closesocket(dst);
5046 if (hThread != NULL)
5047 {
5048 dwRet = WaitForSingleObject(hThread, 500);
5049 ok(dwRet == WAIT_OBJECT_0, "failed to wait for thread termination: %d\n", GetLastError());
5050 CloseHandle(hThread);
5051 }
5052 if (ov.hEvent)
5053 CloseHandle(ov.hEvent);
5054 HeapFree(GetProcessHeap(), 0, buffer);
5055 }
5056
5057 typedef struct async_message
5058 {
5059 SOCKET socket;
5060 LPARAM lparam;
5061 struct async_message *next;
5062 } async_message;
5063
5064 static struct async_message *messages_received;
5065
5066 #define WM_SOCKET (WM_USER+100)
5067 static LRESULT CALLBACK ws2_test_WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
5068 {
5069 struct async_message *message;
5070
5071 switch (msg)
5072 {
5073 case WM_SOCKET:
5074 message = HeapAlloc(GetProcessHeap(), 0, sizeof(*message));
5075 message->socket = (SOCKET) wparam;
5076 message->lparam = lparam;
5077 message->next = NULL;
5078
5079 if (messages_received)
5080 {
5081 struct async_message *last = messages_received;
5082 while (last->next) last = last->next;
5083 last->next = message;
5084 }
5085 else
5086 messages_received = message;
5087 return 0;
5088 }
5089
5090 return DefWindowProcA(hwnd, msg, wparam, lparam);
5091 }
5092
5093 static void get_event_details(int event, int *bit, char *name)
5094 {
5095 switch (event)
5096 {
5097 case FD_ACCEPT:
5098 if (bit) *bit = FD_ACCEPT_BIT;
5099 if (name) strcpy(name, "FD_ACCEPT");
5100 break;
5101 case FD_CONNECT:
5102 if (bit) *bit = FD_CONNECT_BIT;
5103 if (name) strcpy(name, "FD_CONNECT");
5104 break;
5105 case FD_READ:
5106 if (bit) *bit = FD_READ_BIT;
5107 if (name) strcpy(name, "FD_READ");
5108 break;
5109 case FD_OOB:
5110 if (bit) *bit = FD_OOB_BIT;
5111 if (name) strcpy(name, "FD_OOB");
5112 break;
5113 case FD_WRITE:
5114 if (bit) *bit = FD_WRITE_BIT;
5115 if (name) strcpy(name, "FD_WRITE");
5116 break;
5117 case FD_CLOSE:
5118 if (bit) *bit = FD_CLOSE_BIT;
5119 if (name) strcpy(name, "FD_CLOSE");
5120 break;
5121 default:
5122 if (bit) *bit = -1;
5123 if (name) sprintf(name, "bad%x", event);
5124 }
5125 }
5126
5127 static const char *dbgstr_event_seq(const LPARAM *seq)
5128 {
5129 static char message[1024];
5130 char name[12];
5131 int len = 1;
5132
5133 message[0] = '[';
5134 message[1] = 0;
5135 while (*seq)
5136 {
5137 get_event_details(WSAGETSELECTEVENT(*seq), NULL, name);
5138 len += sprintf(message + len, "%s(%d) ", name, WSAGETSELECTERROR(*seq));
5139 seq++;
5140 }
5141 if (len > 1) len--;
5142 strcpy( message + len, "]" );
5143 return message;
5144 }
5145
5146 static char *dbgstr_event_seq_result(SOCKET s, WSANETWORKEVENTS *netEvents)
5147 {
5148 static char message[1024];
5149 struct async_message *curr = messages_received;
5150 int index, error, bit = 0;
5151 char name[12];
5152 int len = 1;
5153
5154 message[0] = '[';
5155 message[1] = 0;
5156 while (1)
5157 {
5158 if (netEvents)
5159 {
5160 if (bit >= FD_MAX_EVENTS) break;
5161 if ( !(netEvents->lNetworkEvents & (1 << bit)) )
5162 {
5163 bit++;
5164 continue;
5165 }
5166 get_event_details(1 << bit, &index, name);
5167 error = netEvents->iErrorCode[index];
5168 bit++;
5169 }
5170 else
5171 {
5172 if (!curr) break;
5173 if (curr->socket != s)
5174 {
5175 curr = curr->next;
5176 continue;
5177 }
5178 get_event_details(WSAGETSELECTEVENT(curr->lparam), NULL, name);
5179 error = WSAGETSELECTERROR(curr->lparam);
5180 curr = curr->next;
5181 }
5182
5183 len += sprintf(message + len, "%s(%d) ", name, error);
5184 }
5185 if (len > 1) len--;
5186 strcpy( message + len, "]" );
5187 return message;
5188 }
5189
5190 static void flush_events(SOCKET s, HANDLE hEvent)
5191 {
5192 WSANETWORKEVENTS netEvents;
5193 struct async_message *prev = NULL, *curr = messages_received;
5194 int ret;
5195 DWORD dwRet;
5196
5197 if (hEvent != INVALID_HANDLE_VALUE)
5198 {
5199 dwRet = WaitForSingleObject(hEvent, 100);
5200 if (dwRet == WAIT_OBJECT_0)
5201 {
5202 ret = WSAEnumNetworkEvents(s, hEvent, &netEvents);
5203 if (ret)
5204 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
5205 }
5206 }
5207 else
5208 {
5209 while (curr)
5210 {
5211 if (curr->socket == s)
5212 {
5213 if (prev) prev->next = curr->next;
5214 else messages_received = curr->next;
5215
5216 HeapFree(GetProcessHeap(), 0, curr);
5217
5218 if (prev) curr = prev->next;
5219 else curr = messages_received;
5220 }
5221 else
5222 {
5223 prev = curr;
5224 curr = curr->next;
5225 }
5226 }
5227 }
5228 }
5229
5230 static int match_event_sequence(SOCKET s, WSANETWORKEVENTS *netEvents, const LPARAM *seq)
5231 {
5232 int event, index, error, events;
5233 struct async_message *curr;
5234
5235 if (netEvents)
5236 {
5237 events = netEvents->lNetworkEvents;
5238 while (*seq)
5239 {
5240 event = WSAGETSELECTEVENT(*seq);
5241 error = WSAGETSELECTERROR(*seq);
5242 get_event_details(event, &index, NULL);
5243
5244 if (!(events & event) && index != -1)
5245 return 0;
5246 if (events & event && index != -1)
5247 {
5248 if (netEvents->iErrorCode[index] != error)
5249 return 0;
5250 }
5251 events &= ~event;
5252 seq++;
5253 }
5254 if (events)
5255 return 0;
5256 }
5257 else
5258 {
5259 curr = messages_received;
5260 while (curr)
5261 {
5262 if (curr->socket == s)
5263 {
5264 if (!*seq) return 0;
5265 if (*seq != curr->lparam) return 0;
5266 seq++;
5267 }
5268 curr = curr->next;
5269 }
5270 if (*seq)
5271 return 0;
5272 }
5273 return 1;
5274 }
5275
5276 /* checks for a sequence of events, (order only checked if window is used) */
5277 static void ok_event_sequence(SOCKET s, HANDLE hEvent, const LPARAM *seq, const LPARAM **broken_seqs, int completelyBroken)
5278 {
5279 MSG msg;
5280 WSANETWORKEVENTS events, *netEvents = NULL;
5281 int ret;
5282 DWORD dwRet;
5283
5284 if (hEvent != INVALID_HANDLE_VALUE)
5285 {
5286 netEvents = &events;
5287
5288 dwRet = WaitForSingleObject(hEvent, 200);
5289 if (dwRet == WAIT_OBJECT_0)
5290 {
5291 ret = WSAEnumNetworkEvents(s, hEvent, netEvents);
5292 if (ret)
5293 {
5294 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
5295 return;
5296 }
5297 }
5298 else
5299 memset(netEvents, 0, sizeof(*netEvents));
5300 }
5301 else
5302 {
5303 Sleep(200);
5304 /* Run the message loop a little */
5305 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
5306 {
5307 DispatchMessageA(&msg);
5308 }
5309 }
5310
5311 if (match_event_sequence(s, netEvents, seq))
5312 {
5313 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq));
5314 flush_events(s, hEvent);
5315 return;
5316 }
5317
5318 if (broken_seqs)
5319 {
5320 for (; *broken_seqs; broken_seqs++)
5321 {
5322 if (match_event_sequence(s, netEvents, *broken_seqs))
5323 {
5324 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s, netEvents), dbgstr_event_seq(seq));
5325 flush_events(s, hEvent);
5326 return;
5327 }
5328 }
5329 }
5330
5331 winetest_ok(broken(completelyBroken), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq),
5332 dbgstr_event_seq_result(s, netEvents));
5333 flush_events(s, hEvent);
5334 }
5335
5336 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
5337
5338 static void test_events(int useMessages)
5339 {
5340 SOCKET server = INVALID_SOCKET;
5341 SOCKET src = INVALID_SOCKET, src2 = INVALID_SOCKET;
5342 SOCKET dst = INVALID_SOCKET, dst2 = INVALID_SOCKET;
5343 struct sockaddr_in addr;
5344 HANDLE hThread = NULL;
5345 HANDLE hEvent = INVALID_HANDLE_VALUE, hEvent2 = INVALID_HANDLE_VALUE;
5346 WNDCLASSEXA wndclass;
5347 HWND hWnd = NULL;
5348 char *buffer = NULL;
5349 int bufferSize = 1024*1024;
5350 WSABUF bufs;
5351 OVERLAPPED ov, ov2;
5352 DWORD flags = 0;
5353 DWORD bytesReturned;
5354 DWORD id;
5355 int len;
5356 int ret;
5357 DWORD dwRet;
5358 BOOL bret;
5359 static char szClassName[] = "wstestclass";
5360 const LPARAM *broken_seq[3];
5361 static const LPARAM empty_seq[] = { 0 };
5362 static const LPARAM close_seq[] = { WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
5363 static const LPARAM write_seq[] = { WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5364 static const LPARAM read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0), 0 };
5365 static const LPARAM oob_seq[] = { WSAMAKESELECTREPLY(FD_OOB, 0), 0 };
5366 static const LPARAM connect_seq[] = { WSAMAKESELECTREPLY(FD_CONNECT, 0),
5367 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5368 static const LPARAM read_read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5369 WSAMAKESELECTREPLY(FD_READ, 0), 0 };
5370 static const LPARAM read_write_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5371 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5372 static const LPARAM read_close_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5373 WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
5374
5375 memset(&ov, 0, sizeof(ov));
5376 memset(&ov2, 0, sizeof(ov2));
5377
5378 /* don't use socketpair, we want connection event */
5379 src = socket(AF_INET, SOCK_STREAM, 0);
5380 if (src == INVALID_SOCKET)
5381 {
5382 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5383 goto end;
5384 }
5385
5386 ret = set_blocking(src, TRUE);
5387 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5388
5389 src2 = socket(AF_INET, SOCK_STREAM, 0);
5390 if (src2 == INVALID_SOCKET)
5391 {
5392 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5393 goto end;
5394 }
5395
5396 ret = set_blocking(src2, TRUE);
5397 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5398
5399 len = sizeof(BOOL);
5400 if (getsockopt(src, SOL_SOCKET, SO_OOBINLINE, (void *)&bret, &len) == SOCKET_ERROR)
5401 {
5402 ok(0, "failed to get oobinline status, %d\n", GetLastError());
5403 goto end;
5404 }
5405 ok(bret == FALSE, "OOB not inline\n");
5406
5407 if (useMessages)
5408 {
5409 trace("Event test using messages\n");
5410
5411 wndclass.cbSize = sizeof(wndclass);
5412 wndclass.style = CS_HREDRAW | CS_VREDRAW;
5413 wndclass.lpfnWndProc = ws2_test_WndProc;
5414 wndclass.cbClsExtra = 0;
5415 wndclass.cbWndExtra = 0;
5416 wndclass.hInstance = GetModuleHandleA(NULL);
5417 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
5418 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
5419 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
5420 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
5421 wndclass.lpszClassName = szClassName;
5422 wndclass.lpszMenuName = NULL;
5423 RegisterClassExA(&wndclass);
5424
5425 hWnd = CreateWindowA(szClassName, "WS2Test", WS_OVERLAPPEDWINDOW,
5426 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
5427 if (!hWnd)
5428 {
5429 ok(0, "failed to create window: %d\n", GetLastError());
5430 return;
5431 }
5432
5433 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5434 if (ret)
5435 {
5436 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5437 goto end;
5438 }
5439
5440 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5441 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5442
5443 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5444 if (ret)
5445 {
5446 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5447 goto end;
5448 }
5449
5450 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5451 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5452 }
5453 else
5454 {
5455 trace("Event test using events\n");
5456
5457 hEvent = WSACreateEvent();
5458 if (hEvent == INVALID_HANDLE_VALUE)
5459 {
5460 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5461 goto end;
5462 }
5463
5464 hEvent2 = WSACreateEvent();
5465 if (hEvent2 == INVALID_HANDLE_VALUE)
5466 {
5467 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5468 goto end;
5469 }
5470
5471 ret = WSAEventSelect(src, hEvent, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5472 if (ret)
5473 {
5474 ok(0, "WSAEventSelect failed, error %d\n", ret);
5475 goto end;
5476 }
5477
5478 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5479 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5480
5481 ret = WSAEventSelect(src2, hEvent2, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5482 if (ret)
5483 {
5484 ok(0, "WSAEventSelect failed, error %d\n", ret);
5485 goto end;
5486 }
5487
5488 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5489 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5490 }
5491
5492 server = socket(AF_INET, SOCK_STREAM, 0);
5493 if (server == INVALID_SOCKET)
5494 {
5495 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5496 goto end;
5497 }
5498
5499 memset(&addr, 0, sizeof(addr));
5500 addr.sin_family = AF_INET;
5501 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
5502 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
5503 if (ret != 0)
5504 {
5505 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5506 goto end;
5507 }
5508
5509 len = sizeof(addr);
5510 ret = getsockname(server, (struct sockaddr*)&addr, &len);
5511 if (ret != 0)
5512 {
5513 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5514 goto end;
5515 }
5516
5517 ret = listen(server, 2);
5518 if (ret != 0)
5519 {
5520 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5521 goto end;
5522 }
5523
5524 ret = connect(src, (struct sockaddr*)&addr, sizeof(addr));
5525 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
5526 {
5527 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5528 goto end;
5529 }
5530
5531 ret = connect(src2, (struct sockaddr*)&addr, sizeof(addr));
5532 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
5533 {
5534 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5535 goto end;
5536 }
5537
5538 len = sizeof(addr);
5539 dst = accept(server, (struct sockaddr*)&addr, &len);
5540 if (dst == INVALID_SOCKET)
5541 {
5542 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5543 goto end;
5544 }
5545
5546 len = sizeof(addr);
5547 dst2 = accept(server, (struct sockaddr*)&addr, &len);
5548 if (dst2 == INVALID_SOCKET)
5549 {
5550 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5551 goto end;
5552 }
5553
5554 closesocket(server);
5555 server = INVALID_SOCKET;
5556
5557 /* On Windows it seems when a non-blocking socket sends to a
5558 blocking socket on the same host, the send() is BLOCKING,
5559 so make both sockets non-blocking. src is already non-blocking
5560 from the async select */
5561
5562 if (set_blocking(dst, FALSE))
5563 {
5564 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
5565 goto end;
5566 }
5567
5568 buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufferSize);
5569 if (buffer == NULL)
5570 {
5571 ok(0, "could not allocate memory for test\n");
5572 goto end;
5573 }
5574
5575 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5576 if (ov.hEvent == NULL)
5577 {
5578 ok(0, "could not create event object, errno = %d\n", GetLastError());
5579 goto end;
5580 }
5581
5582 ov2.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5583 if (ov2.hEvent == NULL)
5584 {
5585 ok(0, "could not create event object, errno = %d\n", GetLastError());
5586 goto end;
5587 }
5588
5589 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
5590 ok_event_seq(src, hEvent, connect_seq, NULL, 1);
5591 ok_event_seq(src2, hEvent2, connect_seq, NULL, 1);
5592 /* broken on all windows - FD_CONNECT error is garbage */
5593
5594 /* Test simple send/recv */
5595 SetLastError(0xdeadbeef);
5596 ret = send(dst, buffer, 100, 0);
5597 ok(ret == 100, "Failed to send buffer %d err %d\n", ret, GetLastError());
5598 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5599 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5600
5601 SetLastError(0xdeadbeef);
5602 ret = recv(src, buffer, 1, MSG_PEEK);
5603 ok(ret == 1, "Failed to peek at recv buffer %d err %d\n", ret, GetLastError());
5604 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5605 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5606
5607 SetLastError(0xdeadbeef);
5608 ret = recv(src, buffer, 50, 0);
5609 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5610 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5611 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5612
5613 ret = recv(src, buffer, 50, 0);
5614 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5615 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5616
5617 /* fun fact - events are re-enabled even on failure, but only for messages */
5618 ret = send(dst, "1", 1, 0);
5619 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5620 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5621
5622 ret = recv(src, buffer, -1, 0);
5623 ok(ret == SOCKET_ERROR && (GetLastError() == WSAEFAULT || GetLastError() == WSAENOBUFS),
5624 "Failed to recv buffer %d err %d\n", ret, GetLastError());
5625 if (useMessages)
5626 {
5627 broken_seq[0] = empty_seq; /* win9x */
5628 broken_seq[1] = NULL;
5629 todo_wine ok_event_seq(src, hEvent, read_seq, broken_seq, 0);
5630 }
5631 else
5632 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5633
5634 SetLastError(0xdeadbeef);
5635 ret = recv(src, buffer, 1, 0);
5636 ok(ret == 1, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5637 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5638 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5639
5640 /* Interaction with overlapped */
5641 bufs.len = sizeof(char);
5642 bufs.buf = buffer;
5643 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
5644 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
5645 "WSARecv failed - %d error %d\n", ret, GetLastError());
5646
5647 bufs.len = sizeof(char);
5648 bufs.buf = buffer+1;
5649 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov2, NULL);
5650 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
5651 "WSARecv failed - %d error %d\n", ret, GetLastError());
5652
5653 ret = send(dst, "12", 2, 0);
5654 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
5655 broken_seq[0] = read_read_seq; /* win9x */
5656 broken_seq[1] = NULL;
5657 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
5658
5659 dwRet = WaitForSingleObject(ov.hEvent, 100);
5660 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5661 if (dwRet == WAIT_OBJECT_0)
5662 {
5663 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
5664 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5665 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
5666 ok(buffer[0] == '1', "Got %c instead of 1\n", buffer[0]);
5667 }
5668
5669 dwRet = WaitForSingleObject(ov2.hEvent, 100);
5670 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5671 if (dwRet == WAIT_OBJECT_0)
5672 {
5673 bret = GetOverlappedResult((HANDLE)src, &ov2, &bytesReturned, FALSE);
5674 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5675 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
5676 ok(buffer[1] == '2', "Got %c instead of 2\n", buffer[1]);
5677 }
5678
5679 SetLastError(0xdeadbeef);
5680 ret = send(dst, "1", 1, 0);
5681 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5682 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5683 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5684
5685 ret = recv(src, buffer, 1, 0);
5686 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5687 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5688
5689 /* Notifications are delivered as soon as possible, blocked only on
5690 * async requests on the same type */
5691 bufs.len = sizeof(char);
5692 bufs.buf = buffer;
5693 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
5694 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
5695 "WSARecv failed - %d error %d\n", ret, GetLastError());
5696
5697 if (0) {
5698 ret = send(dst, "1", 1, MSG_OOB);
5699 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5700 ok_event_seq(src, hEvent, oob_seq, NULL, 0);
5701 }
5702
5703 dwRet = WaitForSingleObject(ov.hEvent, 100);
5704 ok(dwRet == WAIT_TIMEOUT, "OOB message activated read?: %d - %d\n", dwRet, GetLastError());
5705
5706 ret = send(dst, "2", 1, 0);
5707 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5708 broken_seq[0] = read_seq; /* win98 */
5709 broken_seq[1] = NULL;
5710 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
5711
5712 dwRet = WaitForSingleObject(ov.hEvent, 100);
5713 ok(dwRet == WAIT_OBJECT_0 || broken(dwRet == WAIT_TIMEOUT),
5714 "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5715 if (dwRet == WAIT_OBJECT_0)
5716 {
5717 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
5718 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5719 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
5720 ok(buffer[0] == '2', "Got %c instead of 2\n", buffer[0]);
5721 }
5722 else if (dwRet == WAIT_TIMEOUT)
5723 {
5724 /* this happens on win98. We get an FD_READ later on the next test */
5725 CancelIo((HANDLE) src);
5726 }
5727
5728 if (0) {
5729 ret = recv(src, buffer, 1, MSG_OOB);
5730 todo_wine ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5731 /* We get OOB notification, but no data on wine */
5732 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5733 }
5734
5735 /* Flood the send queue */
5736 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
5737 if (hThread == NULL)
5738 {
5739 ok(0, "CreateThread failed, error %d\n", GetLastError());
5740 goto end;
5741 }
5742
5743 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
5744 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5745
5746 /* Now if we send a ton of data and the 'server' does not drain it fast
5747 * enough (set drain_pause to be sure), the socket send buffer will only
5748 * take some of it, and we will get a short write. This will trigger
5749 * another FD_WRITE event as soon as data is sent and more space becomes
5750 * available, but not any earlier. */
5751 drain_pause = TRUE;
5752 do
5753 {
5754 ret = send(src, buffer, bufferSize, 0);
5755 } while (ret == bufferSize);
5756 drain_pause = FALSE;
5757 if (ret >= 0 || WSAGetLastError() == WSAEWOULDBLOCK)
5758 {
5759 Sleep(400); /* win9x */
5760 broken_seq[0] = read_write_seq;
5761 broken_seq[1] = NULL;
5762 ok_event_seq(src, hEvent, write_seq, broken_seq, 0);
5763 }
5764 else
5765 {
5766 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
5767 }
5768
5769 /* Test how FD_CLOSE is handled */
5770 ret = send(dst, "12", 2, 0);
5771 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
5772
5773 /* Wait a little and let the send complete */
5774 Sleep(100);
5775 closesocket(dst);
5776 dst = INVALID_SOCKET;
5777 Sleep(100);
5778
5779 /* We can never implement this in wine, best we can hope for is
5780 sending FD_CLOSE after the reads complete */
5781 broken_seq[0] = read_seq; /* win9x */
5782 broken_seq[1] = NULL;
5783 todo_wine ok_event_seq(src, hEvent, read_close_seq, broken_seq, 0);
5784
5785 ret = recv(src, buffer, 1, 0);
5786 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5787 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5788
5789 ret = recv(src, buffer, 1, 0);
5790 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5791 /* want it? it's here, but you can't have it */
5792 broken_seq[0] = close_seq; /* win9x */
5793 broken_seq[1] = NULL;
5794 todo_wine ok_event_seq(src, hEvent, empty_seq, /* wine sends FD_CLOSE here */
5795 broken_seq, 0);
5796
5797 /* Test how FD_CLOSE is handled */
5798 ret = send(dst2, "12", 2, 0);
5799 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
5800
5801 Sleep(200);
5802 shutdown(dst2, SD_SEND);
5803 Sleep(200);
5804
5805 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
5806 regressions, don't mark them as todo_wine, and mark windows as broken */
5807 broken_seq[0] = read_close_seq;
5808 broken_seq[1] = close_seq;
5809 broken_seq[2] = NULL;
5810 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
5811
5812 ret = recv(src2, buffer, 1, 0);
5813 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5814 broken_seq[0] = close_seq; /* win98 */
5815 broken_seq[1] = NULL;
5816 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
5817
5818 ret = recv(src2, buffer, 1, 0);
5819 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5820 broken_seq[0] = empty_seq;
5821 broken_seq[1] = NULL;
5822 ok_event_seq(src2, hEvent2, close_seq, broken_seq, 0);
5823
5824 ret = send(src2, "1", 1, 0);
5825 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
5826 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
5827
5828 ret = send(src2, "1", 1, 0);
5829 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
5830 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
5831
5832 if (useMessages)
5833 {
5834 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, 0);
5835 if (ret)
5836 {
5837 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5838 goto end;
5839 }
5840
5841 ret = set_blocking(src, TRUE);
5842 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5843
5844 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, 0);
5845 if (ret)
5846 {
5847 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5848 goto end;
5849 }
5850
5851 ret = set_blocking(src2, TRUE);
5852 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5853 }
5854 else
5855 {
5856 ret = WSAEventSelect(src, hEvent2, 0);
5857 if (ret)
5858 {
5859 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5860 goto end;
5861 }
5862
5863 ret = set_blocking(src, TRUE);
5864 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5865
5866 ret = WSAEventSelect(src2, hEvent2, 0);
5867 if (ret)
5868 {
5869 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5870 goto end;
5871 }
5872
5873 ret = set_blocking(src2, TRUE);
5874 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5875 }
5876
5877 end:
5878 if (src != INVALID_SOCKET)
5879 {
5880 flush_events(src, hEvent);
5881 closesocket(src);
5882 }
5883 if (src2 != INVALID_SOCKET)
5884 {
5885 flush_events(src2, hEvent2);
5886 closesocket(src2);
5887 }
5888 HeapFree(GetProcessHeap(), 0, buffer);
5889 if (server != INVALID_SOCKET)
5890 closesocket(server);
5891 if (dst != INVALID_SOCKET)
5892 closesocket(dst);
5893 if (dst2 != INVALID_SOCKET)
5894 closesocket(dst2);
5895 if (hThread != NULL)
5896 CloseHandle(hThread);
5897 if (hWnd != NULL)
5898 DestroyWindow(hWnd);
5899 if (hEvent != NULL)
5900 CloseHandle(hEvent);
5901 if (hEvent2 != NULL)
5902 CloseHandle(hEvent2);
5903 if (ov.hEvent != NULL)
5904 CloseHandle(ov.hEvent);
5905 if (ov2.hEvent != NULL)
5906 CloseHandle(ov2.hEvent);
5907 }
5908
5909 static void test_ipv6only(void)
5910 {
5911 SOCKET v4 = INVALID_SOCKET,
5912 v6 = INVALID_SOCKET;
5913 struct sockaddr_in sin4;
5914 struct sockaddr_in6 sin6;
5915 int ret;
5916
5917 memset(&sin4, 0, sizeof(sin4));
5918 sin4.sin_family = AF_INET;
5919 sin4.sin_port = htons(SERVERPORT);
5920
5921 memset(&sin6, 0, sizeof(sin6));
5922 sin6.sin6_family = AF_INET6;
5923 sin6.sin6_port = htons(SERVERPORT);
5924
5925 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
5926 if (v6 == INVALID_SOCKET) {
5927 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
5928 WSAGetLastError(), WSAEAFNOSUPPORT);
5929 goto end;
5930 }
5931 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
5932 if (ret) {
5933 skip("Could not bind IPv6 address (LastError: %d).\n",
5934 WSAGetLastError());
5935 goto end;
5936 }
5937
5938 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5939 if (v4 == INVALID_SOCKET) {
5940 skip("Could not create IPv4 socket (LastError: %d).\n",
5941 WSAGetLastError());
5942 goto end;
5943 }
5944 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
5945 ok(!ret, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
5946 WSAGetLastError(), WSAEADDRINUSE);
5947
5948 end:
5949 if (v4 != INVALID_SOCKET)
5950 closesocket(v4);
5951 if (v6 != INVALID_SOCKET)
5952 closesocket(v6);
5953 }
5954
5955 static void test_WSASendMsg(void)
5956 {
5957 SOCKET sock, dst;
5958 struct sockaddr_in sendaddr, sockaddr;
5959 GUID WSASendMsg_GUID = WSAID_WSASENDMSG;
5960 LPFN_WSASENDMSG pWSASendMsg = NULL;
5961 char teststr[12] = "hello world", buffer[32];
5962 WSABUF iovec[2];
5963 WSAMSG msg;
5964 DWORD bytesSent, err;
5965 int ret, addrlen;
5966
5967 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
5968
5969 sock = socket(AF_INET, SOCK_DGRAM, 0);
5970 ok(sock != INVALID_SOCKET, "socket() failed\n");
5971
5972 /* Obtain the WSASendMsg function */
5973 WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsg_GUID, sizeof(WSASendMsg_GUID),
5974 &pWSASendMsg, sizeof(pWSASendMsg), &err, NULL, NULL);
5975 if (!pWSASendMsg)
5976 {
5977 closesocket(sock);
5978 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
5979 return;
5980 }
5981
5982 /* fake address for now */
5983 sendaddr.sin_family = AF_INET;
5984 sendaddr.sin_port = htons(139);
5985 sendaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5986
5987 memset(&msg, 0, sizeof(msg));
5988 iovec[0].buf = teststr;
5989 iovec[0].len = sizeof(teststr);
5990 iovec[1].buf = teststr;
5991 iovec[1].len = sizeof(teststr) / 2;
5992 msg.name = (struct sockaddr *) &sendaddr;
5993 msg.namelen = sizeof(sendaddr);
5994 msg.lpBuffers = iovec;
5995 msg.dwBufferCount = 1; /* send only one buffer for now */
5996
5997 WSASetLastError(0xdeadbeef);
5998 ret = pWSASendMsg(INVALID_SOCKET, &msg, 0, NULL, NULL, NULL);
5999 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6000 err = WSAGetLastError();
6001 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
6002
6003 WSASetLastError(0xdeadbeef);
6004 ret = pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL);
6005 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6006 err = WSAGetLastError();
6007 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6008
6009 WSASetLastError(0xdeadbeef);
6010 ret = pWSASendMsg(sock, NULL, 0, &bytesSent, NULL, NULL);
6011 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6012 err = WSAGetLastError();
6013 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6014
6015 WSASetLastError(0xdeadbeef);
6016 ret = pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL);
6017 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6018 err = WSAGetLastError();
6019 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
6020
6021 closesocket(sock);
6022
6023 sock = socket(AF_INET, SOCK_DGRAM, 0);
6024 ok(sock != INVALID_SOCKET, "socket() failed\n");
6025
6026 dst = socket(AF_INET, SOCK_DGRAM, 0);
6027 ok(dst != INVALID_SOCKET, "socket() failed\n");
6028
6029 memset(&sockaddr, 0, sizeof(sockaddr));
6030 sockaddr.sin_family = AF_INET;
6031 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6032 ok(!bind(dst, (struct sockaddr*)&sockaddr, sizeof(sockaddr)),
6033 "bind should have worked\n");
6034
6035 /* read address to find out the port number to be used in send */
6036 memset(&sendaddr, 0, sizeof(sendaddr));
6037 addrlen = sizeof(sendaddr);
6038 ok(!getsockname(dst, (struct sockaddr *) &sendaddr, &addrlen),
6039 "getsockname should have worked\n");
6040 ok(sendaddr.sin_port, "socket port should be != 0\n");
6041
6042 /* ensure the sending socket is not bound */
6043 WSASetLastError(0xdeadbeef);
6044 addrlen = sizeof(sockaddr);
6045 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
6046 ok(ret == SOCKET_ERROR, "getsockname should have failed\n");
6047 err = WSAGetLastError();
6048 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
6049
6050 set_blocking(sock, TRUE);
6051
6052 bytesSent = 0;
6053 SetLastError(0xdeadbeef);
6054 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6055 ok(!ret, "WSASendMsg should have worked\n");
6056 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6057 "Expected 0, got %d\n", GetLastError());
6058 ok(bytesSent == iovec[0].len, "incorret bytes sent, expected %d, sent %d\n",
6059 iovec[0].len, bytesSent);
6060
6061 /* receive data */
6062 addrlen = sizeof(sockaddr);
6063 memset(buffer, 0, sizeof(buffer));
6064 SetLastError(0xdeadbeef);
6065 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
6066 ok(ret == bytesSent, "got %d, expected %d\n",
6067 ret, bytesSent);
6068 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6069
6070 /* A successful call to WSASendMsg must have bound the socket */
6071 addrlen = sizeof(sockaddr);
6072 sockaddr.sin_port = 0;
6073 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6074 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
6075 ok(!ret, "getsockname should have worked\n");
6076 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
6077 inet_ntoa(sockaddr.sin_addr));
6078 ok(sockaddr.sin_port, "sin_port should be != 0\n");
6079
6080 msg.dwBufferCount = 2; /* send both buffers */
6081
6082 bytesSent = 0;
6083 SetLastError(0xdeadbeef);
6084 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6085 ok(!ret, "WSASendMsg should have worked\n");
6086 ok(bytesSent == iovec[0].len + iovec[1].len, "incorret bytes sent, expected %d, sent %d\n",
6087 iovec[0].len + iovec[1].len, bytesSent);
6088 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6089 "Expected 0, got %d\n", GetLastError());
6090
6091 /* receive data */
6092 addrlen = sizeof(sockaddr);
6093 memset(buffer, 0, sizeof(buffer));
6094 SetLastError(0xdeadbeef);
6095 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
6096 ok(ret == bytesSent, "got %d, expected %d\n",
6097 ret, bytesSent);
6098 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6099
6100 closesocket(sock);
6101 closesocket(dst);
6102
6103 /* a bad call to WSASendMsg will also bind the socket */
6104 addrlen = sizeof(sockaddr);
6105 sockaddr.sin_port = 0;
6106 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
6107 sock = socket(AF_INET, SOCK_DGRAM, 0);
6108 ok(sock != INVALID_SOCKET, "socket() failed\n");
6109 ok(pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
6110 todo_wine {
6111 ok(!getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have worked\n");
6112 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
6113 inet_ntoa(sockaddr.sin_addr));
6114 ok(sockaddr.sin_port, "sin_port should be > 0\n");
6115 }
6116 closesocket(sock);
6117
6118 /* a bad call without msg parameter will not trigger the auto-bind */
6119 sock = socket(AF_INET, SOCK_DGRAM, 0);
6120 ok(sock != INVALID_SOCKET, "socket() failed\n");
6121 ok(pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
6122 ok(getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have failed\n");
6123 err = WSAGetLastError();
6124 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
6125 closesocket(sock);
6126
6127 /* SOCK_STREAM sockets are not supported */
6128 bytesSent = 0;
6129 sock = socket(AF_INET, SOCK_STREAM, 0);
6130 ok(sock != INVALID_SOCKET, "socket() failed\n");
6131 SetLastError(0xdeadbeef);
6132 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
6133 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
6134 err = WSAGetLastError();
6135 todo_wine
6136 ok(err == WSAEINVAL, "expected 10014, got %d instead\n", err);
6137 closesocket(sock);
6138 }
6139
6140 static void test_WSASendTo(void)
6141 {
6142 SOCKET s;
6143 struct sockaddr_in addr;
6144 char buf[12] = "hello world";
6145 WSABUF data_buf;
6146 DWORD bytesSent;
6147 int ret;
6148
6149 addr.sin_family = AF_INET;
6150 addr.sin_port = htons(139);
6151 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6152 data_buf.len = sizeof(buf);
6153 data_buf.buf = buf;
6154
6155 if( (s = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
6156 ok(0, "socket() failed error: %d\n", WSAGetLastError());
6157 return;
6158 }
6159
6160 WSASetLastError(12345);
6161 ret = WSASendTo(INVALID_SOCKET, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
6162 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
6163 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
6164
6165 WSASetLastError(12345);
6166 ret = WSASendTo(s, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
6167 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
6168 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
6169
6170 WSASetLastError(12345);
6171 if(WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL)) {
6172 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
6173 return;
6174 }
6175 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
6176 "a successful call to WSASendTo()\n");
6177 }
6178
6179 static DWORD WINAPI recv_thread(LPVOID arg)
6180 {
6181 SOCKET sock = *(SOCKET *)arg;
6182 char buffer[32];
6183 WSABUF wsa;
6184 WSAOVERLAPPED ov;
6185 DWORD flags = 0;
6186
6187 wsa.buf = buffer;
6188 wsa.len = sizeof(buffer);
6189 ov.hEvent = WSACreateEvent();
6190 WSARecv(sock, &wsa, 1, NULL, &flags, &ov, NULL);
6191
6192 WaitForSingleObject(ov.hEvent, 1000);
6193 WSACloseEvent(ov.hEvent);
6194 return 0;
6195 }
6196
6197 static void test_WSARecv(void)
6198 {
6199 SOCKET src, dest, server = INVALID_SOCKET;
6200 char buf[20];
6201 WSABUF bufs;
6202 WSAOVERLAPPED ov;
6203 DWORD bytesReturned, flags, id;
6204 struct linger ling;
6205 struct sockaddr_in addr;
6206 int iret, len;
6207 DWORD dwret;
6208 BOOL bret;
6209 HANDLE thread;
6210
6211 tcp_socketpair(&src, &dest);
6212 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
6213 {
6214 skip("failed to create sockets\n");
6215 goto end;
6216 }
6217
6218 memset(&ov, 0, sizeof(ov));
6219 flags = 0;
6220 bufs.len = 2;
6221 bufs.buf = buf;
6222
6223 /* Send 4 bytes and receive in two calls of 2 */
6224 SetLastError(0xdeadbeef);
6225 iret = send(src, "test", 4, 0);
6226 ok(iret == 4, "Expected 4, got %d\n", iret);
6227 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6228 SetLastError(0xdeadbeef);
6229 bytesReturned = 0xdeadbeef;
6230 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, NULL, NULL);
6231 ok(!iret, "Expected 0, got %d\n", iret);
6232 ok(bytesReturned, "Expected 2, got %d\n", bytesReturned);
6233 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6234 SetLastError(0xdeadbeef);
6235 bytesReturned = 0xdeadbeef;
6236 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, NULL, NULL);
6237 ok(!iret, "Expected 0, got %d\n", iret);
6238 ok(bytesReturned, "Expected 2, got %d\n", bytesReturned);
6239 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6240
6241 bufs.len = 4;
6242 SetLastError(0xdeadbeef);
6243 iret = send(src, "test", 4, 0);
6244 ok(iret == 4, "Expected 4, got %d\n", iret);
6245 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6246 SetLastError(0xdeadbeef);
6247 bytesReturned = 0xdeadbeef;
6248 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, NULL, NULL);
6249 ok(!iret, "Expected 0, got %d\n", iret);
6250 ok(bytesReturned, "Expected 4, got %d\n", bytesReturned);
6251 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6252
6253 bufs.len = sizeof(buf);
6254
6255 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6256 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
6257 if (!ov.hEvent)
6258 goto end;
6259
6260 ling.l_onoff = 1;
6261 ling.l_linger = 0;
6262 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
6263 ok(!iret, "Failed to set linger %d\n", GetLastError());
6264
6265 iret = WSARecv(dest, &bufs, 1, NULL, &flags, &ov, NULL);
6266 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6267
6268 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
6269 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6270
6271 closesocket(src);
6272 src = INVALID_SOCKET;
6273
6274 dwret = WaitForSingleObject(ov.hEvent, 1000);
6275 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %d + errno %d\n", dwret, GetLastError());
6276
6277 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
6278 todo_wine ok(!bret && (GetLastError() == ERROR_NETNAME_DELETED || broken(GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */),
6279 "Did not get disconnect event: %d, error %d\n", bret, GetLastError());
6280 ok(bytesReturned == 0, "Bytes received is %d\n", bytesReturned);
6281 closesocket(dest);
6282 dest = INVALID_SOCKET;
6283
6284 src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
6285 ok(src != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6286 if (src == INVALID_SOCKET) goto end;
6287
6288 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
6289 ok(server != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6290 if (server == INVALID_SOCKET) goto end;
6291
6292 memset(&addr, 0, sizeof(addr));
6293 addr.sin_family = AF_INET;
6294 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6295 iret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
6296 if (iret) goto end;
6297
6298 len = sizeof(addr);
6299 iret = getsockname(server, (struct sockaddr *)&addr, &len);
6300 if (iret) goto end;
6301
6302 iret = listen(server, 1);
6303 if (iret) goto end;
6304
6305 iret = connect(src, (struct sockaddr *)&addr, sizeof(addr));
6306 if (iret) goto end;
6307
6308 len = sizeof(addr);
6309 dest = accept(server, (struct sockaddr *)&addr, &len);
6310 ok(dest != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6311 if (dest == INVALID_SOCKET) goto end;
6312
6313 send(src, "test message", sizeof("test message"), 0);
6314 thread = CreateThread(NULL, 0, recv_thread, &dest, 0, &id);
6315 WaitForSingleObject(thread, 3000);
6316 CloseHandle(thread);
6317
6318 end:
6319 if (server != INVALID_SOCKET)
6320 closesocket(server);
6321 if (dest != INVALID_SOCKET)
6322 closesocket(dest);
6323 if (src != INVALID_SOCKET)
6324 closesocket(src);
6325 if (ov.hEvent)
6326 WSACloseEvent(ov.hEvent);
6327 }
6328
6329 static void test_GetAddrInfoW(void)
6330 {
6331 static const WCHAR port[] = {'8','0',0};
6332 static const WCHAR empty[] = {0};
6333 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
6334 static const WCHAR nxdomain[] =
6335 {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
6336 static const WCHAR zero[] = {'0',0};
6337 int i, ret;
6338 ADDRINFOW *result, *result2, *p, hint;
6339 WCHAR name[256];
6340 DWORD size = sizeof(name)/sizeof(WCHAR);
6341
6342 if (!pGetAddrInfoW || !pFreeAddrInfoW)
6343 {
6344 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
6345 return;
6346 }
6347 memset(&hint, 0, sizeof(ADDRINFOW));
6348 name[0] = 0;
6349 GetComputerNameExW( ComputerNamePhysicalDnsHostname, name, &size );
6350
6351 result = (ADDRINFOW *)0xdeadbeef;
6352 WSASetLastError(0xdeadbeef);
6353 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
6354 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6355 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6356 ok(result == NULL, "got %p\n", result);
6357
6358 result = NULL;
6359 WSASetLastError(0xdeadbeef);
6360 ret = pGetAddrInfoW(empty, NULL, NULL, &result);
6361 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6362 ok(result != NULL, "GetAddrInfoW failed\n");
6363 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6364 pFreeAddrInfoW(result);
6365
6366 result = NULL;
6367 ret = pGetAddrInfoW(NULL, zero, NULL, &result);
6368 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6369 ok(result != NULL, "GetAddrInfoW failed\n");
6370
6371 result2 = NULL;
6372 ret = pGetAddrInfoW(NULL, empty, NULL, &result2);
6373 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6374 ok(result2 != NULL, "GetAddrInfoW failed\n");
6375 compare_addrinfow(result, result2);
6376 pFreeAddrInfoW(result);
6377 pFreeAddrInfoW(result2);
6378
6379 result = NULL;
6380 ret = pGetAddrInfoW(empty, zero, NULL, &result);
6381 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6382 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6383 ok(result != NULL, "GetAddrInfoW failed\n");
6384
6385 result2 = NULL;
6386 ret = pGetAddrInfoW(empty, empty, NULL, &result2);
6387 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6388 ok(result2 != NULL, "GetAddrInfoW failed\n");
6389 compare_addrinfow(result, result2);
6390 pFreeAddrInfoW(result);
6391 pFreeAddrInfoW(result2);
6392
6393 result = NULL;
6394 ret = pGetAddrInfoW(localhost, NULL, NULL, &result);
6395 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6396 pFreeAddrInfoW(result);
6397
6398 result = NULL;
6399 ret = pGetAddrInfoW(localhost, empty, NULL, &result);
6400 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6401 pFreeAddrInfoW(result);
6402
6403 result = NULL;
6404 ret = pGetAddrInfoW(localhost, zero, NULL, &result);
6405 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6406 pFreeAddrInfoW(result);
6407
6408 result = NULL;
6409 ret = pGetAddrInfoW(localhost, port, NULL, &result);
6410 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6411 pFreeAddrInfoW(result);
6412
6413 result = NULL;
6414 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
6415 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6416 pFreeAddrInfoW(result);
6417
6418 result = NULL;
6419 SetLastError(0xdeadbeef);
6420 ret = pGetAddrInfoW(localhost, port, &hint, &result);
6421 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6422 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6423 pFreeAddrInfoW(result);
6424
6425 /* try to get information from the computer name, result is the same
6426 * as if requesting with an empty host name. */
6427 ret = pGetAddrInfoW(name, NULL, NULL, &result);
6428 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6429 ok(result != NULL, "GetAddrInfoW failed\n");
6430
6431 ret = pGetAddrInfoW(empty, NULL, NULL, &result2);
6432 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6433 ok(result != NULL, "GetAddrInfoW failed\n");
6434 compare_addrinfow(result, result2);
6435 pFreeAddrInfoW(result);
6436 pFreeAddrInfoW(result2);
6437
6438 ret = pGetAddrInfoW(name, empty, NULL, &result);
6439 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6440 ok(result != NULL, "GetAddrInfoW failed\n");
6441
6442 ret = pGetAddrInfoW(empty, empty, NULL, &result2);
6443 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6444 ok(result != NULL, "GetAddrInfoW failed\n");
6445 compare_addrinfow(result, result2);
6446 pFreeAddrInfoW(result);
6447 pFreeAddrInfoW(result2);
6448
6449 result = (ADDRINFOW *)0xdeadbeef;
6450 WSASetLastError(0xdeadbeef);
6451 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
6452 if(ret == 0)
6453 {
6454 skip("nxdomain returned success. Broken ISP redirects?\n");
6455 return;
6456 }
6457 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6458 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6459 ok(result == NULL, "got %p\n", result);
6460
6461 result = (ADDRINFOW *)0xdeadbeef;
6462 WSASetLastError(0xdeadbeef);
6463 ret = pGetAddrInfoW(nxdomain, NULL, NULL, &result);
6464 if(ret == 0)
6465 {
6466 skip("nxdomain returned success. Broken ISP redirects?\n");
6467 return;
6468 }
6469 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6470 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6471 ok(result == NULL, "got %p\n", result);
6472
6473 for (i = 0;i < (sizeof(hinttests) / sizeof(hinttests[0]));i++)
6474 {
6475 hint.ai_family = hinttests[i].family;
6476 hint.ai_socktype = hinttests[i].socktype;
6477 hint.ai_protocol = hinttests[i].protocol;
6478
6479 result = NULL;
6480 SetLastError(0xdeadbeef);
6481 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
6482 if (!ret)
6483 {
6484 if (hinttests[i].error)
6485 ok(0, "test %d: GetAddrInfoW succeeded unexpectedly\n", i);
6486 else
6487 {
6488 p = result;
6489 do
6490 {
6491 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
6492 if (hinttests[i].family == AF_UNSPEC)
6493 ok(p->ai_family == AF_INET || p->ai_family == AF_INET6,
6494 "test %d: expected AF_INET or AF_INET6, got %d\n",
6495 i, p->ai_family);
6496 else
6497 ok(p->ai_family == hinttests[i].family,
6498 "test %d: expected family %d, got %d\n",
6499 i, hinttests[i].family, p->ai_family);
6500
6501 ok(p->ai_socktype == hinttests[i].socktype,
6502 "test %d: expected type %d, got %d\n",
6503 i, hinttests[i].socktype, p->ai_socktype);
6504 ok(p->ai_protocol == hinttests[i].protocol,
6505 "test %d: expected protocol %d, got %d\n",
6506 i, hinttests[i].protocol, p->ai_protocol);
6507 p = p->ai_next;
6508 }
6509 while (p);
6510 }
6511 pFreeAddrInfoW(result);
6512 }
6513 else
6514 {
6515 DWORD err = WSAGetLastError();
6516 if (hinttests[i].error)
6517 ok(hinttests[i].error == err, "test %d: GetAddrInfoW failed with error %d, expected %d\n",
6518 i, err, hinttests[i].error);
6519 else
6520 ok(0, "test %d: GetAddrInfoW failed with %d (err %d)\n", i, ret, err);
6521 }
6522 }
6523 }
6524
6525 static void test_getaddrinfo(void)
6526 {
6527 int i, ret;
6528 ADDRINFOA *result, *result2, *p, hint;
6529 CHAR name[256];
6530 DWORD size = sizeof(name);
6531
6532 if (!pgetaddrinfo || !pfreeaddrinfo)
6533 {
6534 win_skip("getaddrinfo and/or freeaddrinfo not present\n");
6535 return;
6536 }
6537 memset(&hint, 0, sizeof(ADDRINFOA));
6538 GetComputerNameExA( ComputerNamePhysicalDnsHostname, name, &size );
6539
6540 result = (ADDRINFOA *)0xdeadbeef;
6541 WSASetLastError(0xdeadbeef);
6542 ret = pgetaddrinfo(NULL, NULL, NULL, &result);
6543 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6544 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6545 ok(result == NULL, "got %p\n", result);
6546
6547 result = NULL;
6548 WSASetLastError(0xdeadbeef);
6549 ret = pgetaddrinfo("", NULL, NULL, &result);
6550 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6551 ok(result != NULL, "getaddrinfo failed\n");
6552 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6553 pfreeaddrinfo(result);
6554
6555 result = NULL;
6556 ret = pgetaddrinfo(NULL, "0", NULL, &result);
6557 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6558 ok(result != NULL, "getaddrinfo failed\n");
6559
6560 result2 = NULL;
6561 ret = pgetaddrinfo(NULL, "", NULL, &result2);
6562 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6563 ok(result2 != NULL, "getaddrinfo failed\n");
6564 compare_addrinfo(result, result2);
6565 pfreeaddrinfo(result);
6566 pfreeaddrinfo(result2);
6567
6568 result = NULL;
6569 WSASetLastError(0xdeadbeef);
6570 ret = pgetaddrinfo("", "0", NULL, &result);
6571 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6572 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6573 ok(result != NULL, "getaddrinfo failed\n");
6574
6575 result2 = NULL;
6576 ret = pgetaddrinfo("", "", NULL, &result2);
6577 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6578 ok(result2 != NULL, "getaddrinfo failed\n");
6579 compare_addrinfo(result, result2);
6580 pfreeaddrinfo(result);
6581 pfreeaddrinfo(result2);
6582
6583 result = NULL;
6584 ret = pgetaddrinfo("localhost", NULL, NULL, &result);
6585 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6586 pfreeaddrinfo(result);
6587
6588 result = NULL;
6589 ret = pgetaddrinfo("localhost", "", NULL, &result);
6590 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6591 pfreeaddrinfo(result);
6592
6593 result = NULL;
6594 ret = pgetaddrinfo("localhost", "0", NULL, &result);
6595 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6596 pfreeaddrinfo(result);
6597
6598 result = NULL;
6599 ret = pgetaddrinfo("localhost", "80", NULL, &result);
6600 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6601 pfreeaddrinfo(result);
6602
6603 result = NULL;
6604 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
6605 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6606 pfreeaddrinfo(result);
6607
6608 result = NULL;
6609 WSASetLastError(0xdeadbeef);
6610 ret = pgetaddrinfo("localhost", "80", &hint, &result);
6611 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6612 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6613 pfreeaddrinfo(result);
6614
6615 /* try to get information from the computer name, result is the same
6616 * as if requesting with an empty host name. */
6617 ret = pgetaddrinfo(name, NULL, NULL, &result);
6618 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6619 ok(result != NULL, "GetAddrInfoW failed\n");
6620
6621 ret = pgetaddrinfo("", NULL, NULL, &result2);
6622 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6623 ok(result != NULL, "GetAddrInfoW failed\n");
6624 compare_addrinfo(result, result2);
6625 pfreeaddrinfo(result);
6626 pfreeaddrinfo(result2);
6627
6628 ret = pgetaddrinfo(name, "", NULL, &result);
6629 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6630 ok(result != NULL, "GetAddrInfoW failed\n");
6631
6632 ret = pgetaddrinfo("", "", NULL, &result2);
6633 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6634 ok(result != NULL, "GetAddrInfoW failed\n");
6635 compare_addrinfo(result, result2);
6636 pfreeaddrinfo(result);
6637 pfreeaddrinfo(result2);
6638
6639 result = (ADDRINFOA *)0xdeadbeef;
6640 WSASetLastError(0xdeadbeef);
6641 ret = pgetaddrinfo("nxdomain.codeweavers.com", NULL, NULL, &result);
6642 if(ret == 0)
6643 {
6644 skip("nxdomain returned success. Broken ISP redirects?\n");
6645 return;
6646 }
6647 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6648 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6649 ok(result == NULL, "got %p\n", result);
6650
6651 for (i = 0;i < (sizeof(hinttests) / sizeof(hinttests[0]));i++)
6652 {
6653 hint.ai_family = hinttests[i].family;
6654 hint.ai_socktype = hinttests[i].socktype;
6655 hint.ai_protocol = hinttests[i].protocol;
6656
6657 result = NULL;
6658 SetLastError(0xdeadbeef);
6659 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
6660 if(!ret)
6661 {
6662 if (hinttests[i].error)
6663 ok(0, "test %d: getaddrinfo succeeded unexpectedly\n", i);
6664 else
6665 {
6666 p = result;
6667 do
6668 {
6669 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
6670 if (hinttests[i].family == AF_UNSPEC)
6671 ok(p->ai_family == AF_INET || p->ai_family == AF_INET6,
6672 "test %d: expected AF_INET or AF_INET6, got %d\n",
6673 i, p->ai_family);
6674 else
6675 ok(p->ai_family == hinttests[i].family,
6676 "test %d: expected family %d, got %d\n",
6677 i, hinttests[i].family, p->ai_family);
6678
6679 ok(p->ai_socktype == hinttests[i].socktype,
6680 "test %d: expected type %d, got %d\n",
6681 i, hinttests[i].socktype, p->ai_socktype);
6682 ok(p->ai_protocol == hinttests[i].protocol,
6683 "test %d: expected protocol %d, got %d\n",
6684 i, hinttests[i].protocol, p->ai_protocol);
6685 p = p->ai_next;
6686 }
6687 while (p);
6688 }
6689 pfreeaddrinfo(result);
6690 }
6691 else
6692 {
6693 DWORD err = WSAGetLastError();
6694 if (hinttests[i].error)
6695 ok(hinttests[i].error == err, "test %d: getaddrinfo failed with error %d, expected %d\n",
6696 i, err, hinttests[i].error);
6697 else
6698 ok(0, "test %d: getaddrinfo failed with %d (err %d)\n", i, ret, err);
6699 }
6700 }
6701 }
6702
6703 static void test_ConnectEx(void)
6704 {
6705 SOCKET listener = INVALID_SOCKET;
6706 SOCKET acceptor = INVALID_SOCKET;
6707 SOCKET connector = INVALID_SOCKET;
6708 struct sockaddr_in address, conaddress;
6709 int addrlen;
6710 OVERLAPPED overlapped;
6711 LPFN_CONNECTEX pConnectEx;
6712 GUID connectExGuid = WSAID_CONNECTEX;
6713 DWORD bytesReturned;
6714 char buffer[1024];
6715 BOOL bret;
6716 DWORD dwret;
6717 int iret;
6718
6719 memset(&overlapped, 0, sizeof(overlapped));
6720
6721 listener = socket(AF_INET, SOCK_STREAM, 0);
6722 if (listener == INVALID_SOCKET) {
6723 skip("could not create listener socket, error %d\n", WSAGetLastError());
6724 goto end;
6725 }
6726
6727 connector = socket(AF_INET, SOCK_STREAM, 0);
6728 if (connector == INVALID_SOCKET) {
6729 skip("could not create connector socket, error %d\n", WSAGetLastError());
6730 goto end;
6731 }
6732
6733 memset(&address, 0, sizeof(address));
6734 address.sin_family = AF_INET;
6735 address.sin_addr.s_addr = inet_addr("127.0.0.1");
6736 iret = bind(listener, (struct sockaddr*)&address, sizeof(address));
6737 if (iret != 0) {
6738 skip("failed to bind, error %d\n", WSAGetLastError());
6739 goto end;
6740 }
6741
6742 addrlen = sizeof(address);
6743 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
6744 if (iret != 0) {
6745 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
6746 goto end;
6747 }
6748
6749 if (set_blocking(listener, TRUE)) {
6750 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
6751 goto end;
6752 }
6753
6754 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectExGuid, sizeof(connectExGuid),
6755 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
6756 if (iret) {
6757 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret, WSAGetLastError());
6758 goto end;
6759 }
6760
6761 bret = pConnectEx(INVALID_SOCKET, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
6762 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "ConnectEx on invalid socket "
6763 "returned %d + errno %d\n", bret, WSAGetLastError());
6764
6765 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
6766 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "ConnectEx on a unbound socket "
6767 "returned %d + errno %d\n", bret, WSAGetLastError());
6768 if (bret == TRUE || WSAGetLastError() != WSAEINVAL)
6769 {
6770 acceptor = accept(listener, NULL, NULL);
6771 if (acceptor != INVALID_SOCKET) {
6772 closesocket(acceptor);
6773 acceptor = INVALID_SOCKET;
6774 }
6775
6776 closesocket(connector);
6777 connector = socket(AF_INET, SOCK_STREAM, 0);
6778 if (connector == INVALID_SOCKET) {
6779 skip("could not create connector socket, error %d\n", WSAGetLastError());
6780 goto end;
6781 }
6782 }
6783
6784 /* ConnectEx needs a bound socket */
6785 memset(&conaddress, 0, sizeof(conaddress));
6786 conaddress.sin_family = AF_INET;
6787 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
6788 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
6789 if (iret != 0) {
6790 skip("failed to bind, error %d\n", WSAGetLastError());
6791 goto end;
6792 }
6793
6794 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, NULL);
6795 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "ConnectEx on a NULL overlapped "
6796 "returned %d + errno %d\n", bret, WSAGetLastError());
6797
6798 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6799 if (overlapped.hEvent == NULL) {
6800 skip("could not create event object, errno = %d\n", GetLastError());
6801 goto end;
6802 }
6803
6804 iret = listen(listener, 1);
6805 if (iret != 0) {
6806 skip("listening failed, errno = %d\n", WSAGetLastError());
6807 goto end;
6808 }
6809
6810 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
6811 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
6812 "returned %d + errno %d\n", bret, WSAGetLastError());
6813 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
6814 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
6815
6816 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
6817 ok(bret, "Connecting failed, error %d\n", GetLastError());
6818 ok(bytesReturned == 0, "Bytes sent is %d\n", bytesReturned);
6819
6820 closesocket(connector);
6821 connector = socket(AF_INET, SOCK_STREAM, 0);
6822 if (connector == INVALID_SOCKET) {
6823 skip("could not create connector socket, error %d\n", WSAGetLastError());
6824 goto end;
6825 }
6826 /* ConnectEx needs a bound socket */
6827 memset(&conaddress, 0, sizeof(conaddress));
6828 conaddress.sin_family = AF_INET;
6829 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
6830 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
6831 if (iret != 0) {
6832 skip("failed to bind, error %d\n", WSAGetLastError());
6833 goto end;
6834 }
6835
6836 acceptor = accept(listener, NULL, NULL);
6837 if (acceptor != INVALID_SOCKET) {
6838 closesocket(acceptor);
6839 }
6840
6841 buffer[0] = '1';
6842 buffer[1] = '2';
6843 buffer[2] = '3';
6844 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, buffer, 3, &bytesReturned, &overlapped);
6845 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
6846 "returned %d + errno %d\n", bret, WSAGetLastError());
6847 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
6848 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
6849
6850 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
6851 ok(bret, "Connecting failed, error %d\n", GetLastError());
6852 ok(bytesReturned == 3, "Bytes sent is %d\n", bytesReturned);
6853
6854 acceptor = accept(listener, NULL, NULL);
6855 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
6856
6857 bytesReturned = recv(acceptor, buffer, 3, 0);
6858 buffer[4] = 0;
6859 ok(bytesReturned == 3, "Didn't get all sent data, got only %d\n", bytesReturned);
6860 ok(buffer[0] == '1' && buffer[1] == '2' && buffer[2] == '3',
6861 "Failed to get the right data, expected '123', got '%s'\n", buffer);
6862
6863 closesocket(connector);
6864 connector = socket(AF_INET, SOCK_STREAM, 0);
6865 if (connector == INVALID_SOCKET) {
6866 skip("could not create connector socket, error %d\n", WSAGetLastError());
6867 goto end;
6868 }
6869 /* ConnectEx needs a bound socket */
6870 memset(&conaddress, 0, sizeof(conaddress));
6871 conaddress.sin_family = AF_INET;
6872 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
6873 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
6874 if (iret != 0) {
6875 skip("failed to bind, error %d\n", WSAGetLastError());
6876 goto end;
6877 }
6878
6879 if (acceptor != INVALID_SOCKET) {
6880 closesocket(acceptor);
6881 acceptor = INVALID_SOCKET;
6882 }
6883
6884 /* Connect with error */
6885 closesocket(listener);
6886 listener = INVALID_SOCKET;
6887
6888 address.sin_port = htons(1);
6889
6890 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
6891 ok(bret == FALSE && GetLastError(), "ConnectEx to bad destination failed: "
6892 "returned %d + errno %d\n", bret, GetLastError());
6893
6894 if (GetLastError() == ERROR_IO_PENDING)
6895 {
6896 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
6897 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
6898
6899 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
6900 ok(bret == FALSE && GetLastError() == ERROR_CONNECTION_REFUSED,
6901 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
6902 }
6903 else {
6904 ok(GetLastError() == WSAECONNREFUSED,
6905 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
6906 }
6907
6908 end:
6909 if (overlapped.hEvent)
6910 WSACloseEvent(overlapped.hEvent);
6911 if (listener != INVALID_SOCKET)
6912 closesocket(listener);
6913 if (acceptor != INVALID_SOCKET)
6914 closesocket(acceptor);
6915 if (connector != INVALID_SOCKET)
6916 closesocket(connector);
6917 }
6918
6919 static void test_AcceptEx(void)
6920 {
6921 SOCKET listener = INVALID_SOCKET;
6922 SOCKET acceptor = INVALID_SOCKET;
6923 SOCKET connector = INVALID_SOCKET;
6924 SOCKET connector2 = INVALID_SOCKET;
6925 struct sockaddr_in bindAddress, peerAddress, *readBindAddress, *readRemoteAddress;
6926 int socklen, optlen;
6927 GUID acceptExGuid = WSAID_ACCEPTEX, getAcceptExGuid = WSAID_GETACCEPTEXSOCKADDRS;
6928 LPFN_ACCEPTEX pAcceptEx = NULL;
6929 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs = NULL;
6930 fd_set fds_accept, fds_send;
6931 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
6932 int got, conn1, i;
6933 DWORD bytesReturned, connect_time;
6934 char buffer[1024], ipbuffer[32];
6935 OVERLAPPED overlapped;
6936 int iret, localSize = sizeof(struct sockaddr_in), remoteSize = localSize;
6937 BOOL bret;
6938 DWORD dwret;
6939
6940 memset(&overlapped, 0, sizeof(overlapped));
6941
6942 listener = socket(AF_INET, SOCK_STREAM, 0);
6943 if (listener == INVALID_SOCKET) {
6944 skip("could not create listener socket, error %d\n", WSAGetLastError());
6945 goto end;
6946 }
6947
6948 acceptor = socket(AF_INET, SOCK_STREAM, 0);
6949 if (acceptor == INVALID_SOCKET) {
6950 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6951 goto end;
6952 }
6953
6954 connector = socket(AF_INET, SOCK_STREAM, 0);
6955 if (connector == INVALID_SOCKET) {
6956 skip("could not create connector socket, error %d\n", WSAGetLastError());
6957 goto end;
6958 }
6959
6960 memset(&bindAddress, 0, sizeof(bindAddress));
6961 bindAddress.sin_family = AF_INET;
6962 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
6963 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
6964 if (iret != 0) {
6965 skip("failed to bind, error %d\n", WSAGetLastError());
6966 goto end;
6967 }
6968
6969 socklen = sizeof(bindAddress);
6970 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
6971 if (iret != 0) {
6972 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
6973 goto end;
6974 }
6975
6976 if (set_blocking(listener, FALSE)) {
6977 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
6978 goto end;
6979 }
6980
6981 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
6982 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
6983 if (iret) {
6984 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
6985 goto end;
6986 }
6987
6988 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &getAcceptExGuid, sizeof(getAcceptExGuid),
6989 &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &bytesReturned, NULL, NULL);
6990 if (iret) {
6991 skip("WSAIoctl failed to get GetAcceptExSockaddrs with ret %d + errno %d\n", iret, WSAGetLastError());
6992 goto end;
6993 }
6994
6995 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6996 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6997 &bytesReturned, &overlapped);
6998 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
6999 "returned %d + errno %d\n", bret, WSAGetLastError());
7000
7001 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7002 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7003 &bytesReturned, &overlapped);
7004 todo_wine
7005 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
7006 "returned %d + errno %d\n", bret, WSAGetLastError());
7007
7008 iret = listen(listener, 5);
7009 if (iret != 0) {
7010 skip("listening failed, errno = %d\n", WSAGetLastError());
7011 goto end;
7012 }
7013
7014 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7015 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7016 &bytesReturned, &overlapped);
7017 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid accepting socket "
7018 "returned %d + errno %d\n", bret, WSAGetLastError());
7019
7020 bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7021 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7022 &bytesReturned, &overlapped);
7023 ok(bret == FALSE &&
7024 (WSAGetLastError() == WSAEINVAL ||
7025 broken(WSAGetLastError() == WSAEFAULT)), /* NT4 */
7026 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
7027
7028 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
7029 &bytesReturned, &overlapped);
7030 ok(bret == FALSE && (WSAGetLastError() == ERROR_IO_PENDING || broken(WSAGetLastError() == WSAEINVAL)) /* NT4 */,
7031 "AcceptEx on too small local address size returned %d + errno %d\n",
7032 bret, WSAGetLastError());
7033 bret = CancelIo((HANDLE) listener);
7034 ok(bret, "Failed to cancel pending accept socket\n");
7035
7036 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 15,
7037 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
7038 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx on too small local address "
7039 "size returned %d + errno %d\n",
7040 bret, WSAGetLastError());
7041 bret = CancelIo((HANDLE) listener);
7042 ok(bret, "Failed to cancel pending accept socket\n");
7043
7044 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
7045 &bytesReturned, &overlapped);
7046 ok(bret == FALSE && (WSAGetLastError() == WSAEFAULT || broken(WSAGetLastError() == WSAEINVAL)) /* NT4 */,
7047 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
7048
7049 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
7050 sizeof(struct sockaddr_in) + 15, &bytesReturned, &overlapped);
7051 ok(bret == FALSE && (WSAGetLastError() == ERROR_IO_PENDING || broken(WSAGetLastError() == WSAEINVAL)) /* NT4 */,
7052 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
7053 bret = CancelIo((HANDLE) listener);
7054 ok(bret, "Failed to cancel pending accept socket\n");
7055
7056 bret = pAcceptEx(listener, acceptor, buffer, 0,
7057 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7058 &bytesReturned, NULL);
7059 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
7060 "returned %d + errno %d\n", bret, WSAGetLastError());
7061
7062 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, 0, &bytesReturned, NULL);
7063 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
7064 "returned %d + errno %d\n", bret, WSAGetLastError());
7065
7066 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
7067 if (overlapped.hEvent == NULL) {
7068 skip("could not create event object, errno = %d\n", GetLastError());
7069 goto end;
7070 }
7071
7072 bret = pAcceptEx(listener, acceptor, buffer, 0,
7073 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7074 &bytesReturned, &overlapped);
7075 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7076
7077 bret = pAcceptEx(listener, acceptor, buffer, 0,
7078 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7079 &bytesReturned, &overlapped);
7080 todo_wine ok((bret == FALSE && WSAGetLastError() == WSAEINVAL) || broken(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) /* NT4 */,
7081 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
7082 if (bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) {
7083 /* We need to cancel this call, otherwise things fail */
7084 bret = CancelIo((HANDLE) listener);
7085 ok(bret, "Failed to cancel failed test. Bailing...\n");
7086 if (!bret) return;
7087 WaitForSingleObject(overlapped.hEvent, 0);
7088
7089 bret = pAcceptEx(listener, acceptor, buffer, 0,
7090 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7091 &bytesReturned, &overlapped);
7092 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7093 }
7094
7095 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7096 todo_wine ok((iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL) || broken(!iret) /* NT4 */,
7097 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
7098 if (!iret || (iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)) {
7099 /* We need to cancel this call, otherwise things fail */
7100 closesocket(acceptor);
7101 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7102 if (acceptor == INVALID_SOCKET) {
7103 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7104 goto end;
7105 }
7106
7107 bret = CancelIo((HANDLE) listener);
7108 ok(bret, "Failed to cancel failed test. Bailing...\n");
7109 if (!bret) return;
7110
7111 bret = pAcceptEx(listener, acceptor, buffer, 0,
7112 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7113 &bytesReturned, &overlapped);
7114 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7115 }
7116
7117 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7118 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7119
7120 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
7121 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7122
7123 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7124 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7125 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7126
7127 closesocket(connector);
7128 connector = INVALID_SOCKET;
7129 closesocket(acceptor);
7130
7131 /* Test short reads */
7132
7133 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7134 if (acceptor == INVALID_SOCKET) {
7135 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7136 goto end;
7137 }
7138 connector = socket(AF_INET, SOCK_STREAM, 0);
7139 if (connector == INVALID_SOCKET) {
7140 skip("could not create connector socket, error %d\n", WSAGetLastError());
7141 goto end;
7142 }
7143 bret = pAcceptEx(listener, acceptor, buffer, 2,
7144 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7145 &bytesReturned, &overlapped);
7146 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7147
7148 connect_time = 0xdeadbeef;
7149 optlen = sizeof(connect_time);
7150 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
7151 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
7152 ok(connect_time == ~0u, "unexpected connect time %u\n", connect_time);
7153
7154 /* AcceptEx() still won't complete until we send data */
7155 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7156 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7157
7158 connect_time = 0xdeadbeef;
7159 optlen = sizeof(connect_time);
7160 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
7161 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
7162 ok(connect_time < 0xdeadbeef, "unexpected connect time %u\n", connect_time);
7163
7164 dwret = WaitForSingleObject(overlapped.hEvent, 0);
7165 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %d + errno %d\n", dwret, GetLastError());
7166
7167 iret = getsockname( connector, (struct sockaddr *)&peerAddress, &remoteSize);
7168 ok( !iret, "getsockname failed.\n");
7169
7170 /* AcceptEx() could complete any time now */
7171 iret = send(connector, buffer, 1, 0);
7172 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
7173
7174 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7175 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7176
7177 /* Check if the buffer from AcceptEx is decoded correctly */
7178 pGetAcceptExSockaddrs(buffer, 2, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7179 (struct sockaddr **)&readBindAddress, &localSize,
7180 (struct sockaddr **)&readRemoteAddress, &remoteSize);
7181 strcpy( ipbuffer, inet_ntoa(readBindAddress->sin_addr));
7182 ok( readBindAddress->sin_addr.s_addr == bindAddress.sin_addr.s_addr,
7183 "Local socket address is different %s != %s\n",
7184 ipbuffer, inet_ntoa(bindAddress.sin_addr));
7185 ok( readBindAddress->sin_port == bindAddress.sin_port,
7186 "Local socket port is different: %d != %d\n",
7187 readBindAddress->sin_port, bindAddress.sin_port);
7188 strcpy( ipbuffer, inet_ntoa(readRemoteAddress->sin_addr));
7189 ok( readRemoteAddress->sin_addr.s_addr == peerAddress.sin_addr.s_addr,
7190 "Remote socket address is different %s != %s\n",
7191 ipbuffer, inet_ntoa(peerAddress.sin_addr));
7192 ok( readRemoteAddress->sin_port == peerAddress.sin_port,
7193 "Remote socket port is different: %d != %d\n",
7194 readRemoteAddress->sin_port, peerAddress.sin_port);
7195
7196 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7197 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7198 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7199
7200 closesocket(connector);
7201 connector = INVALID_SOCKET;
7202 closesocket(acceptor);
7203
7204 /* Test CF_DEFER & AcceptEx interaction */
7205
7206 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7207 if (acceptor == INVALID_SOCKET) {
7208 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7209 goto end;
7210 }
7211 connector = socket(AF_INET, SOCK_STREAM, 0);
7212 if (connector == INVALID_SOCKET) {
7213 skip("could not create connector socket, error %d\n", WSAGetLastError());
7214 goto end;
7215 }
7216 connector2 = socket(AF_INET, SOCK_STREAM, 0);
7217 if (connector == INVALID_SOCKET) {
7218 skip("could not create connector socket, error %d\n", WSAGetLastError());
7219 goto end;
7220 }
7221
7222 if (set_blocking(connector, FALSE)) {
7223 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7224 goto end;
7225 }
7226
7227 if (set_blocking(connector2, FALSE)) {
7228 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7229 goto end;
7230 }
7231
7232 /* Connect socket #1 */
7233 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7234 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7235
7236 FD_ZERO ( &fds_accept );
7237 FD_ZERO ( &fds_send );
7238
7239 FD_SET ( listener, &fds_accept );
7240 FD_SET ( connector, &fds_send );
7241
7242 buffer[0] = '0';
7243 got = 0;
7244 conn1 = 0;
7245
7246 for (i = 0; i < 4000; ++i)
7247 {
7248 fd_set fds_openaccept = fds_accept, fds_opensend = fds_send;
7249
7250 wsa_ok ( ( select ( 0, &fds_openaccept, &fds_opensend, NULL, &timeout ) ), SOCKET_ERROR !=,
7251 "acceptex test(%d): could not select on socket, errno %d\n" );
7252
7253 /* check for incoming requests */
7254 if ( FD_ISSET ( listener, &fds_openaccept ) ) {
7255 got++;
7256 if (got == 1) {
7257 SOCKET tmp = WSAAccept(listener, NULL, NULL, (LPCONDITIONPROC) AlwaysDeferConditionFunc, 0);
7258 ok(tmp == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
7259 bret = pAcceptEx(listener, acceptor, buffer, 0,
7260 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7261 &bytesReturned, &overlapped);
7262 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7263 }
7264 else if (got == 2) {
7265 /* this should be socket #2 */
7266 SOCKET tmp = accept(listener, NULL, NULL);
7267 ok(tmp != INVALID_SOCKET, "accept failed %d\n", WSAGetLastError());
7268 closesocket(tmp);
7269 }
7270 else {
7271 ok(FALSE, "Got more than 2 connections?\n");
7272 }
7273 }
7274 if ( conn1 && FD_ISSET ( connector2, &fds_opensend ) ) {
7275 /* Send data on second socket, and stop */
7276 send(connector2, "2", 1, 0);
7277 FD_CLR ( connector2, &fds_send );
7278
7279 break;
7280 }
7281 if ( FD_ISSET ( connector, &fds_opensend ) ) {
7282 /* Once #1 is connected, allow #2 to connect */
7283 conn1 = 1;
7284
7285 send(connector, "1", 1, 0);
7286 FD_CLR ( connector, &fds_send );
7287
7288 iret = connect(connector2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7289 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7290 FD_SET ( connector2, &fds_send );
7291 }
7292 }
7293
7294 ok (got == 2 || broken(got == 1) /* NT4 */,
7295 "Did not get both connections, got %d\n", got);
7296
7297 dwret = WaitForSingleObject(overlapped.hEvent, 0);
7298 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7299
7300 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7301 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7302 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7303
7304 set_blocking(acceptor, TRUE);
7305 iret = recv( acceptor, buffer, 2, 0);
7306 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
7307
7308 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
7309
7310 closesocket(connector);
7311 connector = INVALID_SOCKET;
7312 closesocket(acceptor);
7313
7314 /* clean up in case of failures */
7315 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
7316 closesocket(acceptor);
7317
7318 /* Disconnect during receive? */
7319
7320 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7321 if (acceptor == INVALID_SOCKET) {
7322 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7323 goto end;
7324 }
7325 connector = socket(AF_INET, SOCK_STREAM, 0);
7326 if (connector == INVALID_SOCKET) {
7327 skip("could not create connector socket, error %d\n", WSAGetLastError());
7328 goto end;
7329 }
7330 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7331 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7332 &bytesReturned, &overlapped);
7333 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7334
7335 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7336 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7337
7338 closesocket(connector);
7339 connector = INVALID_SOCKET;
7340
7341 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7342 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7343
7344 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7345 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7346 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7347
7348 closesocket(acceptor);
7349
7350 /* Test closing with pending requests */
7351
7352 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7353 if (acceptor == INVALID_SOCKET) {
7354 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7355 goto end;
7356 }
7357 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7358 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7359 &bytesReturned, &overlapped);
7360 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7361
7362 closesocket(acceptor);
7363
7364 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7365 todo_wine ok(dwret == WAIT_OBJECT_0 || broken(dwret == WAIT_TIMEOUT) /* NT4/2000 */,
7366 "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7367
7368 if (dwret != WAIT_TIMEOUT) {
7369 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7370 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
7371 }
7372 else {
7373 bret = CancelIo((HANDLE) listener);
7374 ok(bret, "Failed to cancel failed test. Bailing...\n");
7375 if (!bret) return;
7376 WaitForSingleObject(overlapped.hEvent, 0);
7377 }
7378
7379 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7380 if (acceptor == INVALID_SOCKET) {
7381 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7382 goto end;
7383 }
7384 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7385 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7386 &bytesReturned, &overlapped);
7387 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7388
7389 CancelIo((HANDLE) acceptor);
7390
7391 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7392 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %d + errno %d\n", dwret, GetLastError());
7393
7394 closesocket(acceptor);
7395
7396 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7397 if (acceptor == INVALID_SOCKET) {
7398 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7399 goto end;
7400 }
7401 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7402 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7403 &bytesReturned, &overlapped);
7404 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7405
7406 closesocket(listener);
7407 listener = INVALID_SOCKET;
7408
7409 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7410 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7411
7412 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7413 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
7414
7415 end:
7416 if (overlapped.hEvent)
7417 WSACloseEvent(overlapped.hEvent);
7418 if (listener != INVALID_SOCKET)
7419 closesocket(listener);
7420 if (acceptor != INVALID_SOCKET)
7421 closesocket(acceptor);
7422 if (connector != INVALID_SOCKET)
7423 closesocket(connector);
7424 if (connector2 != INVALID_SOCKET)
7425 closesocket(connector2);
7426 }
7427
7428 static void test_getpeername(void)
7429 {
7430 SOCKET sock;
7431 struct sockaddr_in sa, sa_out;
7432 SOCKADDR_STORAGE ss;
7433 int sa_len;
7434 const char buf[] = "hello world";
7435 int ret;
7436
7437 /* Test the parameter validation order. */
7438 ret = getpeername(INVALID_SOCKET, NULL, NULL);
7439 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
7440 ok(WSAGetLastError() == WSAENOTSOCK,
7441 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
7442
7443 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
7444 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
7445 if (sock == INVALID_SOCKET)
7446 {
7447 skip("Socket creation failed with %d\n", WSAGetLastError());
7448 return;
7449 }
7450
7451 ret = getpeername(sock, NULL, NULL);
7452 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
7453 ok(WSAGetLastError() == WSAENOTCONN ||
7454 broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
7455 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
7456
7457 memset(&sa, 0, sizeof(sa));
7458 sa.sin_family = AF_INET;
7459 sa.sin_port = htons(139);
7460 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
7461
7462 /* sendto does not change a socket's connection state. */
7463 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
7464 ok(ret != SOCKET_ERROR,
7465 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
7466
7467 ret = getpeername(sock, NULL, NULL);
7468 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
7469 ok(WSAGetLastError() == WSAENOTCONN ||
7470 broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
7471 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
7472
7473 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
7474 ok(ret == 0,
7475 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
7476
7477 ret = getpeername(sock, NULL, NULL);
7478 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
7479 ok(WSAGetLastError() == WSAEFAULT,
7480 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7481
7482 /* Test crashes on Wine. */
7483 if (0)
7484 {
7485 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
7486 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
7487 ok(WSAGetLastError() == WSAEFAULT,
7488 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7489 }
7490
7491 ret = getpeername(sock, (struct sockaddr*)&sa_out, NULL);
7492 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
7493 ok(WSAGetLastError() == WSAEFAULT,
7494 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7495
7496 sa_len = 0;
7497 ret = getpeername(sock, NULL, &sa_len);
7498 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
7499 ok(WSAGetLastError() == WSAEFAULT,
7500 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7501 ok(!sa_len, "got %d\n", sa_len);
7502
7503 sa_len = 0;
7504 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
7505 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
7506 ok(WSAGetLastError() == WSAEFAULT,
7507 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7508 ok(!sa_len, "got %d\n", sa_len);
7509
7510 sa_len = sizeof(ss);
7511 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
7512 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
7513 ok(!memcmp(&sa, &ss, sizeof(sa)),
7514 "Expected the returned structure to be identical to the connect structure\n");
7515 ok(sa_len == sizeof(sa), "got %d\n", sa_len);
7516
7517 closesocket(sock);
7518 }
7519
7520 static void test_sioRoutingInterfaceQuery(void)
7521 {
7522 int ret;
7523 SOCKET sock;
7524 SOCKADDR_IN sin = { 0 }, sout = { 0 };
7525 DWORD bytesReturned;
7526
7527 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
7528 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
7529 if (sock == INVALID_SOCKET)
7530 {
7531 skip("Socket creation failed with %d\n", WSAGetLastError());
7532 return;
7533 }
7534 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, NULL, 0, NULL, 0, NULL,
7535 NULL, NULL);
7536 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
7537 "expected WSAEFAULT, got %d\n", WSAGetLastError());
7538 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
7539 NULL, 0, NULL, NULL, NULL);
7540 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
7541 "expected WSAEFAULT, got %d\n", WSAGetLastError());
7542 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
7543 NULL, 0, &bytesReturned, NULL, NULL);
7544 ok(ret == SOCKET_ERROR &&
7545 (WSAGetLastError() == WSAEFAULT /* Win98 */ ||
7546 WSAGetLastError() == WSAEINVAL /* NT4 */||
7547 WSAGetLastError() == WSAEAFNOSUPPORT),
7548 "expected WSAEFAULT or WSAEINVAL or WSAEAFNOSUPPORT, got %d\n",
7549 WSAGetLastError());
7550 sin.sin_family = AF_INET;
7551 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
7552 NULL, 0, &bytesReturned, NULL, NULL);
7553 ok(ret == SOCKET_ERROR &&
7554 (WSAGetLastError() == WSAEFAULT /* Win98 */ ||
7555 WSAGetLastError() == WSAEINVAL),
7556 "expected WSAEFAULT or WSAEINVAL, got %d\n", WSAGetLastError());
7557 sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
7558 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
7559 NULL, 0, &bytesReturned, NULL, NULL);
7560 ok(ret == SOCKET_ERROR &&
7561 (WSAGetLastError() == WSAEINVAL /* NT4 */ ||
7562 WSAGetLastError() == WSAEFAULT),
7563 "expected WSAEINVAL or WSAEFAULT, got %d\n", WSAGetLastError());
7564 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
7565 &sout, sizeof(sout), &bytesReturned, NULL, NULL);
7566 ok(!ret || broken(WSAGetLastError() == WSAEINVAL /* NT4 */),
7567 "WSAIoctl failed: %d\n", WSAGetLastError());
7568 if (!ret)
7569 {
7570 ok(sout.sin_family == AF_INET, "expected AF_INET, got %d\n",
7571 sout.sin_family);
7572 /* We expect the source address to be INADDR_LOOPBACK as well, but
7573 * there's no guarantee that a route to the loopback address exists,
7574 * so rather than introduce spurious test failures we do not test the
7575 * source address.
7576 */
7577 }
7578 closesocket(sock);
7579 }
7580
7581 static void test_sioAddressListChange(void)
7582 {
7583 struct sockaddr_in bindAddress;
7584 struct in_addr net_address;
7585 WSAOVERLAPPED overlapped;
7586 struct hostent *h;
7587 DWORD num_bytes;
7588 SOCKET sock;
7589 int acount;
7590 int ret;
7591
7592 if (!winetest_interactive)
7593 {
7594 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
7595 return;
7596 }
7597
7598 /* Use gethostbyname to find the list of local network interfaces */
7599 h = gethostbyname("");
7600 if (!h)
7601 {
7602 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, gethostbyname failed with %u\n",
7603 WSAGetLastError());
7604 return;
7605 }
7606 for (acount = 0; h->h_addr_list[acount]; acount++);
7607 if (acount == 0)
7608 {
7609 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
7610 return;
7611 }
7612 net_address.s_addr = *(ULONG *) h->h_addr_list[0];
7613
7614 /* Bind an overlapped socket to the first found network interface */
7615 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
7616 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
7617 if (sock == INVALID_SOCKET)
7618 {
7619 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, socket creation failed with %u\n",
7620 WSAGetLastError());
7621 return;
7622 }
7623 memset(&bindAddress, 0, sizeof(bindAddress));
7624 bindAddress.sin_family = AF_INET;
7625 bindAddress.sin_addr.s_addr = net_address.s_addr;
7626 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7627 if (ret != 0)
7628 {
7629 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, failed to bind, error %u\n", WSAGetLastError());
7630 goto end;
7631 }
7632
7633 /* Wait for address changes, request that the user connects/disconnects an interface */
7634 memset(&overlapped, 0, sizeof(overlapped));
7635 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
7636 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
7637 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
7638 ok(WSAGetLastError() == WSA_IO_PENDING, "Expected pending last error %d\n", WSAGetLastError());
7639 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
7640 " change the ipv4 address of any of the local network interfaces (10 second timeout).\n");
7641 ret = WaitForSingleObject(overlapped.hEvent, 10000);
7642 ok(ret == WAIT_OBJECT_0, "failed to get overlapped event %u\n", ret);
7643
7644 end:
7645 closesocket(sock);
7646 }
7647
7648 static void test_synchronous_WSAIoctl(void)
7649 {
7650 HANDLE previous_port, io_port;
7651 WSAOVERLAPPED overlapped, *olp;
7652 SOCKET socket;
7653 ULONG on;
7654 ULONG_PTR key;
7655 DWORD num_bytes;
7656 BOOL ret;
7657 int res;
7658
7659 previous_port = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );
7660 ok( previous_port != NULL, "failed to create completion port %u\n", GetLastError() );
7661
7662 socket = WSASocketW( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED );
7663 ok( socket != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError() );
7664
7665 io_port = CreateIoCompletionPort( (HANDLE)socket, previous_port, 0, 0 );
7666 ok( io_port != NULL, "failed to create completion port %u\n", GetLastError() );
7667
7668 on = 1;
7669 memset( &overlapped, 0, sizeof(overlapped) );
7670 res = WSAIoctl( socket, FIONBIO, &on, sizeof(on), NULL, 0, &num_bytes, &overlapped, NULL );
7671 ok( !res, "WSAIoctl failed %d\n", WSAGetLastError() );
7672
7673 ret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 10000 );
7674 ok( ret, "failed to get completion status %u\n", GetLastError() );
7675
7676 CloseHandle( io_port );
7677 closesocket( socket );
7678 CloseHandle( previous_port );
7679 }
7680
7681 #define WM_ASYNCCOMPLETE (WM_USER + 100)
7682 static HWND create_async_message_window(void)
7683 {
7684 static const char class_name[] = "ws2_32 async message window class";
7685
7686 WNDCLASSEXA wndclass;
7687 HWND hWnd;
7688
7689 wndclass.cbSize = sizeof(wndclass);
7690 wndclass.style = CS_HREDRAW | CS_VREDRAW;
7691 wndclass.lpfnWndProc = DefWindowProcA;
7692 wndclass.cbClsExtra = 0;
7693 wndclass.cbWndExtra = 0;
7694 wndclass.hInstance = GetModuleHandleA(NULL);
7695 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
7696 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
7697 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
7698 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
7699 wndclass.lpszClassName = class_name;
7700 wndclass.lpszMenuName = NULL;
7701
7702 RegisterClassExA(&wndclass);
7703
7704 hWnd = CreateWindowA(class_name, "ws2_32 async message window", WS_OVERLAPPEDWINDOW,
7705 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
7706 if (!hWnd)
7707 {
7708 ok(0, "failed to create window: %u\n", GetLastError());
7709 return NULL;
7710 }
7711
7712 return hWnd;
7713 }
7714
7715 static void test_WSAAsyncGetServByPort(void)
7716 {
7717 HWND hwnd = create_async_message_window();
7718 HANDLE ret;
7719 char buffer[MAXGETHOSTSTRUCT];
7720
7721 if (!hwnd)
7722 return;
7723
7724 /* FIXME: The asynchronous window messages should be tested. */
7725
7726 /* Parameters are not checked when initiating the asynchronous operation. */
7727 ret = WSAAsyncGetServByPort(NULL, 0, 0, NULL, NULL, 0);
7728 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
7729
7730 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, 0, NULL, NULL, 0);
7731 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
7732
7733 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, NULL, 0);
7734 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
7735
7736 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, buffer, MAXGETHOSTSTRUCT);
7737 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
7738
7739 DestroyWindow(hwnd);
7740 }
7741
7742 static void test_WSAAsyncGetServByName(void)
7743 {
7744 HWND hwnd = create_async_message_window();
7745 HANDLE ret;
7746 char buffer[MAXGETHOSTSTRUCT];
7747
7748 if (!hwnd)
7749 return;
7750
7751 /* FIXME: The asynchronous window messages should be tested. */
7752
7753 /* Parameters are not checked when initiating the asynchronous operation. */
7754 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", NULL, NULL, 0);
7755 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
7756
7757 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", "", buffer, MAXGETHOSTSTRUCT);
7758 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
7759
7760 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", NULL, NULL, 0);
7761 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
7762
7763 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", "tcp", buffer, MAXGETHOSTSTRUCT);
7764 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
7765
7766 DestroyWindow(hwnd);
7767 }
7768
7769 /*
7770 * Provide consistent initialization for the AcceptEx IOCP tests.
7771 */
7772 static SOCKET setup_iocp_src(struct sockaddr_in *bindAddress)
7773 {
7774 SOCKET src, ret = INVALID_SOCKET;
7775 int iret, socklen;
7776
7777 src = socket(AF_INET, SOCK_STREAM, 0);
7778 if (src == INVALID_SOCKET)
7779 {
7780 skip("could not create listener socket, error %d\n", WSAGetLastError());
7781 goto end;
7782 }
7783
7784 memset(bindAddress, 0, sizeof(*bindAddress));
7785 bindAddress->sin_family = AF_INET;
7786 bindAddress->sin_addr.s_addr = inet_addr("127.0.0.1");
7787 iret = bind(src, (struct sockaddr*)bindAddress, sizeof(*bindAddress));
7788 if (iret != 0)
7789 {
7790 skip("failed to bind, error %d\n", WSAGetLastError());
7791 goto end;
7792 }
7793
7794 socklen = sizeof(*bindAddress);
7795 iret = getsockname(src, (struct sockaddr*)bindAddress, &socklen);
7796 if (iret != 0) {
7797 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
7798 goto end;
7799 }
7800
7801 if (set_blocking(src, FALSE))
7802 {
7803 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7804 goto end;
7805 }
7806
7807 iret = listen(src, 5);
7808 if (iret != 0)
7809 {
7810 skip("listening failed, errno = %d\n", WSAGetLastError());
7811 goto end;
7812 }
7813
7814 ret = src;
7815 end:
7816 if (src != ret && ret == INVALID_SOCKET)
7817 closesocket(src);
7818 return ret;
7819 }
7820
7821 static void test_completion_port(void)
7822 {
7823 HANDLE previous_port, io_port;
7824 WSAOVERLAPPED ov, *olp;
7825 SOCKET src, dest, dup, connector = INVALID_SOCKET;
7826 WSAPROTOCOL_INFOA info;
7827 char buf[1024];
7828 WSABUF bufs;
7829 DWORD num_bytes, flags;
7830 struct linger ling;
7831 int iret;
7832 BOOL bret;
7833 ULONG_PTR key;
7834 struct sockaddr_in bindAddress;
7835 GUID acceptExGuid = WSAID_ACCEPTEX;
7836 LPFN_ACCEPTEX pAcceptEx = NULL;
7837
7838 memset(buf, 0, sizeof(buf));
7839 previous_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
7840 ok( previous_port != NULL, "Failed to create completion port %u\n", GetLastError());
7841
7842 memset(&ov, 0, sizeof(ov));
7843
7844 tcp_socketpair(&src, &dest);
7845 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
7846 {
7847 skip("failed to create sockets\n");
7848 goto end;
7849 }
7850
7851 bufs.len = sizeof(buf);
7852 bufs.buf = buf;
7853 flags = 0;
7854
7855 ling.l_onoff = 1;
7856 ling.l_linger = 0;
7857 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
7858 ok(!iret, "Failed to set linger %d\n", GetLastError());
7859
7860 io_port = CreateIoCompletionPort( (HANDLE)dest, previous_port, 125, 0 );
7861 ok(io_port != NULL, "Failed to create completion port %u\n", GetLastError());
7862
7863 SetLastError(0xdeadbeef);
7864
7865 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
7866 ok(iret == SOCKET_ERROR, "WSARecv returned %d\n", iret);
7867 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
7868
7869 Sleep(100);
7870
7871 closesocket(src);
7872 src = INVALID_SOCKET;
7873
7874 SetLastError(0xdeadbeef);
7875 key = 0xdeadbeef;
7876 num_bytes = 0xdeadbeef;
7877 olp = (WSAOVERLAPPED *)0xdeadbeef;
7878
7879 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
7880 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret);
7881 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED, "Last error was %d\n", GetLastError());
7882 ok(key == 125, "Key is %lu\n", key);
7883 ok(num_bytes == 0, "Number of bytes received is %u\n", num_bytes);
7884 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
7885
7886 SetLastError(0xdeadbeef);
7887 key = 0xdeadbeef;
7888 num_bytes = 0xdeadbeef;
7889 olp = (WSAOVERLAPPED *)0xdeadbeef;
7890
7891 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
7892 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret );
7893 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7894 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7895 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7896 ok(!olp, "Overlapped structure is at %p\n", olp);
7897
7898 if (dest != INVALID_SOCKET)
7899 closesocket(dest);
7900
7901 memset(&ov, 0, sizeof(ov));
7902
7903 tcp_socketpair(&src, &dest);
7904 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
7905 {
7906 skip("failed to create sockets\n");
7907 goto end;
7908 }
7909
7910 bufs.len = sizeof(buf);
7911 bufs.buf = buf;
7912 flags = 0;
7913
7914 ling.l_onoff = 1;
7915 ling.l_linger = 0;
7916 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
7917 ok(!iret, "Failed to set linger %d\n", GetLastError());
7918
7919 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
7920 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
7921
7922 set_blocking(dest, FALSE);
7923
7924 closesocket(src);
7925 src = INVALID_SOCKET;
7926
7927 Sleep(100);
7928
7929 num_bytes = 0xdeadbeef;
7930 SetLastError(0xdeadbeef);
7931
7932 iret = WSASend(dest, &bufs, 1, &num_bytes, 0, &ov, NULL);
7933 ok(iret == SOCKET_ERROR, "WSASend failed - %d\n", iret);
7934 ok(GetLastError() == WSAECONNRESET, "Last error was %d\n", GetLastError());
7935 ok(num_bytes == 0xdeadbeef, "Managed to send %d\n", num_bytes);
7936
7937 SetLastError(0xdeadbeef);
7938 key = 0xdeadbeef;
7939 num_bytes = 0xdeadbeef;
7940 olp = (WSAOVERLAPPED *)0xdeadbeef;
7941
7942 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
7943 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
7944 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7945 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7946 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7947 ok(!olp, "Overlapped structure is at %p\n", olp);
7948
7949 if (dest != INVALID_SOCKET)
7950 closesocket(dest);
7951
7952 dest = socket(AF_INET, SOCK_STREAM, 0);
7953 if (dest == INVALID_SOCKET)
7954 {
7955 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7956 goto end;
7957 }
7958
7959 iret = WSAIoctl(dest, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
7960 &pAcceptEx, sizeof(pAcceptEx), &num_bytes, NULL, NULL);
7961 if (iret)
7962 {
7963 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
7964 goto end;
7965 }
7966
7967 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
7968
7969 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
7970 goto end;
7971
7972 SetLastError(0xdeadbeef);
7973
7974 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
7975 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7976 &num_bytes, &ov);
7977 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
7978 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
7979
7980 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
7981 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
7982
7983 closesocket(src);
7984 src = INVALID_SOCKET;
7985
7986 SetLastError(0xdeadbeef);
7987 key = 0xdeadbeef;
7988 num_bytes = 0xdeadbeef;
7989 olp = (WSAOVERLAPPED *)0xdeadbeef;
7990
7991 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
7992 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7993 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
7994 ok(key == 125, "Key is %lu\n", key);
7995 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
7996 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
7997 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
7998
7999 SetLastError(0xdeadbeef);
8000 key = 0xdeadbeef;
8001 num_bytes = 0xdeadbeef;
8002 olp = (WSAOVERLAPPED *)0xdeadbeef;
8003 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8004 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8005 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8006 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8007 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8008 ok(!olp, "Overlapped structure is at %p\n", olp);
8009
8010 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
8011
8012 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8013 goto end;
8014
8015 SetLastError(0xdeadbeef);
8016
8017 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8018 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8019
8020 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8021 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8022 &num_bytes, &ov);
8023 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8024 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8025
8026 closesocket(src);
8027 src = INVALID_SOCKET;
8028
8029 SetLastError(0xdeadbeef);
8030 key = 0xdeadbeef;
8031 num_bytes = 0xdeadbeef;
8032 olp = (WSAOVERLAPPED *)0xdeadbeef;
8033
8034 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8035 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8036 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8037 ok(key == 125, "Key is %lu\n", key);
8038 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8039 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8040 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8041
8042 SetLastError(0xdeadbeef);
8043 key = 0xdeadbeef;
8044 num_bytes = 0xdeadbeef;
8045 olp = (WSAOVERLAPPED *)0xdeadbeef;
8046 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8047 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8048 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8049 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8050 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8051 ok(!olp, "Overlapped structure is at %p\n", olp);
8052
8053 /* Test IOCP with duplicated handle */
8054
8055 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8056 goto end;
8057
8058 SetLastError(0xdeadbeef);
8059
8060 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8061 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8062
8063 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
8064 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
8065 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
8066
8067 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8068 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8069 &num_bytes, &ov);
8070 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8071 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8072
8073 SetLastError(0xdeadbeef);
8074 key = 0xdeadbeef;
8075 num_bytes = 0xdeadbeef;
8076 olp = (WSAOVERLAPPED *)0xdeadbeef;
8077 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8078 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8079 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8080 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8081 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8082 ok(!olp, "Overlapped structure is at %p\n", olp);
8083
8084 closesocket(src);
8085 src = INVALID_SOCKET;
8086 closesocket(dup);
8087 dup = INVALID_SOCKET;
8088
8089 SetLastError(0xdeadbeef);
8090 key = 0xdeadbeef;
8091 num_bytes = 0xdeadbeef;
8092 olp = (WSAOVERLAPPED *)0xdeadbeef;
8093 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8094 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8095 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8096 ok(key == 125, "Key is %lu\n", key);
8097 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8098 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8099 ok(olp && olp->Internal == (ULONG)STATUS_CANCELLED, "Internal status is %lx\n", olp ? olp->Internal : 0);
8100
8101 SetLastError(0xdeadbeef);
8102 key = 0xdeadbeef;
8103 num_bytes = 0xdeadbeef;
8104 olp = (WSAOVERLAPPED *)0xdeadbeef;
8105 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8106 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8107 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8108 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8109 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8110 ok(!olp, "Overlapped structure is at %p\n", olp);
8111
8112 /* Test IOCP with duplicated handle (closing duplicated handle) */
8113
8114 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8115 goto end;
8116
8117 SetLastError(0xdeadbeef);
8118
8119 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8120 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8121
8122 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
8123 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
8124 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
8125
8126 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8127 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8128 &num_bytes, &ov);
8129 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8130 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8131
8132 closesocket(dup);
8133 dup = INVALID_SOCKET;
8134
8135 SetLastError(0xdeadbeef);
8136 key = 0xdeadbeef;
8137 num_bytes = 0xdeadbeef;
8138 olp = (WSAOVERLAPPED *)0xdeadbeef;
8139 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8140 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8141 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8142 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8143 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8144 ok(!olp, "Overlapped structure is at %p\n", olp);
8145
8146 SetLastError(0xdeadbeef);
8147 key = 0xdeadbeef;
8148 num_bytes = 0xdeadbeef;
8149 olp = (WSAOVERLAPPED *)0xdeadbeef;
8150 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8151 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8152 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8153 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8154 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8155 ok(!olp, "Overlapped structure is at %p\n", olp);
8156
8157 closesocket(src);
8158 src = INVALID_SOCKET;
8159
8160 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8161 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8162 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8163 ok(key == 125, "Key is %lu\n", key);
8164 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8165 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8166 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8167
8168 SetLastError(0xdeadbeef);
8169 key = 0xdeadbeef;
8170 num_bytes = 0xdeadbeef;
8171 olp = (WSAOVERLAPPED *)0xdeadbeef;
8172 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8173 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8174 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8175 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8176 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8177 ok(!olp, "Overlapped structure is at %p\n", olp);
8178
8179 /* Test IOCP with duplicated handle (closing original handle) */
8180
8181 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8182 goto end;
8183
8184 SetLastError(0xdeadbeef);
8185
8186 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8187 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8188
8189 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
8190 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
8191 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
8192
8193 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8194 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8195 &num_bytes, &ov);
8196 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8197 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8198
8199 closesocket(src);
8200 src = INVALID_SOCKET;
8201
8202 SetLastError(0xdeadbeef);
8203 key = 0xdeadbeef;
8204 num_bytes = 0xdeadbeef;
8205 olp = (WSAOVERLAPPED *)0xdeadbeef;
8206 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8207 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8208 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8209 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8210 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8211 ok(!olp, "Overlapped structure is at %p\n", olp);
8212
8213 closesocket(dup);
8214 dup = INVALID_SOCKET;
8215
8216 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8217 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8218 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8219 ok(key == 125, "Key is %lu\n", key);
8220 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8221 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8222 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8223
8224 SetLastError(0xdeadbeef);
8225 key = 0xdeadbeef;
8226 num_bytes = 0xdeadbeef;
8227 olp = (WSAOVERLAPPED *)0xdeadbeef;
8228 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8229 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8230 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8231 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8232 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8233 ok(!olp, "Overlapped structure is at %p\n", olp);
8234
8235 /* Test IOCP without AcceptEx */
8236
8237 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8238 goto end;
8239
8240 SetLastError(0xdeadbeef);
8241
8242 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8243 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8244
8245 closesocket(src);
8246 src = INVALID_SOCKET;
8247
8248 SetLastError(0xdeadbeef);
8249 key = 0xdeadbeef;
8250 num_bytes = 0xdeadbeef;
8251 olp = (WSAOVERLAPPED *)0xdeadbeef;
8252 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8253 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8254 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8255 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8256 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8257 ok(!olp, "Overlapped structure is at %p\n", olp);
8258
8259 /* */
8260
8261 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8262 goto end;
8263
8264 connector = socket(AF_INET, SOCK_STREAM, 0);
8265 if (connector == INVALID_SOCKET) {
8266 skip("could not create connector socket, error %d\n", WSAGetLastError());
8267 goto end;
8268 }
8269
8270 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8271 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8272
8273 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
8274 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8275
8276 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8277 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8278 &num_bytes, &ov);
8279 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8280 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8281
8282 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8283 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8284
8285 closesocket(connector);
8286 connector = INVALID_SOCKET;
8287
8288 SetLastError(0xdeadbeef);
8289 key = 0xdeadbeef;
8290 num_bytes = 0xdeadbeef;
8291 olp = (WSAOVERLAPPED *)0xdeadbeef;
8292
8293 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8294 ok(bret == TRUE, "failed to get completion status %u\n", bret);
8295 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8296 ok(key == 125, "Key is %lu\n", key);
8297 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8298 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8299 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
8300
8301 SetLastError(0xdeadbeef);
8302 key = 0xdeadbeef;
8303 num_bytes = 0xdeadbeef;
8304 olp = (WSAOVERLAPPED *)0xdeadbeef;
8305 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8306 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8307 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8308 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8309 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8310 ok(!olp, "Overlapped structure is at %p\n", olp);
8311
8312 if (dest != INVALID_SOCKET)
8313 closesocket(dest);
8314 if (src != INVALID_SOCKET)
8315 closesocket(dest);
8316
8317 /* */
8318
8319 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8320 goto end;
8321
8322 dest = socket(AF_INET, SOCK_STREAM, 0);
8323 if (dest == INVALID_SOCKET)
8324 {
8325 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8326 goto end;
8327 }
8328
8329 connector = socket(AF_INET, SOCK_STREAM, 0);
8330 if (connector == INVALID_SOCKET) {
8331 skip("could not create connector socket, error %d\n", WSAGetLastError());
8332 goto end;
8333 }
8334
8335 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8336 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8337
8338 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
8339 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8340
8341 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8342 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8343 &num_bytes, &ov);
8344 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8345 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8346
8347 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8348 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8349
8350 iret = send(connector, buf, 1, 0);
8351 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
8352
8353 Sleep(100);
8354
8355 closesocket(dest);
8356 dest = INVALID_SOCKET;
8357
8358 SetLastError(0xdeadbeef);
8359 key = 0xdeadbeef;
8360 num_bytes = 0xdeadbeef;
8361 olp = (WSAOVERLAPPED *)0xdeadbeef;
8362
8363 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8364 ok(bret == TRUE, "failed to get completion status %u\n", bret);
8365 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8366 ok(key == 125, "Key is %lu\n", key);
8367 ok(num_bytes == 1, "Number of bytes transferred is %u\n", num_bytes);
8368 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8369 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
8370
8371 SetLastError(0xdeadbeef);
8372 key = 0xdeadbeef;
8373 num_bytes = 0xdeadbeef;
8374 olp = (WSAOVERLAPPED *)0xdeadbeef;
8375 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8376 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8377 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8378 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8379 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8380 ok(!olp, "Overlapped structure is at %p\n", olp);
8381
8382 if (src != INVALID_SOCKET)
8383 closesocket(src);
8384 if (connector != INVALID_SOCKET)
8385 closesocket(connector);
8386
8387 /* */
8388
8389 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8390 goto end;
8391
8392 dest = socket(AF_INET, SOCK_STREAM, 0);
8393 if (dest == INVALID_SOCKET)
8394 {
8395 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8396 goto end;
8397 }
8398
8399 connector = socket(AF_INET, SOCK_STREAM, 0);
8400 if (connector == INVALID_SOCKET) {
8401 skip("could not create connector socket, error %d\n", WSAGetLastError());
8402 goto end;
8403 }
8404
8405 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8406 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8407
8408 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
8409 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8410
8411 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8412 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8413 &num_bytes, &ov);
8414 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8415 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8416
8417 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8418 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8419
8420 closesocket(dest);
8421 dest = INVALID_SOCKET;
8422
8423 SetLastError(0xdeadbeef);
8424 key = 0xdeadbeef;
8425 num_bytes = 0xdeadbeef;
8426 olp = (WSAOVERLAPPED *)0xdeadbeef;
8427
8428 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8429 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8430 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED ||
8431 GetLastError() == ERROR_OPERATION_ABORTED ||
8432 GetLastError() == ERROR_CONNECTION_ABORTED ||
8433 GetLastError() == ERROR_PIPE_NOT_CONNECTED /* win 2000 */,
8434 "Last error was %d\n", GetLastError());
8435 ok(key == 125, "Key is %lu\n", key);
8436 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8437 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8438 todo_wine ok(olp && (olp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT ||
8439 olp->Internal == (ULONG)STATUS_CANCELLED ||
8440 olp->Internal == (ULONG)STATUS_CONNECTION_ABORTED ||
8441 olp->Internal == (ULONG)STATUS_PIPE_DISCONNECTED /* win 2000 */),
8442 "Internal status is %lx\n", olp ? olp->Internal : 0);
8443
8444 SetLastError(0xdeadbeef);
8445 key = 0xdeadbeef;
8446 num_bytes = 0xdeadbeef;
8447 olp = (WSAOVERLAPPED *)0xdeadbeef;
8448 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8449 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8450 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8451 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8452 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8453 ok(!olp, "Overlapped structure is at %p\n", olp);
8454
8455
8456 end:
8457 if (dest != INVALID_SOCKET)
8458 closesocket(dest);
8459 if (src != INVALID_SOCKET)
8460 closesocket(src);
8461 if (connector != INVALID_SOCKET)
8462 closesocket(connector);
8463 CloseHandle(previous_port);
8464 }
8465
8466 static void test_address_list_query(void)
8467 {
8468 SOCKET_ADDRESS_LIST *address_list;
8469 DWORD bytes_returned, size;
8470 unsigned int i;
8471 SOCKET s;
8472 int ret;
8473
8474 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8475 ok(s != INVALID_SOCKET, "Failed to create socket, error %d.\n", WSAGetLastError());
8476
8477 bytes_returned = 0;
8478 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0, &bytes_returned, NULL, NULL);
8479 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
8480 if(WSAGetLastError() == WSAEINVAL)
8481 {
8482 win_skip("Windows <= NT4 is not supported in this test\n");
8483 closesocket(s);
8484 return;
8485 }
8486 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
8487 ok(bytes_returned >= FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]),
8488 "Got unexpected bytes_returned %u.\n", bytes_returned);
8489
8490 size = bytes_returned;
8491 bytes_returned = 0;
8492 address_list = HeapAlloc(GetProcessHeap(), 0, size * 2);
8493 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, size * 2, &bytes_returned, NULL, NULL);
8494 ok(!ret, "Got unexpected ret %d, error %d.\n", ret, WSAGetLastError());
8495 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
8496
8497 bytes_returned = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[address_list->iAddressCount]);
8498 for (i = 0; i < address_list->iAddressCount; ++i)
8499 {
8500 bytes_returned += address_list->Address[i].iSockaddrLength;
8501 }
8502 ok(size == bytes_returned, "Got unexpected size %u, expected %u.\n", size, bytes_returned);
8503
8504 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, size, NULL, NULL, NULL);
8505 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
8506 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
8507
8508 bytes_returned = 0xdeadbeef;
8509 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, size, &bytes_returned, NULL, NULL);
8510 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
8511 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
8512 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
8513
8514 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, 1, &bytes_returned, NULL, NULL);
8515 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
8516 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
8517 ok(bytes_returned == 0, "Got unexpected bytes_returned %u.\n", bytes_returned);
8518
8519 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list,
8520 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &bytes_returned, NULL, NULL);
8521 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
8522 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
8523 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
8524
8525 HeapFree(GetProcessHeap(), 0, address_list);
8526 closesocket(s);
8527 }
8528
8529 static DWORD WINAPI inet_ntoa_thread_proc(void *param)
8530 {
8531 ULONG addr;
8532 const char *str;
8533 HANDLE *event = param;
8534
8535 addr = inet_addr("4.3.2.1");
8536 ok(addr == htonl(0x04030201), "expected 0x04030201, got %08x\n", addr);
8537 str = inet_ntoa(*(struct in_addr *)&addr);
8538 ok(!strcmp(str, "4.3.2.1"), "expected 4.3.2.1, got %s\n", str);
8539
8540 SetEvent(event[0]);
8541 WaitForSingleObject(event[1], 3000);
8542
8543 return 0;
8544 }
8545
8546 static void test_inet_ntoa(void)
8547 {
8548 ULONG addr;
8549 const char *str;
8550 HANDLE thread, event[2];
8551 DWORD tid;
8552
8553 addr = inet_addr("1.2.3.4");
8554 ok(addr == htonl(0x01020304), "expected 0x01020304, got %08x\n", addr);
8555 str = inet_ntoa(*(struct in_addr *)&addr);
8556 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
8557
8558 event[0] = CreateEventW(NULL, TRUE, FALSE, NULL);
8559 event[1] = CreateEventW(NULL, TRUE, FALSE, NULL);
8560
8561 thread = CreateThread(NULL, 0, inet_ntoa_thread_proc, event, 0, &tid);
8562 WaitForSingleObject(event[0], 3000);
8563
8564 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
8565
8566 SetEvent(event[1]);
8567 WaitForSingleObject(thread, 3000);
8568
8569 CloseHandle(event[0]);
8570 CloseHandle(event[1]);
8571 CloseHandle(thread);
8572 }
8573
8574 static void test_WSALookupService(void)
8575 {
8576 char buffer[4096], strbuff[128];
8577 WSAQUERYSETW *qs = NULL;
8578 HANDLE hnd;
8579 PNLA_BLOB netdata;
8580 int ret;
8581 DWORD error, offset, bsize;
8582
8583 if (!pWSALookupServiceBeginW || !pWSALookupServiceEnd || !pWSALookupServiceNextW)
8584 {
8585 win_skip("WSALookupServiceBeginW or WSALookupServiceEnd or WSALookupServiceNextW not found\n");
8586 return;
8587 }
8588
8589 qs = (WSAQUERYSETW *)buffer;
8590 memset(qs, 0, sizeof(*qs));
8591
8592 /* invalid parameter tests */
8593 ret = pWSALookupServiceBeginW(NULL, 0, &hnd);
8594 error = WSAGetLastError();
8595 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
8596 todo_wine
8597 ok(error == WSAEFAULT, "expected 10014, got %d\n", error);
8598
8599 ret = pWSALookupServiceBeginW(qs, 0, NULL);
8600 error = WSAGetLastError();
8601 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
8602 todo_wine
8603 ok(error == WSAEFAULT, "expected 10014, got %d\n", error);
8604
8605 ret = pWSALookupServiceBeginW(qs, 0, &hnd);
8606 error = WSAGetLastError();
8607 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
8608 todo_wine
8609 ok(error == WSAEINVAL
8610 || broken(error == ERROR_INVALID_PARAMETER) /* == XP */
8611 || broken(error == WSAEFAULT) /* == NT */
8612 || broken(error == WSASERVICE_NOT_FOUND) /* == 2000 */,
8613 "expected 10022, got %d\n", error);
8614
8615 ret = pWSALookupServiceEnd(NULL);
8616 error = WSAGetLastError();
8617 todo_wine
8618 ok(ret == SOCKET_ERROR, "WSALookupServiceEnd should have failed\n");
8619 todo_wine
8620 ok(error == ERROR_INVALID_HANDLE, "expected 6, got %d\n", error);
8621
8622 /* standard network list query */
8623 qs->dwSize = sizeof(*qs);
8624 hnd = (HANDLE)0xdeadbeef;
8625 ret = pWSALookupServiceBeginW(qs, LUP_RETURN_ALL | LUP_DEEP, &hnd);
8626 error = WSAGetLastError();
8627 if(ret && error == ERROR_INVALID_PARAMETER)
8628 {
8629 win_skip("the current WSALookupServiceBeginW test is not supported in win <= 2000\n");
8630 return;
8631 }
8632
8633 todo_wine
8634 ok(!ret, "WSALookupServiceBeginW failed unexpectedly with error %d\n", error);
8635 todo_wine
8636 ok(hnd != (HANDLE)0xdeadbeef, "Handle was not filled\n");
8637
8638 offset = 0;
8639 do
8640 {
8641 memset(qs, 0, sizeof(*qs));
8642 bsize = sizeof(buffer);
8643
8644 if (pWSALookupServiceNextW(hnd, 0, &bsize, qs) == SOCKET_ERROR)
8645 {
8646 error = WSAGetLastError();
8647 if (error == WSA_E_NO_MORE) break;
8648 ok(0, "Error %d happened while listing services\n", error);
8649 break;
8650 }
8651
8652 WideCharToMultiByte(CP_ACP, 0, qs->lpszServiceInstanceName, -1,
8653 strbuff, sizeof(strbuff), NULL, NULL);
8654 trace("Network Name: %s\n", strbuff);
8655
8656 /* network data is written in the blob field */
8657 if (qs->lpBlob)
8658 {
8659 /* each network may have multiple NLA_BLOB information structures */
8660 do
8661 {
8662 netdata = (PNLA_BLOB) &qs->lpBlob->pBlobData[offset];
8663 switch (netdata->header.type)
8664 {
8665 case NLA_RAW_DATA:
8666 trace("\tNLA Data Type: NLA_RAW_DATA\n");
8667 break;
8668 case NLA_INTERFACE:
8669 trace("\tNLA Data Type: NLA_INTERFACE\n");
8670 trace("\t\tType: %d\n", netdata->data.interfaceData.dwType);
8671 trace("\t\tSpeed: %d\n", netdata->data.interfaceData.dwSpeed);
8672 trace("\t\tAdapter Name: %s\n", netdata->data.interfaceData.adapterName);
8673 break;
8674 case NLA_802_1X_LOCATION:
8675 trace("\tNLA Data Type: NLA_802_1X_LOCATION\n");
8676 trace("\t\tInformation: %s\n", netdata->data.locationData.information);
8677 break;
8678 case NLA_CONNECTIVITY:
8679 switch (netdata->data.connectivity.type)
8680 {
8681 case NLA_NETWORK_AD_HOC:
8682 trace("\t\tNetwork Type: AD HOC\n");
8683 break;
8684 case NLA_NETWORK_MANAGED:
8685 trace("\t\tNetwork Type: Managed\n");
8686 break;
8687 case NLA_NETWORK_UNMANAGED:
8688 trace("\t\tNetwork Type: Unmanaged\n");
8689 break;
8690 case NLA_NETWORK_UNKNOWN:
8691 trace("\t\tNetwork Type: Unknown\n");
8692 }
8693 switch (netdata->data.connectivity.internet)
8694 {
8695 case NLA_INTERNET_NO:
8696 trace("\t\tInternet connectivity: No\n");
8697 break;
8698 case NLA_INTERNET_YES:
8699 trace("\t\tInternet connectivity: Yes\n");
8700 break;
8701 case NLA_INTERNET_UNKNOWN:
8702 trace("\t\tInternet connectivity: Unknown\n");
8703 break;
8704 }
8705 break;
8706 case NLA_ICS:
8707 trace("\tNLA Data Type: NLA_ICS\n");
8708 trace("\t\tSpeed: %d\n",
8709 netdata->data.ICS.remote.speed);
8710 trace("\t\tType: %d\n",
8711 netdata->data.ICS.remote.type);
8712 trace("\t\tState: %d\n",
8713 netdata->data.ICS.remote.state);
8714 WideCharToMultiByte(CP_ACP, 0, netdata->data.ICS.remote.machineName, -1,
8715 strbuff, sizeof(strbuff), NULL, NULL);
8716 trace("\t\tMachine Name: %s\n", strbuff);
8717 WideCharToMultiByte(CP_ACP, 0, netdata->data.ICS.remote.sharedAdapterName, -1,
8718 strbuff, sizeof(strbuff), NULL, NULL);
8719 trace("\t\tShared Adapter Name: %s\n", strbuff);
8720 break;
8721 default:
8722 trace("\tNLA Data Type: Unknown\n");
8723 break;
8724 }
8725 }
8726 while (offset);
8727 }
8728 }
8729 while (1);
8730
8731 ret = pWSALookupServiceEnd(hnd);
8732 ok(!ret, "WSALookupServiceEnd failed unexpectedly\n");
8733 }
8734
8735 /**************** Main program ***************/
8736
8737 START_TEST( sock )
8738 {
8739 int i;
8740
8741 /* Leave these tests at the beginning. They depend on WSAStartup not having been
8742 * called, which is done by Init() below. */
8743 test_WithoutWSAStartup();
8744 test_WithWSAStartup();
8745
8746 Init();
8747
8748 test_inet_ntoa();
8749 test_inet_pton();
8750 test_set_getsockopt();
8751 test_so_reuseaddr();
8752 test_ip_pktinfo();
8753 test_extendedSocketOptions();
8754
8755 for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
8756 {
8757 trace ( " **** STARTING TEST %d ****\n", i );
8758 do_test ( &tests[i] );
8759 trace ( " **** TEST %d COMPLETE ****\n", i );
8760 }
8761
8762 test_UDP();
8763
8764 test_getservbyname();
8765 test_WSASocket();
8766 test_WSADuplicateSocket();
8767 test_WSAEnumNetworkEvents();
8768
8769 test_WSAAddressToStringA();
8770 test_WSAAddressToStringW();
8771
8772 test_WSAStringToAddressA();
8773 test_WSAStringToAddressW();
8774
8775 test_errors();
8776 test_listen();
8777 test_select();
8778 test_accept();
8779 test_getpeername();
8780 test_getsockname();
8781 test_inet_addr();
8782 test_addr_to_print();
8783 test_ioctlsocket();
8784 test_dns();
8785 test_gethostbyname_hack();
8786 test_gethostname();
8787
8788 test_WSASendMsg();
8789 test_WSASendTo();
8790 test_WSARecv();
8791
8792 test_events(0);
8793 test_events(1);
8794
8795 test_ipv6only();
8796 test_GetAddrInfoW();
8797 test_getaddrinfo();
8798 test_AcceptEx();
8799 test_ConnectEx();
8800
8801 test_sioRoutingInterfaceQuery();
8802 test_sioAddressListChange();
8803
8804 test_WSALookupService();
8805
8806 test_WSAAsyncGetServByPort();
8807 test_WSAAsyncGetServByName();
8808
8809 test_completion_port();
8810 test_address_list_query();
8811
8812 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
8813 test_send();
8814 test_synchronous_WSAIoctl();
8815
8816 Exit();
8817 }
Maarten's multimedia branch