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