?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ws2_32/tests: Add some more select() related tests.
[wine.git] / dlls / ws2_32 / tests / sock.c
blob2b4daaed8a3404576f3c4c0495901ddce8d9b8d6
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 /* check atmark state */
616 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
617 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
618
619 /* Echo data back */
620 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, 0, par->buflen );
621 ok ( n_sent == n_expected,
622 "oob_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
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_WSAEnumNetworkEvents(void)
2652 {
2653 SOCKET s, s2;
2654 int sock_type[] = {SOCK_STREAM, SOCK_DGRAM, SOCK_STREAM}, i, j, k, l;
2655 struct sockaddr_in address;
2656 HANDLE event;
2657 WSANETWORKEVENTS net_events;
2658 /* Windows 2000 Pro without SP installed (testbot) will crash if
2659 * WSAEnumNetworkEvents have a NULL event, so skip this test in <= 2000 */
2660 DWORD ver = GetVersion() & 0xFFFF;
2661 BOOL supports_null = ((ver & 0xFF) << 8 | (ver >> 8)) > 0x0500;
2662
2663 memset(&address, 0, sizeof(address));
2664 address.sin_addr.s_addr = htonl(INADDR_ANY);
2665 address.sin_family = AF_INET;
2666
2667 /* This test follows the steps from bugs 10204 and 24946 */
2668 for (l = 0; l < 2; l++)
2669 {
2670 if (l == 1 && !supports_null && broken(1)) continue;
2671
2672 for (i = 0; i < sizeof(sock_type) / sizeof(sock_type[0]); i++)
2673 {
2674 if (i == 2)
2675 ok(!tcp_socketpair(&s, &s2), "Test[%d]: creating socket pair failed\n", i);
2676 else
2677 {
2678 s = socket(AF_INET, sock_type[i], 0);
2679 ok (s != SOCKET_ERROR, "Test[%d]: failed to create socket\n", i);
2680 ok (!bind(s, (struct sockaddr*) &address, sizeof(address)), "Test[%d]: bind failed\n", i);
2681 }
2682 event = WSACreateEvent();
2683 ok (event != NULL, "Test[%d]: failed to create event\n", i);
2684 for (j = 0; j < 5; j++) /* Repeat sometimes and the result must be the same */
2685 {
2686 /* When the TCP socket is not connected NO events will be returned.
2687 * When connected and no data pending it will get the write event.
2688 * UDP sockets don't have connections so as soon as they are bound
2689 * they can read/write data. Since nobody is sendind us data only
2690 * the write event will be returned and ONLY once.
2691 */
2692 ok (!WSAEventSelect(s, event, FD_READ | FD_WRITE), "Test[%d]: WSAEventSelect failed\n", i);
2693 memset(&net_events, 0xAB, sizeof(net_events));
2694 ok (!WSAEnumNetworkEvents(s, l == 0 ? event : NULL, &net_events),
2695 "Test[%d]: WSAEnumNetworkEvents failed\n", i);
2696 if (i >= 1 && j == 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
2697 {
2698 if (i == 0) /* Remove when fixed */
2699 {
2700 todo_wine
2701 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %d\n",
2702 i, net_events.lNetworkEvents);
2703 }
2704 else
2705 ok (net_events.lNetworkEvents == FD_WRITE, "Test[%d]: expected 2, got %d\n",
2706 i, net_events.lNetworkEvents);
2707 }
2708 else
2709 {
2710 if (i != 0) /* Remove when fixed */
2711 {
2712 todo_wine
2713 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %d\n",
2714 i, net_events.lNetworkEvents);
2715 }
2716 else
2717 ok (net_events.lNetworkEvents == 0, "Test[%d]: expected 0, got %d\n",
2718 i, net_events.lNetworkEvents);
2719 }
2720 for (k = 0; k < FD_MAX_EVENTS; k++)
2721 {
2722 if (i >= 1 && j == 0 && k == 1) /* first UDP and connected TCP test, FD_WRITE bit no error*/
2723 {
2724 ok (net_events.iErrorCode[k] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
2725 i, k, net_events.iErrorCode[k]);
2726 }
2727 else
2728 {
2729 /* Bits that are not set in lNetworkEvents MUST not be changed */
2730 todo_wine
2731 ok (net_events.iErrorCode[k] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
2732 i, k, net_events.iErrorCode[k]);
2733 }
2734 }
2735 }
2736 closesocket(s);
2737 WSACloseEvent(event);
2738 if (i == 2) closesocket(s2);
2739 }
2740 }
2741 }
2742
2743 static void test_WSAAddressToStringA(void)
2744 {
2745 SOCKET v6 = INVALID_SOCKET;
2746 INT ret;
2747 DWORD len;
2748 int GLE;
2749 SOCKADDR_IN sockaddr;
2750 CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2751
2752 CHAR expect1[] = "0.0.0.0";
2753 CHAR expect2[] = "255.255.255.255";
2754 CHAR expect3[] = "0.0.0.0:65535";
2755 CHAR expect4[] = "255.255.255.255:65535";
2756
2757 SOCKADDR_IN6 sockaddr6;
2758 CHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2759
2760 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2761 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2762 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2763
2764 CHAR expect6_1[] = "::1";
2765 CHAR expect6_2[] = "20ab::1";
2766 CHAR expect6_3[] = "[20ab::2001]:33274";
2767 CHAR expect6_3_nt[] = "20ab::2001@33274";
2768 CHAR expect6_3_w2k[] = "20ab::2001";
2769 CHAR expect6_3_2[] = "[20ab::2001%4660]:33274";
2770 CHAR expect6_3_2_nt[] = "4660/20ab::2001@33274";
2771 CHAR expect6_3_2_w2k[] = "20ab::2001%4660";
2772 CHAR expect6_3_3[] = "20ab::2001%4660";
2773 CHAR expect6_3_3_nt[] = "4660/20ab::2001";
2774
2775 len = 0;
2776
2777 sockaddr.sin_family = AF_INET;
2778 sockaddr.sin_port = 0;
2779 sockaddr.sin_addr.s_addr = 0;
2780
2781 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2782 GLE = WSAGetLastError();
2783 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
2784 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2785 GLE, ret );
2786
2787 len = sizeof(address);
2788
2789 sockaddr.sin_family = AF_INET;
2790 sockaddr.sin_port = 0;
2791 sockaddr.sin_addr.s_addr = 0;
2792
2793 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2794 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2795
2796 ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
2797 ok( len == sizeof( expect1 ), "Got size %d\n", len);
2798
2799 len = sizeof(address);
2800
2801 sockaddr.sin_family = AF_INET;
2802 sockaddr.sin_port = 0;
2803 sockaddr.sin_addr.s_addr = 0xffffffff;
2804
2805 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2806 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2807
2808 ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
2809
2810 len = sizeof(address);
2811
2812 sockaddr.sin_family = AF_INET;
2813 sockaddr.sin_port = 0xffff;
2814 sockaddr.sin_addr.s_addr = 0;
2815
2816 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2817 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2818
2819 ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
2820
2821 len = sizeof(address);
2822
2823 sockaddr.sin_family = AF_INET;
2824 sockaddr.sin_port = 0xffff;
2825 sockaddr.sin_addr.s_addr = 0xffffffff;
2826
2827 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2828 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2829
2830 ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
2831 ok( len == sizeof( expect4 ), "Got size %d\n", len);
2832
2833 /*check to see it IPv6 is available */
2834 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
2835 if (v6 == INVALID_SOCKET) {
2836 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2837 WSAGetLastError(), WSAEAFNOSUPPORT);
2838 goto end;
2839 }
2840 /* Test a short IPv6 address */
2841 len = sizeof(address6);
2842
2843 sockaddr6.sin6_family = AF_INET6;
2844 sockaddr6.sin6_port = 0x0000;
2845 sockaddr6.sin6_scope_id = 0;
2846 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
2847
2848 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2849 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2850 ok( !strcmp( address6, expect6_1 ), "Expected: %s, got: %s\n", expect6_1, address6 );
2851 ok( len == sizeof(expect6_1), "Got size %d\n", len);
2852
2853 /* Test a longer IPv6 address */
2854 len = sizeof(address6);
2855
2856 sockaddr6.sin6_family = AF_INET6;
2857 sockaddr6.sin6_port = 0x0000;
2858 sockaddr6.sin6_scope_id = 0;
2859 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
2860
2861 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2862 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2863 ok( !strcmp( address6, expect6_2 ), "Expected: %s, got: %s\n", expect6_2, address6 );
2864 ok( len == sizeof(expect6_2), "Got size %d\n", len);
2865
2866 /* Test IPv6 address and port number */
2867 len = sizeof(address6);
2868
2869 sockaddr6.sin6_family = AF_INET6;
2870 sockaddr6.sin6_port = 0xfa81;
2871 sockaddr6.sin6_scope_id = 0;
2872 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2873
2874 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2875 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2876 ok( !strcmp( address6, expect6_3 ) ||
2877 broken( !strcmp( address6, expect6_3_nt ) ) || /* NT4 */
2878 broken( !strcmp( address6, expect6_3_w2k ) ), /* Win2000 */
2879 "Expected: %s, got: %s\n", expect6_3, address6 );
2880 ok( len == sizeof(expect6_3) ||
2881 broken( len == sizeof(expect6_3_nt) ) || /* NT4 */
2882 broken( len == sizeof(expect6_3_w2k) ), /* Win2000 */
2883 "Got size %d\n", len);
2884
2885 /* Test IPv6 address, port number and scope_id */
2886 len = sizeof(address6);
2887
2888 sockaddr6.sin6_family = AF_INET6;
2889 sockaddr6.sin6_port = 0xfa81;
2890 sockaddr6.sin6_scope_id = 0x1234;
2891 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2892
2893 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2894 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2895 ok( !strcmp( address6, expect6_3_2 ) ||
2896 broken( !strcmp( address6, expect6_3_2_nt ) ) || /* NT4 */
2897 broken( !strcmp( address6, expect6_3_2_w2k ) ), /* Win2000 */
2898 "Expected: %s, got: %s\n", expect6_3_2, address6 );
2899 ok( len == sizeof(expect6_3_2) ||
2900 broken( len == sizeof(expect6_3_2_nt) ) || /* NT4 */
2901 broken( len == sizeof(expect6_3_2_w2k) ), /* Win2000 */
2902 "Got size %d\n", len);
2903
2904 /* Test IPv6 address and scope_id */
2905 len = sizeof(address6);
2906
2907 sockaddr6.sin6_family = AF_INET6;
2908 sockaddr6.sin6_port = 0x0000;
2909 sockaddr6.sin6_scope_id = 0x1234;
2910 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2911
2912 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2913 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2914 ok( !strcmp( address6, expect6_3_3 ) ||
2915 broken( !strcmp( address6, expect6_3_3_nt ) ), /* NT4 */
2916 "Expected: %s, got: %s\n", expect6_3_3, address6 );
2917 ok( len == sizeof(expect6_3_3) ||
2918 broken( len == sizeof(expect6_3_3_nt) ), /* NT4 */
2919 "Got size %d\n", len);
2920
2921 end:
2922 if (v6 != INVALID_SOCKET)
2923 closesocket(v6);
2924 }
2925
2926 static void test_WSAAddressToStringW(void)
2927 {
2928 SOCKET v6 = INVALID_SOCKET;
2929 INT ret;
2930 DWORD len;
2931 int GLE;
2932 SOCKADDR_IN sockaddr;
2933 WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2934
2935 WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
2936 WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
2937 WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
2938 WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
2939 '6', '5', '5', '3', '5', 0 };
2940
2941 SOCKADDR_IN6 sockaddr6;
2942 WCHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2943
2944 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2945 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2946 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2947
2948 WCHAR expect6_1[] = {':',':','1',0};
2949 WCHAR expect6_2[] = {'2','0','a','b',':',':','1',0};
2950 WCHAR expect6_3[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
2951 WCHAR expect6_3_nt[] = {'2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
2952 WCHAR expect6_3_w2k[] = {'2','0','a','b',':',':','2','0','0','1',0};
2953 WCHAR expect6_3_2[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
2954 WCHAR expect6_3_2_nt[] = {'4','6','6','0','/','2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
2955 WCHAR expect6_3_2_w2k[] = {'2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',0};
2956 WCHAR expect6_3_3[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
2957 WCHAR expect6_3_3_nt[] = {'6','5','5','3','4','/','2','0','a','b',':',':','2','0','0','1',0};
2958
2959 len = 0;
2960
2961 sockaddr.sin_family = AF_INET;
2962 sockaddr.sin_port = 0;
2963 sockaddr.sin_addr.s_addr = 0;
2964
2965 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2966 GLE = WSAGetLastError();
2967 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
2968 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2969 GLE, ret );
2970
2971 len = sizeof(address);
2972
2973 sockaddr.sin_family = AF_INET;
2974 sockaddr.sin_port = 0;
2975 sockaddr.sin_addr.s_addr = 0;
2976
2977 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2978 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2979
2980 ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
2981 ok( len == sizeof( expect1 )/sizeof( WCHAR ), "Got size %d\n", len);
2982
2983 len = sizeof(address);
2984
2985 sockaddr.sin_family = AF_INET;
2986 sockaddr.sin_port = 0;
2987 sockaddr.sin_addr.s_addr = 0xffffffff;
2988
2989 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2990 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2991
2992 ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
2993
2994 len = sizeof(address);
2995
2996 sockaddr.sin_family = AF_INET;
2997 sockaddr.sin_port = 0xffff;
2998 sockaddr.sin_addr.s_addr = 0;
2999
3000 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3001 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3002
3003 ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
3004
3005 len = sizeof(address);
3006
3007 sockaddr.sin_family = AF_INET;
3008 sockaddr.sin_port = 0xffff;
3009 sockaddr.sin_addr.s_addr = 0xffffffff;
3010
3011 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
3012 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3013
3014 ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
3015 ok( len == sizeof( expect4 )/sizeof( WCHAR ), "Got %d\n", len);
3016
3017 /*check to see it IPv6 is available */
3018 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
3019 if (v6 == INVALID_SOCKET) {
3020 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3021 WSAGetLastError(), WSAEAFNOSUPPORT);
3022 goto end;
3023 }
3024
3025 /* Test a short IPv6 address */
3026 len = sizeof(address6)/sizeof(WCHAR);
3027
3028 sockaddr6.sin6_family = AF_INET6;
3029 sockaddr6.sin6_port = 0x0000;
3030 sockaddr6.sin6_scope_id = 0;
3031 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
3032
3033 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3034 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3035 ok( !lstrcmpW( address6, expect6_1 ), "Wrong string returned\n" );
3036 ok( len == sizeof(expect6_1)/sizeof(WCHAR), "Got %d\n", len);
3037
3038 /* Test a longer IPv6 address */
3039 len = sizeof(address6)/sizeof(WCHAR);
3040
3041 sockaddr6.sin6_family = AF_INET6;
3042 sockaddr6.sin6_port = 0x0000;
3043 sockaddr6.sin6_scope_id = 0;
3044 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
3045
3046 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3047 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3048
3049 ok( !lstrcmpW( address6, expect6_2 ), "Wrong string returned\n" );
3050 ok( len == sizeof(expect6_2)/sizeof(WCHAR), "Got %d\n", len);
3051
3052 /* Test IPv6 address and port number */
3053 len = sizeof(address6)/sizeof(WCHAR);
3054
3055 sockaddr6.sin6_family = AF_INET6;
3056 sockaddr6.sin6_port = 0xfa81;
3057 sockaddr6.sin6_scope_id = 0;
3058 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3059
3060 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3061 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3062 ok( !lstrcmpW( address6, expect6_3 ) ||
3063 broken( !lstrcmpW( address6, expect6_3_nt ) ) || /* NT4 */
3064 broken( !lstrcmpW( address6, expect6_3_w2k ) ), /* Win2000 */
3065 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3),
3066 wine_dbgstr_w(address6) );
3067 ok( len == sizeof(expect6_3)/sizeof(WCHAR) ||
3068 broken(len == sizeof(expect6_3_nt)/sizeof(WCHAR) ) || /* NT4 */
3069 broken(len == sizeof(expect6_3_w2k)/sizeof(WCHAR) ), /* Win2000 */
3070 "Got %d\n", len);
3071
3072 /* Test IPv6 address, port number and scope_id */
3073 len = sizeof(address6)/sizeof(WCHAR);
3074
3075 sockaddr6.sin6_family = AF_INET6;
3076 sockaddr6.sin6_port = 0xfa81;
3077 sockaddr6.sin6_scope_id = 0x1234;
3078 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3079
3080 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3081 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3082 ok( !lstrcmpW( address6, expect6_3_2 ) ||
3083 broken( !lstrcmpW( address6, expect6_3_2_nt ) ) || /* NT4 */
3084 broken( !lstrcmpW( address6, expect6_3_2_w2k ) ), /* Win2000 */
3085 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2),
3086 wine_dbgstr_w(address6) );
3087 ok( len == sizeof(expect6_3_2)/sizeof(WCHAR) ||
3088 broken( len == sizeof(expect6_3_2_nt)/sizeof(WCHAR) ) || /* NT4 */
3089 broken( len == sizeof(expect6_3_2_w2k)/sizeof(WCHAR) ), /* Win2000 */
3090 "Got %d\n", len);
3091
3092 /* Test IPv6 address and scope_id */
3093 len = sizeof(address6)/sizeof(WCHAR);
3094
3095 sockaddr6.sin6_family = AF_INET6;
3096 sockaddr6.sin6_port = 0x0000;
3097 sockaddr6.sin6_scope_id = 0xfffe;
3098 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
3099
3100 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
3101 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3102 ok( !lstrcmpW( address6, expect6_3_3 ) ||
3103 broken( !lstrcmpW( address6, expect6_3_3_nt ) ), /* NT4 */
3104 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3),
3105 wine_dbgstr_w(address6) );
3106 ok( len == sizeof(expect6_3_3)/sizeof(WCHAR) ||
3107 broken( len == sizeof(expect6_3_3_nt)/sizeof(WCHAR) ), /* NT4 */
3108 "Got %d\n", len);
3109
3110 end:
3111 if (v6 != INVALID_SOCKET)
3112 closesocket(v6);
3113 }
3114
3115 static void test_WSAStringToAddressA(void)
3116 {
3117 INT ret, len;
3118 SOCKADDR_IN sockaddr;
3119 SOCKADDR_IN6 sockaddr6;
3120 int GLE;
3121
3122 CHAR address1[] = "0.0.0.0";
3123 CHAR address2[] = "127.127.127.127";
3124 CHAR address3[] = "255.255.255.255";
3125 CHAR address4[] = "127.127.127.127:65535";
3126 CHAR address5[] = "255.255.255.255:65535";
3127 CHAR address6[] = "::1";
3128 CHAR address7[] = "[::1]";
3129 CHAR address8[] = "[::1]:65535";
3130 CHAR address9[] = "2001::1";
3131
3132 len = 0;
3133 sockaddr.sin_family = AF_INET;
3134
3135 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3136 ok( ret == SOCKET_ERROR, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
3137 WSAGetLastError() );
3138
3139 len = sizeof(sockaddr);
3140 sockaddr.sin_port = 0;
3141 sockaddr.sin_addr.s_addr = 0;
3142
3143 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3144 ok( !ret && sockaddr.sin_addr.s_addr == 0,
3145 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3146
3147 len = sizeof(sockaddr);
3148 sockaddr.sin_port = 0;
3149 sockaddr.sin_addr.s_addr = 0;
3150
3151 ret = WSAStringToAddressA( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3152 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
3153 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3154
3155 len = sizeof(sockaddr);
3156 sockaddr.sin_port = 0;
3157 sockaddr.sin_addr.s_addr = 0;
3158
3159 ret = WSAStringToAddressA( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3160 GLE = WSAGetLastError();
3161 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
3162 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3163 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
3164
3165 len = sizeof(sockaddr);
3166 sockaddr.sin_port = 0;
3167 sockaddr.sin_addr.s_addr = 0;
3168
3169 ret = WSAStringToAddressA( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3170 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
3171 "WSAStringToAddressA() 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 = WSAStringToAddressA( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3178 GLE = WSAGetLastError();
3179 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
3180 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3181 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
3182
3183 len = sizeof(sockaddr6);
3184 memset(&sockaddr6, 0, len);
3185 sockaddr6.sin6_family = AF_INET6;
3186
3187 ret = WSAStringToAddressA( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3188 &len );
3189 GLE = WSAGetLastError();
3190 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3191 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3192
3193 len = sizeof(sockaddr6);
3194 memset(&sockaddr6, 0, len);
3195 sockaddr6.sin6_family = AF_INET6;
3196
3197 ret = WSAStringToAddressA( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3198 &len );
3199 GLE = WSAGetLastError();
3200 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3201 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3202
3203 len = sizeof(sockaddr6);
3204 memset(&sockaddr6, 0, len);
3205 sockaddr6.sin6_family = AF_INET6;
3206
3207 ret = WSAStringToAddressA( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3208 &len );
3209 GLE = WSAGetLastError();
3210 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
3211 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3212 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
3213
3214 len = sizeof(sockaddr);
3215
3216 ret = WSAStringToAddressA( address9, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3217 GLE = WSAGetLastError();
3218 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3219 "WSAStringToAddressA() should have failed with %d\n", GLE );
3220 }
3221
3222 static void test_WSAStringToAddressW(void)
3223 {
3224 INT ret, len;
3225 SOCKADDR_IN sockaddr, *sin;
3226 SOCKADDR_IN6 sockaddr6;
3227 SOCKADDR_STORAGE sockaddr_storage;
3228 int GLE;
3229
3230 WCHAR address1[] = { '0','.','0','.','0','.','0', 0 };
3231 WCHAR address2[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
3232 WCHAR address3[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3233 WCHAR address4[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
3234 ':', '6', '5', '5', '3', '5', 0 };
3235 WCHAR address5[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3236 '6', '5', '5', '3', '5', 0 };
3237 WCHAR address6[] = {':',':','1','\0'};
3238 WCHAR address7[] = {'[',':',':','1',']','\0'};
3239 WCHAR address8[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
3240 WCHAR address9[] = {'2','0','0','1',':',':','1','\0'};
3241
3242 len = 0;
3243 sockaddr.sin_family = AF_INET;
3244
3245 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3246 ok( ret == SOCKET_ERROR, "WSAStringToAddressW() failed unexpectedly: %d\n",
3247 WSAGetLastError() );
3248
3249 len = sizeof(sockaddr);
3250 sockaddr.sin_port = 0;
3251 sockaddr.sin_addr.s_addr = 0;
3252
3253 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3254 ok( !ret && sockaddr.sin_addr.s_addr == 0,
3255 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3256
3257 len = sizeof(sockaddr);
3258 sockaddr.sin_port = 0;
3259 sockaddr.sin_addr.s_addr = 0;
3260
3261 ret = WSAStringToAddressW( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3262 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
3263 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3264
3265 len = sizeof(sockaddr);
3266 sockaddr.sin_port = 0;
3267 sockaddr.sin_addr.s_addr = 0;
3268
3269 ret = WSAStringToAddressW( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3270 GLE = WSAGetLastError();
3271 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
3272 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3273 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3274
3275 len = sizeof(sockaddr);
3276 sockaddr.sin_port = 0;
3277 sockaddr.sin_addr.s_addr = 0;
3278
3279 ret = WSAStringToAddressW( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3280 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
3281 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3282
3283 len = sizeof(sockaddr);
3284 sockaddr.sin_port = 0;
3285 sockaddr.sin_addr.s_addr = 0;
3286
3287 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3288 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
3289 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3290 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3291
3292 /* Test with a larger buffer than necessary */
3293 len = sizeof(sockaddr_storage);
3294 sin = (SOCKADDR_IN *)&sockaddr_storage;
3295 sin->sin_port = 0;
3296 sin->sin_addr.s_addr = 0;
3297
3298 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)sin, &len );
3299 ok( (ret == 0 && sin->sin_addr.s_addr == 0xffffffff && sin->sin_port == 0xffff) ||
3300 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
3301 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
3302 ok( len == sizeof(SOCKADDR_IN) ||
3303 broken(len == sizeof(SOCKADDR_STORAGE)) /* NT4/2k */,
3304 "unexpected length %d\n", len );
3305
3306 len = sizeof(sockaddr6);
3307 memset(&sockaddr6, 0, len);
3308 sockaddr6.sin6_family = AF_INET6;
3309
3310 ret = WSAStringToAddressW( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3311 &len );
3312 GLE = WSAGetLastError();
3313 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3314 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3315
3316 len = sizeof(sockaddr6);
3317 memset(&sockaddr6, 0, len);
3318 sockaddr6.sin6_family = AF_INET6;
3319
3320 ret = WSAStringToAddressW( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3321 &len );
3322 GLE = WSAGetLastError();
3323 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3324 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3325
3326 len = sizeof(sockaddr6);
3327 memset(&sockaddr6, 0, len);
3328 sockaddr6.sin6_family = AF_INET6;
3329
3330 ret = WSAStringToAddressW( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
3331 &len );
3332 GLE = WSAGetLastError();
3333 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
3334 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3335 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
3336
3337 len = sizeof(sockaddr);
3338
3339 ret = WSAStringToAddressW( address9, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
3340 GLE = WSAGetLastError();
3341 ok( (ret == SOCKET_ERROR && GLE == WSAEINVAL),
3342 "WSAStringToAddressW() should have failed with %d\n", GLE );
3343 }
3344
3345 static DWORD WINAPI SelectReadThread(void *param)
3346 {
3347 select_thread_params *par = param;
3348 fd_set readfds;
3349 int ret;
3350 struct sockaddr_in addr;
3351 struct timeval select_timeout;
3352
3353 FD_ZERO(&readfds);
3354 FD_SET(par->s, &readfds);
3355 select_timeout.tv_sec=5;
3356 select_timeout.tv_usec=0;
3357 addr.sin_family = AF_INET;
3358 addr.sin_addr.s_addr = inet_addr(SERVERIP);
3359 addr.sin_port = htons(SERVERPORT);
3360
3361 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
3362 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
3363
3364 SetEvent(server_ready);
3365 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
3366 par->ReadKilled = (ret == 1);
3367
3368 return 0;
3369 }
3370
3371 static void test_errors(void)
3372 {
3373 SOCKET sock;
3374 SOCKADDR_IN SockAddr;
3375 int ret, err;
3376
3377 WSASetLastError(NO_ERROR);
3378 sock = socket(PF_INET, SOCK_STREAM, 0);
3379 ok( (sock != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3380 memset(&SockAddr, 0, sizeof(SockAddr));
3381 SockAddr.sin_family = AF_INET;
3382 SockAddr.sin_port = htons(6924);
3383 SockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
3384
3385 ret = connect(sock, (PSOCKADDR)&SockAddr, sizeof(SockAddr));
3386 ok( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got: %d\n", ret );
3387 if (ret == SOCKET_ERROR)
3388 {
3389 err = WSAGetLastError();
3390 ok( (err == WSAECONNREFUSED), "expected WSAECONNREFUSED, got: %d\n", err );
3391 }
3392
3393 {
3394 TIMEVAL timeval;
3395 fd_set set = {1, {sock}};
3396
3397 timeval.tv_sec = 0;
3398 timeval.tv_usec = 50000;
3399
3400 ret = select(1, NULL, &set, NULL, &timeval);
3401 ok( (ret == 0), "expected 0 (timeout), got: %d\n", ret );
3402 }
3403
3404 ret = closesocket(sock);
3405 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3406 }
3407
3408 static void test_listen(void)
3409 {
3410 SOCKET fdA, fdB;
3411 int ret, acceptc, olen = sizeof(acceptc);
3412 struct sockaddr_in address;
3413
3414 memset(&address, 0, sizeof(address));
3415 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3416 address.sin_family = AF_INET;
3417 address.sin_port = htons(SERVERPORT);
3418
3419 /* invalid socket tests */
3420 SetLastError(0xdeadbeef);
3421 ok ((listen(0, 0) == SOCKET_ERROR), "listen did not fail\n");
3422 ret = WSAGetLastError();
3423 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3424
3425 SetLastError(0xdeadbeef);
3426 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR), "listen did not fail\n");
3427 ret = WSAGetLastError();
3428 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
3429
3430 /* tcp tests */
3431 fdA = socket(AF_INET, SOCK_STREAM, 0);
3432 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3433
3434 fdB = socket(AF_INET, SOCK_STREAM, 0);
3435 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3436
3437 SetLastError(0xdeadbeef);
3438 ok ((listen(fdA, -2) == SOCKET_ERROR), "listen did not fail\n");
3439 ret = WSAGetLastError();
3440 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3441
3442 SetLastError(0xdeadbeef);
3443 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
3444 ret = WSAGetLastError();
3445 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3446
3447 SetLastError(0xdeadbeef);
3448 ok ((listen(fdA, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3449 ret = WSAGetLastError();
3450 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3451
3452 ok (!bind(fdA, (struct sockaddr*) &address, sizeof(address)), "bind failed\n");
3453
3454 SetLastError(0xdeadbeef);
3455 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3456 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3457
3458 acceptc = 0xdead;
3459 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3460 ok (!ret, "getsockopt failed\n");
3461 ok (acceptc == 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc);
3462
3463 ok (!listen(fdA, 0), "listen failed\n");
3464 ok (!listen(fdA, SOMAXCONN), "double listen failed\n");
3465
3466 acceptc = 0xdead;
3467 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3468 ok (!ret, "getsockopt failed\n");
3469 ok (acceptc == 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc);
3470
3471 SetLastError(0xdeadbeef);
3472 ok ((listen(fdB, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3473 ret = WSAGetLastError();
3474 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3475
3476 ret = closesocket(fdB);
3477 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3478
3479 fdB = socket(AF_INET, SOCK_STREAM, 0);
3480 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3481
3482 SetLastError(0xdeadbeef);
3483 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3484 ret = WSAGetLastError();
3485 ok (ret == WSAEADDRINUSE, "expected 10048, received %d\n", ret);
3486
3487 ret = closesocket(fdA);
3488 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3489 ret = closesocket(fdB);
3490 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3491 }
3492
3493 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
3494 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
3495 static void test_select(void)
3496 {
3497 static char tmp_buf[1024];
3498
3499 SOCKET fdListen, fdRead, fdWrite;
3500 fd_set readfds, writefds, exceptfds;
3501 unsigned int maxfd;
3502 int ret, len;
3503 char buffer;
3504 struct timeval select_timeout;
3505 struct sockaddr_in address;
3506 select_thread_params thread_params;
3507 HANDLE thread_handle;
3508 DWORD id;
3509
3510 fdRead = socket(AF_INET, SOCK_STREAM, 0);
3511 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3512 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
3513 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3514
3515 FD_ZERO_ALL();
3516 FD_SET_ALL(fdRead);
3517 FD_SET_ALL(fdWrite);
3518 select_timeout.tv_sec=0;
3519 select_timeout.tv_usec=500;
3520
3521 maxfd = fdRead;
3522 if (fdWrite > maxfd)
3523 maxfd = fdWrite;
3524
3525 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3526 ok ( (ret == 0), "select should not return any socket handles\n");
3527 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3528 ok ( !FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3529 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3530 ok ( !FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3531
3532 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3533 ret = closesocket(fdWrite);
3534 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3535
3536 thread_params.s = fdRead;
3537 thread_params.ReadKilled = FALSE;
3538 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
3539 thread_handle = CreateThread (NULL, 0, SelectReadThread, &thread_params, 0, &id );
3540 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
3541
3542 WaitForSingleObject (server_ready, INFINITE);
3543 Sleep(200);
3544 ret = closesocket(fdRead);
3545 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3546
3547 WaitForSingleObject (thread_handle, 1000);
3548 ok ( (thread_params.ReadKilled) ||
3549 broken(thread_params.ReadKilled == 0), /*Win98*/
3550 "closesocket did not wakeup select\n");
3551 ret = recv(fdRead, &buffer, 1, MSG_PEEK);
3552 ok( (ret == -1), "peek at closed socket expected -1 got %d\n", ret);
3553
3554 /* Test selecting invalid handles */
3555 FD_ZERO_ALL();
3556
3557 SetLastError(0);
3558 ret = select(maxfd+1, 0, 0, 0, &select_timeout);
3559 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3560 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3561
3562 SetLastError(0);
3563 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3564 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3565 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3566
3567 FD_SET(INVALID_SOCKET, &readfds);
3568 SetLastError(0);
3569 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3570 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3571 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3572 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3573
3574 FD_ZERO(&readfds);
3575 FD_SET(INVALID_SOCKET, &writefds);
3576 SetLastError(0);
3577 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3578 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3579 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3580 ok ( !FD_ISSET(fdRead, &writefds), "FD should not be set\n");
3581
3582 FD_ZERO(&writefds);
3583 FD_SET(INVALID_SOCKET, &exceptfds);
3584 SetLastError(0);
3585 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3586 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3587 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3588 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3589
3590 ok(!tcp_socketpair(&fdRead, &fdWrite), "creating socket pair failed\n");
3591 maxfd = fdRead;
3592 if(fdWrite > maxfd) maxfd = fdWrite;
3593
3594 FD_ZERO(&readfds);
3595 FD_SET(fdRead, &readfds);
3596 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3597 ok(!ret, "select returned %d\n", ret);
3598
3599 FD_ZERO(&writefds);
3600 FD_SET(fdWrite, &writefds);
3601 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3602 ok(ret == 1, "select returned %d\n", ret);
3603 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3604
3605 /* tests for overlapping fd_set pointers */
3606 FD_ZERO(&readfds);
3607 FD_SET(fdWrite, &readfds);
3608 ret = select(fdWrite+1, &readfds, &readfds, NULL, &select_timeout);
3609 ok(ret == 1, "select returned %d\n", ret);
3610 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3611
3612 FD_ZERO(&readfds);
3613 FD_SET(fdWrite, &readfds);
3614 FD_SET(fdRead, &readfds);
3615 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3616 ok(ret == 2, "select returned %d\n", ret);
3617 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3618 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3619
3620 ok(send(fdWrite, "test", 4, 0) == 4, "failed to send data\n");
3621 FD_ZERO(&readfds);
3622 FD_SET(fdRead, &readfds);
3623 ret = select(fdRead+1, &readfds, NULL, NULL, &select_timeout);
3624 ok(ret == 1, "select returned %d\n", ret);
3625 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3626
3627 FD_ZERO(&readfds);
3628 FD_SET(fdWrite, &readfds);
3629 FD_SET(fdRead, &readfds);
3630 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3631 ok(ret == 2, "select returned %d\n", ret);
3632 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3633 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3634
3635 while(1) {
3636 FD_ZERO(&writefds);
3637 FD_SET(fdWrite, &writefds);
3638 ret = select(fdWrite+1, NULL, &writefds, NULL, &select_timeout);
3639 if(!ret) break;
3640 ok(send(fdWrite, tmp_buf, sizeof(tmp_buf), 0) > 0, "failed to send data\n");
3641 }
3642 FD_ZERO(&readfds);
3643 FD_SET(fdWrite, &readfds);
3644 FD_SET(fdRead, &readfds);
3645 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3646 ok(ret == 1, "select returned %d\n", ret);
3647 ok(!FD_ISSET(fdWrite, &readfds), "fdWrite socket is in the set\n");
3648 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3649
3650 ok(send(fdRead, "test", 4, 0) == 4, "failed to send data\n");
3651 Sleep(100);
3652 FD_ZERO(&readfds);
3653 FD_SET(fdWrite, &readfds);
3654 FD_SET(fdRead, &readfds);
3655 ret = select(maxfd+1, &readfds, &readfds, NULL, &select_timeout);
3656 ok(ret == 2, "select returned %d\n", ret);
3657 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3658 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3659
3660 closesocket(fdRead);
3661 closesocket(fdWrite);
3662
3663 /* select() works in 3 distinct states:
3664 * - to check if a connection attempt ended with success or error;
3665 * - to check if a pending connection is waiting for acceptance;
3666 * - to check for data to read, availability for write and OOB data
3667 *
3668 * The tests below ensure that all conditions are tested.
3669 */
3670 memset(&address, 0, sizeof(address));
3671 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3672 address.sin_family = AF_INET;
3673 len = sizeof(address);
3674 fdListen = setup_server_socket(&address, &len);
3675 select_timeout.tv_sec = 1;
3676 select_timeout.tv_usec = 250000;
3677
3678 /* When no events are pending select returns 0 with no error */
3679 FD_ZERO_ALL();
3680 FD_SET_ALL(fdListen);
3681 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3682 ok(ret == 0, "expected 0, got %d\n", ret);
3683
3684 /* When a socket is attempting to connect the listening socket receives the read descriptor */
3685 fdWrite = setup_connector_socket(&address, len, TRUE);
3686 FD_ZERO_ALL();
3687 FD_SET_ALL(fdListen);
3688 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3689 ok(ret == 1, "expected 1, got %d\n", ret);
3690 ok(FD_ISSET(fdListen, &readfds), "fdListen socket is not in the set\n");
3691 len = sizeof(address);
3692 fdRead = accept(fdListen, (struct sockaddr*) &address, &len);
3693 ok(fdRead != INVALID_SOCKET, "expected a valid socket\n");
3694
3695 /* The connector is signaled through the write descriptor */
3696 FD_ZERO_ALL();
3697 FD_SET_ALL(fdListen);
3698 FD_SET_ALL(fdRead);
3699 FD_SET_ALL(fdWrite);
3700 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3701 ok(ret == 2, "expected 2, got %d\n", ret);
3702 ok(FD_ISSET(fdWrite, &writefds), "fdWrite socket is not in the set\n");
3703 ok(FD_ISSET(fdRead, &writefds), "fdRead socket is not in the set\n");
3704 len = sizeof(id);
3705 id = 0xdeadbeef;
3706 ok(!getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len), "getsockopt failed with %d\n",WSAGetLastError());
3707 ok(id == 0, "expected 0, got %d\n", id);
3708
3709 /* When data is received the receiver gets the read descriptor */
3710 ret = send(fdWrite, "1234", 4, 0);
3711 ok(ret == 4, "expected 4, got %d\n", ret);
3712 FD_ZERO_ALL();
3713 FD_SET_ALL(fdListen);
3714 FD_SET(fdRead, &readfds);
3715 FD_SET(fdRead, &exceptfds);
3716 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3717 ok(ret == 1, "expected 1, got %d\n", ret);
3718 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3719 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
3720 ok(ret == 4, "expected 4, got %d\n", ret);
3721 ok(!strcmp(tmp_buf, "1234"), "data received differs from sent\n");
3722
3723 /* When OOB data is received the socket is set in the except descriptor */
3724 ret = send(fdWrite, "A", 1, MSG_OOB);
3725 ok(ret == 1, "expected 1, got %d\n", ret);
3726 FD_ZERO_ALL();
3727 FD_SET_ALL(fdListen);
3728 FD_SET(fdRead, &readfds);
3729 FD_SET(fdRead, &exceptfds);
3730 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3731 ok(ret == 1, "expected 1, got %d\n", ret);
3732 ok(FD_ISSET(fdRead, &exceptfds), "fdRead socket is not in the set\n");
3733 tmp_buf[0] = 0xAF;
3734 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
3735 ok(ret == 1, "expected 1, got %d\n", ret);
3736 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
3737
3738 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
3739 ret = 1;
3740 ret = setsockopt(fdRead, SOL_SOCKET, SO_OOBINLINE, (char*) &ret, sizeof(ret));
3741 ok(ret == 0, "expected 0, got %d\n", ret);
3742 ret = send(fdWrite, "A", 1, MSG_OOB);
3743 ok(ret == 1, "expected 1, got %d\n", ret);
3744 FD_ZERO_ALL();
3745 FD_SET_ALL(fdListen);
3746 FD_SET(fdRead, &readfds);
3747 FD_SET(fdRead, &exceptfds);
3748 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3749 ok(ret == 1, "expected 1, got %d\n", ret);
3750 ok(FD_ISSET(fdRead, &readfds), "fdRead socket is not in the set\n");
3751 tmp_buf[0] = 0xAF;
3752 SetLastError(0xdeadbeef);
3753 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), MSG_OOB);
3754 if (ret == SOCKET_ERROR) /* can't recv with MSG_OOB if OOBINLINED */
3755 {
3756 ok(GetLastError() == WSAEINVAL, "expected 10022, got %d\n", GetLastError());
3757 ret = recv(fdRead, tmp_buf, sizeof(tmp_buf), 0);
3758 ok(ret == 1, "expected 1, got %d\n", ret);
3759 ok(tmp_buf[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf[0]);
3760 }
3761 else ok(broken(ret == 1) /* <= NT4 */, "expected error, got 1\n");
3762
3763 /* When the connection is closed the socket is set in the read descriptor */
3764 ret = closesocket(fdRead);
3765 ok(ret == 0, "expected 0, got %d\n", ret);
3766 FD_ZERO_ALL();
3767 FD_SET_ALL(fdListen);
3768 FD_SET(fdWrite, &readfds);
3769 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3770 ok(ret == 1, "expected 1, got %d\n", ret);
3771 ok(FD_ISSET(fdWrite, &readfds), "fdWrite socket is not in the set\n");
3772 ret = recv(fdWrite, tmp_buf, sizeof(tmp_buf), 0);
3773 ok(ret == 0, "expected 0, got %d\n", ret);
3774
3775 /* When a connection is attempted to a non-listening socket it will get to the except descriptor */
3776 ret = closesocket(fdWrite);
3777 ok(ret == 0, "expected 0, got %d\n", ret);
3778 ret = closesocket(fdListen);
3779 ok(ret == 0, "expected 0, got %d\n", ret);
3780 len = sizeof(address);
3781 fdWrite = setup_connector_socket(&address, len, TRUE);
3782 FD_ZERO_ALL();
3783 FD_SET(fdWrite, &writefds);
3784 FD_SET(fdWrite, &exceptfds);
3785 select_timeout.tv_sec = 2; /* requires more time to realize it will not connect */
3786 ret = select(0, &readfds, &writefds, &exceptfds, &select_timeout);
3787 ok(ret == 1, "expected 1, got %d\n", ret);
3788 len = sizeof(id);
3789 id = 0xdeadbeef;
3790 ok(!getsockopt(fdWrite, SOL_SOCKET, SO_ERROR, (char*)&id, &len), "getsockopt failed with %d\n",WSAGetLastError());
3791 todo_wine
3792 ok(id == WSAECONNREFUSED, "expected 10061, got %d\n", id);
3793 ok(FD_ISSET(fdWrite, &exceptfds), "fdWrite socket is not in the set\n");
3794 ok(select_timeout.tv_usec == 250000, "select timeout should not have changed\n");
3795 closesocket(fdWrite);
3796 }
3797 #undef FD_SET_ALL
3798 #undef FD_ZERO_ALL
3799
3800 static DWORD WINAPI AcceptKillThread(void *param)
3801 {
3802 select_thread_params *par = param;
3803 struct sockaddr_in address;
3804 int len = sizeof(address);
3805 SOCKET client_socket;
3806
3807 SetEvent(server_ready);
3808 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
3809 if (client_socket != INVALID_SOCKET)
3810 closesocket(client_socket);
3811 par->ReadKilled = (client_socket == INVALID_SOCKET);
3812 return 0;
3813 }
3814
3815
3816 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
3817 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
3818 GROUP *g, DWORD_PTR dwCallbackData)
3819 {
3820 return CF_DEFER;
3821 }
3822
3823 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len)
3824 {
3825 int ret, val;
3826 SOCKET server_socket;
3827
3828 server_socket = socket(AF_INET, SOCK_STREAM, 0);
3829 if (server_socket == INVALID_SOCKET)
3830 {
3831 trace("error creating server socket: %d\n", WSAGetLastError());
3832 return INVALID_SOCKET;
3833 }
3834
3835 val = 1;
3836 ret = setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
3837 if (ret)
3838 {
3839 trace("error setting SO_REUSEADDR: %d\n", WSAGetLastError());
3840 closesocket(server_socket);
3841 return INVALID_SOCKET;
3842 }
3843
3844 ret = bind(server_socket, (struct sockaddr *)addr, *len);
3845 if (ret)
3846 {
3847 trace("error binding server socket: %d\n", WSAGetLastError());
3848 }
3849
3850 ret = getsockname(server_socket, (struct sockaddr *)addr, len);
3851 if (ret)
3852 {
3853 skip("failed to lookup bind address: %d\n", WSAGetLastError());
3854 closesocket(server_socket);
3855 return INVALID_SOCKET;
3856 }
3857
3858 ret = listen(server_socket, 5);
3859 if (ret)
3860 {
3861 trace("error making server socket listen: %d\n", WSAGetLastError());
3862 closesocket(server_socket);
3863 return INVALID_SOCKET;
3864 }
3865
3866 return server_socket;
3867 }
3868
3869 static SOCKET setup_connector_socket(struct sockaddr_in *addr, int len, BOOL nonblock)
3870 {
3871 int ret;
3872 SOCKET connector;
3873
3874 connector = socket(AF_INET, SOCK_STREAM, 0);
3875 ok(connector != INVALID_SOCKET, "failed to create connector socket %d\n", WSAGetLastError());
3876
3877 if (nonblock)
3878 set_blocking(connector, !nonblock);
3879
3880 ret = connect(connector, (struct sockaddr *)addr, len);
3881 if (!nonblock)
3882 ok(!ret, "connecting to accepting socket failed %d\n", WSAGetLastError());
3883 else if (ret == SOCKET_ERROR)
3884 {
3885 DWORD error = WSAGetLastError();
3886 ok(error == WSAEWOULDBLOCK || error == WSAEINPROGRESS,
3887 "expected 10035 or 10036, got %d\n", error);
3888 }
3889
3890 return connector;
3891 }
3892
3893 static void test_accept(void)
3894 {
3895 int ret;
3896 SOCKET server_socket, accepted = INVALID_SOCKET, connector;
3897 struct sockaddr_in address;
3898 SOCKADDR_STORAGE ss;
3899 int socklen;
3900 select_thread_params thread_params;
3901 HANDLE thread_handle = NULL;
3902 DWORD id;
3903
3904 memset(&address, 0, sizeof(address));
3905 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3906 address.sin_family = AF_INET;
3907
3908 socklen = sizeof(address);
3909 server_socket = setup_server_socket(&address, &socklen);
3910 if (server_socket == INVALID_SOCKET)
3911 {
3912 trace("error creating server socket: %d\n", WSAGetLastError());
3913 return;
3914 }
3915
3916 connector = setup_connector_socket(&address, socklen, FALSE);
3917 if (connector == INVALID_SOCKET) goto done;
3918
3919 trace("Blocking accept next\n");
3920
3921 accepted = WSAAccept(server_socket, NULL, NULL, AlwaysDeferConditionFunc, 0);
3922 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
3923
3924 accepted = accept(server_socket, NULL, 0);
3925 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
3926
3927 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
3928 if (server_ready == INVALID_HANDLE_VALUE)
3929 {
3930 trace("error creating event: %d\n", GetLastError());
3931 goto done;
3932 }
3933
3934 thread_params.s = server_socket;
3935 thread_params.ReadKilled = FALSE;
3936 thread_handle = CreateThread(NULL, 0, AcceptKillThread, &thread_params, 0, &id);
3937 if (thread_handle == NULL)
3938 {
3939 trace("error creating thread: %d\n", GetLastError());
3940 goto done;
3941 }
3942
3943 WaitForSingleObject(server_ready, INFINITE);
3944 Sleep(200);
3945 ret = closesocket(server_socket);
3946 if (ret != 0)
3947 {
3948 trace("closesocket failed: %d\n", WSAGetLastError());
3949 goto done;
3950 }
3951
3952 WaitForSingleObject(thread_handle, 1000);
3953 ok(thread_params.ReadKilled || broken(!thread_params.ReadKilled) /* Win98/ME, after accept */,
3954 "closesocket did not wakeup accept\n");
3955
3956 closesocket(accepted);
3957 closesocket(connector);
3958 accepted = connector = INVALID_SOCKET;
3959
3960 socklen = sizeof(address);
3961 server_socket = setup_server_socket(&address, &socklen);
3962 if (server_socket == INVALID_SOCKET) goto done;
3963
3964 connector = setup_connector_socket(&address, socklen, FALSE);
3965 if (connector == INVALID_SOCKET) goto done;
3966
3967 socklen = 0;
3968 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
3969 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
3970 ok(!socklen, "got %d\n", socklen);
3971 closesocket(connector);
3972 connector = INVALID_SOCKET;
3973
3974 socklen = sizeof(address);
3975 connector = setup_connector_socket(&address, socklen, FALSE);
3976 if (connector == INVALID_SOCKET) goto done;
3977
3978 accepted = WSAAccept(server_socket, NULL, NULL, NULL, 0);
3979 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
3980 closesocket(accepted);
3981 closesocket(connector);
3982 accepted = connector = INVALID_SOCKET;
3983
3984 socklen = sizeof(address);
3985 connector = setup_connector_socket(&address, socklen, FALSE);
3986 if (connector == INVALID_SOCKET) goto done;
3987
3988 socklen = sizeof(ss);
3989 memset(&ss, 0, sizeof(ss));
3990 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
3991 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
3992 ok(socklen != sizeof(ss), "unexpected length\n");
3993 ok(ss.ss_family, "family not set\n");
3994 closesocket(accepted);
3995 closesocket(connector);
3996 accepted = connector = INVALID_SOCKET;
3997
3998 socklen = sizeof(address);
3999 connector = setup_connector_socket(&address, socklen, FALSE);
4000 if (connector == INVALID_SOCKET) goto done;
4001
4002 socklen = 0;
4003 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4004 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
4005 ok(!socklen, "got %d\n", socklen);
4006 closesocket(connector);
4007 accepted = connector = INVALID_SOCKET;
4008
4009 socklen = sizeof(address);
4010 connector = setup_connector_socket(&address, socklen, FALSE);
4011 if (connector == INVALID_SOCKET) goto done;
4012
4013 accepted = accept(server_socket, NULL, NULL);
4014 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4015 closesocket(accepted);
4016 closesocket(connector);
4017 accepted = connector = INVALID_SOCKET;
4018
4019 socklen = sizeof(address);
4020 connector = setup_connector_socket(&address, socklen, FALSE);
4021 if (connector == INVALID_SOCKET) goto done;
4022
4023 socklen = sizeof(ss);
4024 memset(&ss, 0, sizeof(ss));
4025 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
4026 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
4027 ok(socklen != sizeof(ss), "unexpected length\n");
4028 ok(ss.ss_family, "family not set\n");
4029
4030 done:
4031 if (accepted != INVALID_SOCKET)
4032 closesocket(accepted);
4033 if (connector != INVALID_SOCKET)
4034 closesocket(connector);
4035 if (thread_handle != NULL)
4036 CloseHandle(thread_handle);
4037 if (server_ready != INVALID_HANDLE_VALUE)
4038 CloseHandle(server_ready);
4039 if (server_socket != INVALID_SOCKET)
4040 closesocket(server_socket);
4041 }
4042
4043 static void test_extendedSocketOptions(void)
4044 {
4045 WSADATA wsa;
4046 SOCKET sock;
4047 struct sockaddr_in sa;
4048 int sa_len = sizeof(struct sockaddr_in);
4049 int optval, optlen = sizeof(int), ret;
4050 BOOL bool_opt_val;
4051 LINGER linger_val;
4052
4053 if(WSAStartup(MAKEWORD(2,0), &wsa)){
4054 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4055 return;
4056 }
4057
4058 memset(&sa, 0, sa_len);
4059
4060 sa.sin_family = AF_INET;
4061 sa.sin_port = htons(0);
4062 sa.sin_addr.s_addr = htonl(INADDR_ANY);
4063
4064 if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) == INVALID_SOCKET) {
4065 trace("Creating the socket failed: %d\n", WSAGetLastError());
4066 WSACleanup();
4067 return;
4068 }
4069
4070 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
4071 trace("Failed to bind socket: %d\n", WSAGetLastError());
4072 closesocket(sock);
4073 WSACleanup();
4074 return;
4075 }
4076
4077 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4078
4079 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
4080 ok((optval == 65507) || (optval == 65527),
4081 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
4082
4083 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
4084 SetLastError(0xdeadbeef);
4085 optval = 0xdeadbeef;
4086 optlen = sizeof(int);
4087 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4088 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4089 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4090 ret, WSAGetLastError(), optval, optval);
4091
4092 /* more invalid values for level */
4093 SetLastError(0xdeadbeef);
4094 optval = 0xdeadbeef;
4095 optlen = sizeof(int);
4096 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4097 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4098 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4099 ret, WSAGetLastError(), optval, optval);
4100
4101 SetLastError(0xdeadbeef);
4102 optval = 0xdeadbeef;
4103 optlen = sizeof(int);
4104 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4105 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4106 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4107 ret, WSAGetLastError(), optval, optval);
4108
4109 SetLastError(0xdeadbeef);
4110 optval = 0xdeadbeef;
4111 optlen = sizeof(int);
4112 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4113 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4114 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4115 ret, WSAGetLastError(), optval, optval);
4116
4117 SetLastError(0xdeadbeef);
4118 optval = 0xdeadbeef;
4119 optlen = sizeof(int);
4120 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
4121 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
4122 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4123 ret, WSAGetLastError(), optval, optval);
4124
4125 SetLastError(0xdeadbeef);
4126 optlen = sizeof(LINGER);
4127 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4128 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAENOPROTOOPT),
4129 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
4130 ret, WSAGetLastError());
4131 closesocket(sock);
4132
4133 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
4134 trace("Creating the socket failed: %d\n", WSAGetLastError());
4135 WSACleanup();
4136 return;
4137 }
4138
4139 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
4140 trace("Failed to bind socket: %d\n", WSAGetLastError());
4141 closesocket(sock);
4142 WSACleanup();
4143 return;
4144 }
4145
4146 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
4147 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
4148
4149 optlen = sizeof(BOOL);
4150 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
4151 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
4152 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
4153 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
4154 bool_opt_val, linger_val.l_onoff);
4155
4156 closesocket(sock);
4157 WSACleanup();
4158 }
4159
4160 static void test_getsockname(void)
4161 {
4162 WSADATA wsa;
4163 SOCKET sock;
4164 struct sockaddr_in sa_set, sa_get;
4165 int sa_set_len = sizeof(struct sockaddr_in);
4166 int sa_get_len = sa_set_len;
4167 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
4168 int ret;
4169
4170 if(WSAStartup(MAKEWORD(2,0), &wsa)){
4171 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4172 return;
4173 }
4174
4175 memset(&sa_set, 0, sa_set_len);
4176
4177 sa_set.sin_family = AF_INET;
4178 sa_set.sin_port = htons(0);
4179 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
4180
4181 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
4182 trace("Creating the socket failed: %d\n", WSAGetLastError());
4183 WSACleanup();
4184 return;
4185 }
4186
4187 sa_get = sa_set;
4188 if (getsockname(sock, (struct sockaddr*) &sa_get, &sa_get_len) == 0)
4189 ok(0, "getsockname on unbound socket should fail\n");
4190 else {
4191 ok(WSAGetLastError() == WSAEINVAL, "getsockname on unbound socket "
4192 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL);
4193 ok(memcmp(&sa_get, &sa_set, sizeof(sa_get)) == 0,
4194 "failed getsockname modified sockaddr when it shouldn't\n");
4195 }
4196
4197 if(bind(sock, (struct sockaddr *) &sa_set, sa_set_len) < 0){
4198 trace("Failed to bind socket: %d\n", WSAGetLastError());
4199 closesocket(sock);
4200 WSACleanup();
4201 return;
4202 }
4203
4204 if(getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len) != 0){
4205 trace("Failed to call getsockname: %d\n", WSAGetLastError());
4206 closesocket(sock);
4207 WSACleanup();
4208 return;
4209 }
4210
4211 ret = memcmp(sa_get.sin_zero, null_padding, 8);
4212 ok(ret == 0 || broken(ret != 0), /* NT4 */
4213 "getsockname did not zero the sockaddr_in structure\n");
4214
4215 closesocket(sock);
4216 WSACleanup();
4217 }
4218
4219 static void test_dns(void)
4220 {
4221 struct hostent *h;
4222 union memaddress
4223 {
4224 char *chr;
4225 void *mem;
4226 } addr;
4227 char **ptr;
4228 int acount;
4229
4230 h = gethostbyname("");
4231 ok(h != NULL, "gethostbyname(\"\") failed with %d\n", h_errno);
4232
4233 /* Use an address with valid alias names if possible */
4234 h = gethostbyname("source.winehq.org");
4235 if(!h)
4236 {
4237 skip("Can't test the hostent structure because gethostbyname failed\n");
4238 return;
4239 }
4240
4241 /* The returned struct must be allocated in a very strict way. First we need to
4242 * count how many aliases there are because they must be located right after
4243 * the struct hostent size. Knowing the amount of aliases we know the exact
4244 * location of the first IP returned. Rule valid for >= XP, for older OS's
4245 * it's somewhat the opposite. */
4246 addr.mem = h + 1;
4247 if(h->h_addr_list == addr.mem) /* <= W2K */
4248 {
4249 win_skip("Skipping hostent tests since this OS is unsupported\n");
4250 return;
4251 }
4252
4253 ok(h->h_aliases == addr.mem,
4254 "hostent->h_aliases should be in %p, it is in %p\n", addr.mem, h->h_aliases);
4255
4256 for(ptr = h->h_aliases, acount = 1; *ptr; ptr++) acount++;
4257 addr.chr += sizeof(*ptr) * acount;
4258 ok(h->h_addr_list == addr.mem,
4259 "hostent->h_addr_list should be in %p, it is in %p\n", addr.mem, h->h_addr_list);
4260
4261 for(ptr = h->h_addr_list, acount = 1; *ptr; ptr++) acount++;
4262
4263 addr.chr += sizeof(*ptr) * acount;
4264 ok(h->h_addr_list[0] == addr.mem,
4265 "hostent->h_addr_list[0] should be in %p, it is in %p\n", addr.mem, h->h_addr_list[0]);
4266 }
4267
4268 /* Our winsock headers don't define gethostname because it conflicts with the
4269 * definition in unistd.h. Define it here to get rid of the warning. */
4270
4271 int WINAPI gethostname(char *name, int namelen);
4272
4273 static void test_gethostbyname_hack(void)
4274 {
4275 struct hostent *he;
4276 char name[256];
4277 static BYTE loopback[] = {127, 0, 0, 1};
4278 static BYTE magic_loopback[] = {127, 12, 34, 56};
4279 int ret;
4280
4281 ret = gethostname(name, 256);
4282 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4283
4284 he = gethostbyname("localhost");
4285 ok(he != NULL, "gethostbyname(\"localhost\") failed: %d\n", h_errno);
4286 if(he)
4287 {
4288 if(he->h_length != 4)
4289 {
4290 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
4291 return;
4292 }
4293
4294 ok(memcmp(he->h_addr_list[0], loopback, he->h_length) == 0,
4295 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
4296 he->h_addr_list[0][0], he->h_addr_list[0][1], he->h_addr_list[0][2],
4297 he->h_addr_list[0][3]);
4298 }
4299
4300 if(strcmp(name, "localhost") == 0)
4301 {
4302 skip("hostname seems to be \"localhost\", skipping test.\n");
4303 return;
4304 }
4305
4306 he = NULL;
4307 he = gethostbyname(name);
4308 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, h_errno);
4309 if(he)
4310 {
4311 if(he->h_length != 4)
4312 {
4313 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
4314 return;
4315 }
4316
4317 if (he->h_addr_list[0][0] == 127)
4318 {
4319 ok(memcmp(he->h_addr_list[0], magic_loopback, he->h_length) == 0,
4320 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
4321 name, he->h_addr_list[0][0], he->h_addr_list[0][1],
4322 he->h_addr_list[0][2], he->h_addr_list[0][3]);
4323 }
4324 }
4325
4326 gethostbyname("nonexistent.winehq.org");
4327 /* Don't check for the return value, as some braindead ISPs will kindly
4328 * resolve nonexistent host names to addresses of the ISP's spam pages. */
4329 }
4330
4331 static void test_gethostname(void)
4332 {
4333 struct hostent *he;
4334 char name[256];
4335 int ret, len;
4336
4337 WSASetLastError(0xdeadbeef);
4338 ret = gethostname(NULL, 256);
4339 ok(ret == -1, "gethostname() returned %d\n", ret);
4340 ok(WSAGetLastError() == WSAEFAULT, "gethostname with null buffer "
4341 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT);
4342
4343 ret = gethostname(name, sizeof(name));
4344 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4345 he = gethostbyname(name);
4346 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4347
4348 len = strlen(name);
4349 WSASetLastError(0xdeadbeef);
4350 strcpy(name, "deadbeef");
4351 ret = gethostname(name, len);
4352 ok(ret == -1, "gethostname() returned %d\n", ret);
4353 ok(!strcmp(name, "deadbeef"), "name changed unexpected!\n");
4354 ok(WSAGetLastError() == WSAEFAULT, "gethostname with insufficient length "
4355 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT);
4356
4357 len++;
4358 ret = gethostname(name, len);
4359 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
4360 he = gethostbyname(name);
4361 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, WSAGetLastError());
4362 }
4363
4364 static void test_inet_addr(void)
4365 {
4366 u_long addr;
4367
4368 addr = inet_addr(NULL);
4369 ok(addr == INADDR_NONE, "inet_addr succeeded unexpectedly\n");
4370 }
4371
4372 static void test_addr_to_print(void)
4373 {
4374 char dst[16];
4375 char dst6[64];
4376 const char * pdst;
4377 struct in_addr in;
4378 struct in6_addr in6;
4379
4380 u_long addr0_Num = 0x00000000;
4381 PCSTR addr0_Str = "0.0.0.0";
4382 u_long addr1_Num = 0x20201015;
4383 PCSTR addr1_Str = "21.16.32.32";
4384 u_char addr2_Num[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
4385 PCSTR addr2_Str = "::fffe:cc98:bd74";
4386 u_char addr3_Num[16] = {0x20,0x30,0xa4,0xb1};
4387 PCSTR addr3_Str = "2030:a4b1::";
4388 u_char addr4_Num[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
4389 PCSTR addr4_Str = "::204.152.189.116";
4390
4391 /* Test IPv4 addresses */
4392 in.s_addr = addr0_Num;
4393
4394 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
4395 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
4396 ok(!strcmp(pdst, addr0_Str),"Address %s != %s\n", pdst, addr0_Str);
4397
4398 /* Test that inet_ntoa and inet_ntop return the same value */
4399 in.S_un.S_addr = addr1_Num;
4400 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
4401 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
4402 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4403
4404 /* InetNtop became available in Vista and Win2008 */
4405 if (!pInetNtop)
4406 {
4407 win_skip("InetNtop not present, not executing tests\n");
4408 return;
4409 }
4410
4411 /* Second part of test */
4412 pdst = pInetNtop(AF_INET,(void*)&in.s_addr, dst, sizeof(dst));
4413 ok(pdst != NULL, "InetNtop failed %s\n", dst);
4414 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4415
4416 /* Test invalid parm conditions */
4417 pdst = pInetNtop(1, (void*)&in.s_addr, dst, sizeof(dst));
4418 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4419 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "Should be WSAEAFNOSUPPORT\n");
4420
4421 /* Test Null destination */
4422 pdst = NULL;
4423 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, NULL, sizeof(dst));
4424 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4425 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4426 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4427
4428 /* Test zero length passed */
4429 WSASetLastError(0);
4430 pdst = NULL;
4431 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 0);
4432 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4433 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4434 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4435
4436 /* Test length one shorter than the address length */
4437 WSASetLastError(0);
4438 pdst = NULL;
4439 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 6);
4440 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4441 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4442 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4443
4444 /* Test longer length is ok */
4445 WSASetLastError(0);
4446 pdst = NULL;
4447 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, sizeof(dst)+1);
4448 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
4449 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
4450
4451 /* Test the IPv6 addresses */
4452
4453 /* Test an zero prefixed IPV6 address */
4454 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
4455 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
4456 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4457 ok(!strcmp(pdst, addr2_Str),"Address %s != %s\n", pdst, addr2_Str);
4458
4459 /* Test an zero suffixed IPV6 address */
4460 memcpy(in6.s6_addr, addr3_Num, sizeof(addr3_Num));
4461 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
4462 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4463 ok(!strcmp(pdst, addr3_Str),"Address %s != %s\n", pdst, addr3_Str);
4464
4465 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
4466 memcpy(in6.s6_addr, addr4_Num, sizeof(addr4_Num));
4467 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, sizeof(dst6));
4468 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
4469 ok(!strcmp(pdst, addr4_Str),"Address %s != %s\n", pdst, addr4_Str);
4470
4471 /* Test invalid parm conditions */
4472 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
4473
4474 /* Test Null destination */
4475 pdst = NULL;
4476 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, NULL, sizeof(dst6));
4477 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4478 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4479 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4480
4481 /* Test zero length passed */
4482 WSASetLastError(0);
4483 pdst = NULL;
4484 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 0);
4485 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4486 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4487 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4488
4489 /* Test length one shorter than the address length */
4490 WSASetLastError(0);
4491 pdst = NULL;
4492 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 16);
4493 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
4494 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
4495 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4496
4497 /* Test longer length is ok */
4498 WSASetLastError(0);
4499 pdst = NULL;
4500 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 18);
4501 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
4502 }
4503 static void test_inet_pton(void)
4504 {
4505 struct TEST_DATA
4506 {
4507 int family, ret;
4508 DWORD err;
4509 const char *printable, *collapsed, *raw_data;
4510 } tests[] = {
4511 {AF_UNSPEC, -1, WSAEFAULT, /* Test 0 */
4512 NULL, NULL, NULL},
4513 {AF_INET, -1, WSAEFAULT,
4514 NULL, NULL, NULL},
4515 {AF_INET6, -1, WSAEFAULT,
4516 NULL, NULL, NULL},
4517 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4518 "127.0.0.1", NULL, NULL},
4519 {AF_INET, 1, 0,
4520 "127.0.0.1", "127.0.0.1",
4521 "\x7f\x00\x00\x01"},
4522 {AF_INET6, 0, 0,
4523 "127.0.0.1", "127.0.0.1", NULL},
4524 {AF_INET, 0, 0,
4525 "::1/128", NULL, NULL},
4526 {AF_INET6, 0, 0,
4527 "::1/128", NULL, NULL},
4528 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4529 "broken", NULL, NULL},
4530 {AF_INET, 0, 0,
4531 "broken", NULL, NULL},
4532 {AF_INET6, 0, 0, /* Test 10 */
4533 "broken", NULL, NULL},
4534 {AF_UNSPEC, -1, WSAEAFNOSUPPORT,
4535 "177.32.45.20", NULL, NULL},
4536 {AF_INET, 1, 0,
4537 "177.32.45.20", "177.32.45.20",
4538 "\xb1\x20\x2d\x14"},
4539 {AF_INET6, 0, 0,
4540 "177.32.45.20", NULL, NULL},
4541 {AF_INET, 0, 0,
4542 "2607:f0d0:1002:51::4", NULL, NULL},
4543 {AF_INET6, 1, 0,
4544 "2607:f0d0:1002:51::4", "2607:f0d0:1002:51::4",
4545 "\x26\x07\xf0\xd0\x10\x02\x00\x51\x00\x00\x00\x00\x00\x00\x00\x04"},
4546 {AF_INET, 0, 0,
4547 "::177.32.45.20", NULL, NULL},
4548 {AF_INET6, 1, 0,
4549 "::177.32.45.20", "::177.32.45.20",
4550 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x20\x2d\x14"},
4551 {AF_INET, 0, 0,
4552 "fe80::0202:b3ff:fe1e:8329", NULL, NULL},
4553 {AF_INET6, 1, 0,
4554 "fe80::0202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
4555 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
4556 {AF_INET6, 1, 0, /* Test 20 */
4557 "fe80::202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
4558 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
4559 {AF_INET, 0, 0,
4560 "a", NULL, NULL},
4561 {AF_INET, 0, 0,
4562 "a.b", NULL, NULL},
4563 {AF_INET, 0, 0,
4564 "a.b.c", NULL, NULL},
4565 {AF_INET, 0, 0,
4566 "a.b.c.d", NULL, NULL},
4567 {AF_INET6, 1, 0,
4568 "2001:cdba:0000:0000:0000:0000:3257:9652", "2001:cdba::3257:9652",
4569 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
4570 {AF_INET6, 1, 0,
4571 "2001:cdba::3257:9652", "2001:cdba::3257:9652",
4572 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
4573 {AF_INET6, 1, 0,
4574 "2001:cdba:0:0:0:0:3257:9652", "2001:cdba::3257:9652",
4575 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"}
4576 };
4577 int i, ret;
4578 DWORD err;
4579 char buffer[64],str[64];
4580 const char *ptr;
4581
4582 /* InetNtop and InetPton became available in Vista and Win2008 */
4583 if (!pInetNtop || !pInetPton)
4584 {
4585 win_skip("InetNtop and/or InetPton not present, not executing tests\n");
4586 return;
4587 }
4588
4589 for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
4590 {
4591 WSASetLastError(0xdeadbeef);
4592 ret = pInetPton(tests[i].family, (char *)tests[i].printable, buffer);
4593 ok (ret == tests[i].ret, "Test [%d]: Expected %d, got %d\n", i, tests[i].ret, ret);
4594 if (tests[i].ret == -1)
4595 {
4596 err = WSAGetLastError();
4597 ok (tests[i].err == err, "Test [%d]: Expected 0x%x, got 0x%x\n", i, tests[i].err, err);
4598 }
4599 if (tests[i].ret != 1) continue;
4600 ok (memcmp(buffer, tests[i].raw_data,
4601 tests[i].family == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr)) == 0,
4602 "Test [%d]: Expected binary data differs\n", i);
4603
4604 /* Test the result from Pton with Ntop */
4605 strcpy (str, "deadbeef");
4606 ptr = pInetNtop(tests[i].family, buffer, str, sizeof(str));
4607 ok (ptr != NULL, "Test [%d]: Failed with NULL\n", i);
4608 ok (ptr == str, "Test [%d]: Pointers differ (%p != %p)\n", i, ptr, str);
4609 if (!ptr) continue;
4610 ok (strcmp(ptr, tests[i].collapsed) == 0, "Test [%d]: Expected '%s', got '%s'\n",
4611 i, tests[i].collapsed, ptr);
4612 }
4613 }
4614
4615 static void test_ioctlsocket(void)
4616 {
4617 SOCKET sock, src, dst;
4618 struct tcp_keepalive kalive;
4619 int ret, optval;
4620 static const LONG cmds[] = {FIONBIO, FIONREAD, SIOCATMARK};
4621 UINT i, bytes_rec;
4622 char data;
4623 WSABUF bufs;
4624 u_long arg = 0;
4625
4626 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4627 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
4628 if(sock == INVALID_SOCKET)
4629 {
4630 skip("Can't continue without a socket.\n");
4631 return;
4632 }
4633
4634 for(i = 0; i < sizeof(cmds)/sizeof(cmds[0]); i++)
4635 {
4636 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
4637 ret = ioctlsocket(sock, cmds[i], (u_long *)1);
4638 ok(ret == SOCKET_ERROR, "ioctlsocket succeeded unexpectedly\n");
4639 ret = WSAGetLastError();
4640 ok(ret == WSAEFAULT, "expected WSAEFAULT, got %d instead\n", ret);
4641 }
4642
4643 /* A fresh and not connected socket has no urgent data, this test shows
4644 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
4645
4646 ret = ioctlsocket(sock, SIOCATMARK, &arg);
4647 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
4648 ok(arg, "SIOCATMARK expected a non-zero value\n");
4649
4650 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
4651 optval = 1;
4652 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
4653 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
4654 arg = 0;
4655 ret = ioctlsocket(sock, SIOCATMARK, &arg);
4656 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
4657 ok(arg, "SIOCATMARK expected a non-zero value\n");
4658
4659 /* disable SO_OOBINLINE and get the same old behavior */
4660 optval = 0;
4661 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
4662 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
4663 arg = 0;
4664 ret = ioctlsocket(sock, SIOCATMARK, &arg);
4665 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
4666 ok(arg, "SIOCATMARK expected a non-zero value\n");
4667
4668 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &arg, 0, NULL, 0, &arg, NULL, NULL);
4669 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4670 ret = WSAGetLastError();
4671 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
4672
4673 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, NULL, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4674 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4675 ret = WSAGetLastError();
4676 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
4677
4678 /* broken used to catch W95, W98, NT4 */
4679 make_keepalive(kalive, 0, 0, 0);
4680 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4681 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4682
4683 make_keepalive(kalive, 1, 0, 0);
4684 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4685 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4686
4687 make_keepalive(kalive, 1, 1000, 1000);
4688 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4689 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4690
4691 make_keepalive(kalive, 1, 10000, 10000);
4692 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4693 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4694
4695 make_keepalive(kalive, 1, 100, 100);
4696 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4697 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4698
4699 make_keepalive(kalive, 0, 100, 100);
4700 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
4701 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
4702
4703 closesocket(sock);
4704
4705 if (tcp_socketpair(&src, &dst) != 0)
4706 {
4707 ok(0, "creating socket pair failed, skipping test\n");
4708 return;
4709 }
4710
4711 /* test FIONREAD on TCP sockets */
4712 optval = 0xdeadbeef;
4713 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
4714 ok(ret == 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
4715 ok(optval == 0, "FIONREAD should have returned 0 bytes, got %d instead\n", optval);
4716
4717 optval = 0xdeadbeef;
4718 ok(send(src, "TEST", 4, 0) == 4, "failed to send test data\n");
4719 Sleep(100);
4720 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
4721 ok(ret == 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
4722 ok(optval == 4, "FIONREAD should have returned 4 bytes, got %d instead\n", optval);
4723
4724 /* trying to read from an OOB inlined socket with MSG_OOB results in WSAEINVAL */
4725 set_blocking(dst, FALSE);
4726 i = MSG_OOB;
4727 SetLastError(0xdeadbeef);
4728 ret = recv(dst, &data, 1, i);
4729 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4730 ret = GetLastError();
4731 ok(ret == WSAEWOULDBLOCK, "expected 10035, got %d\n", ret);
4732 bufs.len = sizeof(char);
4733 bufs.buf = &data;
4734 ret = WSARecv(dst, &bufs, 1, &bytes_rec, &i, NULL, NULL);
4735 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4736 ret = GetLastError();
4737 ok(ret == WSAEWOULDBLOCK, "expected 10035, got %d\n", ret);
4738 optval = 1;
4739 ret = setsockopt(dst, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
4740 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
4741 i = MSG_OOB;
4742 SetLastError(0xdeadbeef);
4743 ret = recv(dst, &data, 1, i);
4744 if (ret == SOCKET_ERROR)
4745 {
4746 ret = GetLastError();
4747 ok(ret == WSAEINVAL, "expected 10022, got %d\n", ret);
4748 bufs.len = sizeof(char);
4749 bufs.buf = &data;
4750 ret = WSARecv(dst, &bufs, 1, &bytes_rec, &i, NULL, NULL);
4751 ok(ret == SOCKET_ERROR, "expected -1, got %d\n", ret);
4752 ret = GetLastError();
4753 ok(ret == WSAEINVAL, "expected 10022, got %d\n", ret);
4754 }
4755 else ok(broken(ret == 1) /* <= NT4 */, "expected error, got 1\n");
4756
4757 closesocket(dst);
4758 optval = 0xdeadbeef;
4759 ret = WSAIoctl(dst, FIONREAD, NULL, 0, &optval, sizeof(optval), &arg, NULL, NULL);
4760 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
4761 ok(optval == 0xdeadbeef, "FIONREAD should not have changed last error, got %d instead\n", optval);
4762 closesocket(src);
4763 }
4764
4765 static BOOL drain_pause = FALSE;
4766 static DWORD WINAPI drain_socket_thread(LPVOID arg)
4767 {
4768 char buffer[1024];
4769 SOCKET sock = *(SOCKET*)arg;
4770 int ret;
4771
4772 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
4773 {
4774 if (ret < 0)
4775 {
4776 if (WSAGetLastError() == WSAEWOULDBLOCK)
4777 {
4778 fd_set readset;
4779 FD_ZERO(&readset);
4780 FD_SET(sock, &readset);
4781 select(sock+1, &readset, NULL, NULL, NULL);
4782 while (drain_pause)
4783 Sleep(100);
4784 }
4785 else
4786 break;
4787 }
4788 }
4789 return 0;
4790 }
4791
4792 static void test_send(void)
4793 {
4794 SOCKET src = INVALID_SOCKET;
4795 SOCKET dst = INVALID_SOCKET;
4796 HANDLE hThread = NULL;
4797 const int buflen = 1024*1024;
4798 char *buffer = NULL;
4799 int ret, i, zero = 0;
4800 WSABUF buf;
4801 OVERLAPPED ov;
4802 BOOL bret;
4803 DWORD id, bytes_sent, dwRet;
4804
4805 memset(&ov, 0, sizeof(ov));
4806
4807 if (tcp_socketpair(&src, &dst) != 0)
4808 {
4809 ok(0, "creating socket pair failed, skipping test\n");
4810 return;
4811 }
4812
4813 set_blocking(dst, FALSE);
4814 /* force disable buffering so we can get a pending overlapped request */
4815 ret = setsockopt(dst, SOL_SOCKET, SO_SNDBUF, (char *) &zero, sizeof(zero));
4816 ok(!ret, "setsockopt SO_SNDBUF failed: %d - %d\n", ret, GetLastError());
4817
4818 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
4819 if (hThread == NULL)
4820 {
4821 ok(0, "CreateThread failed, error %d\n", GetLastError());
4822 goto end;
4823 }
4824
4825 buffer = HeapAlloc(GetProcessHeap(), 0, buflen);
4826 if (buffer == NULL)
4827 {
4828 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
4829 goto end;
4830 }
4831
4832 /* fill the buffer with some nonsense */
4833 for (i = 0; i < buflen; ++i)
4834 {
4835 buffer[i] = (char) i;
4836 }
4837
4838 ret = send(src, buffer, buflen, 0);
4839 if (ret >= 0)
4840 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
4841 else
4842 ok(0, "send failed, error %d\n", WSAGetLastError());
4843
4844 buf.buf = buffer;
4845 buf.len = buflen;
4846
4847 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
4848 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
4849 if (!ov.hEvent)
4850 goto end;
4851
4852 bytes_sent = 0;
4853 WSASetLastError(12345);
4854 ret = WSASend(dst, &buf, 1, &bytes_sent, 0, &ov, NULL);
4855 ok((ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING) || broken(bytes_sent == buflen),
4856 "Failed to start overlapped send %d - %d - %d/%d\n", ret, WSAGetLastError(), bytes_sent, buflen);
4857
4858 /* don't check for completion yet, we may need to drain the buffer while still sending */
4859 set_blocking(src, FALSE);
4860 for (i = 0; i < buflen; ++i)
4861 {
4862 int j = 0;
4863
4864 ret = recv(src, buffer, 1, 0);
4865 while (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK && j < 100)
4866 {
4867 j++;
4868 Sleep(50);
4869 ret = recv(src, buffer, 1, 0);
4870 }
4871
4872 ok(ret == 1, "Failed to receive data %d - %d (got %d/%d)\n", ret, GetLastError(), i, buflen);
4873 if (ret != 1)
4874 break;
4875
4876 ok(buffer[0] == (char) i, "Received bad data at position %d\n", i);
4877 }
4878
4879 dwRet = WaitForSingleObject(ov.hEvent, 1000);
4880 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
4881 if (dwRet == WAIT_OBJECT_0)
4882 {
4883 bret = GetOverlappedResult((HANDLE)dst, &ov, &bytes_sent, FALSE);
4884 ok((bret && bytes_sent == buflen) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
4885 "Got %d instead of %d (%d - %d)\n", bytes_sent, buflen, bret, GetLastError());
4886 }
4887
4888 WSASetLastError(12345);
4889 ret = WSASend(INVALID_SOCKET, &buf, 1, NULL, 0, &ov, NULL);
4890 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
4891 "WSASend failed %d - %d\n", ret, WSAGetLastError());
4892
4893 WSASetLastError(12345);
4894 ret = WSASend(dst, &buf, 1, NULL, 0, &ov, NULL);
4895 ok(ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING,
4896 "Failed to start overlapped send %d - %d\n", ret, WSAGetLastError());
4897
4898 end:
4899 if (src != INVALID_SOCKET)
4900 closesocket(src);
4901 if (dst != INVALID_SOCKET)
4902 closesocket(dst);
4903 if (hThread != NULL)
4904 {
4905 dwRet = WaitForSingleObject(hThread, 500);
4906 ok(dwRet == WAIT_OBJECT_0, "failed to wait for thread termination: %d\n", GetLastError());
4907 CloseHandle(hThread);
4908 }
4909 if (ov.hEvent)
4910 CloseHandle(ov.hEvent);
4911 HeapFree(GetProcessHeap(), 0, buffer);
4912 }
4913
4914 typedef struct async_message
4915 {
4916 SOCKET socket;
4917 LPARAM lparam;
4918 struct async_message *next;
4919 } async_message;
4920
4921 static struct async_message *messages_received;
4922
4923 #define WM_SOCKET (WM_USER+100)
4924 static LRESULT CALLBACK ws2_test_WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
4925 {
4926 struct async_message *message;
4927
4928 switch (msg)
4929 {
4930 case WM_SOCKET:
4931 message = HeapAlloc(GetProcessHeap(), 0, sizeof(*message));
4932 message->socket = (SOCKET) wparam;
4933 message->lparam = lparam;
4934 message->next = NULL;
4935
4936 if (messages_received)
4937 {
4938 struct async_message *last = messages_received;
4939 while (last->next) last = last->next;
4940 last->next = message;
4941 }
4942 else
4943 messages_received = message;
4944 return 0;
4945 }
4946
4947 return DefWindowProcA(hwnd, msg, wparam, lparam);
4948 }
4949
4950 static void get_event_details(int event, int *bit, char *name)
4951 {
4952 switch (event)
4953 {
4954 case FD_ACCEPT:
4955 if (bit) *bit = FD_ACCEPT_BIT;
4956 if (name) strcpy(name, "FD_ACCEPT");
4957 break;
4958 case FD_CONNECT:
4959 if (bit) *bit = FD_CONNECT_BIT;
4960 if (name) strcpy(name, "FD_CONNECT");
4961 break;
4962 case FD_READ:
4963 if (bit) *bit = FD_READ_BIT;
4964 if (name) strcpy(name, "FD_READ");
4965 break;
4966 case FD_OOB:
4967 if (bit) *bit = FD_OOB_BIT;
4968 if (name) strcpy(name, "FD_OOB");
4969 break;
4970 case FD_WRITE:
4971 if (bit) *bit = FD_WRITE_BIT;
4972 if (name) strcpy(name, "FD_WRITE");
4973 break;
4974 case FD_CLOSE:
4975 if (bit) *bit = FD_CLOSE_BIT;
4976 if (name) strcpy(name, "FD_CLOSE");
4977 break;
4978 default:
4979 if (bit) *bit = -1;
4980 if (name) sprintf(name, "bad%x", event);
4981 }
4982 }
4983
4984 static const char *dbgstr_event_seq(const LPARAM *seq)
4985 {
4986 static char message[1024];
4987 char name[12];
4988 int len = 1;
4989
4990 message[0] = '[';
4991 message[1] = 0;
4992 while (*seq)
4993 {
4994 get_event_details(WSAGETSELECTEVENT(*seq), NULL, name);
4995 len += sprintf(message + len, "%s(%d) ", name, WSAGETSELECTERROR(*seq));
4996 seq++;
4997 }
4998 if (len > 1) len--;
4999 strcpy( message + len, "]" );
5000 return message;
5001 }
5002
5003 static char *dbgstr_event_seq_result(SOCKET s, WSANETWORKEVENTS *netEvents)
5004 {
5005 static char message[1024];
5006 struct async_message *curr = messages_received;
5007 int index, error, bit = 0;
5008 char name[12];
5009 int len = 1;
5010
5011 message[0] = '[';
5012 message[1] = 0;
5013 while (1)
5014 {
5015 if (netEvents)
5016 {
5017 if (bit >= FD_MAX_EVENTS) break;
5018 if ( !(netEvents->lNetworkEvents & (1 << bit)) )
5019 {
5020 bit++;
5021 continue;
5022 }
5023 get_event_details(1 << bit, &index, name);
5024 error = netEvents->iErrorCode[index];
5025 bit++;
5026 }
5027 else
5028 {
5029 if (!curr) break;
5030 if (curr->socket != s)
5031 {
5032 curr = curr->next;
5033 continue;
5034 }
5035 get_event_details(WSAGETSELECTEVENT(curr->lparam), NULL, name);
5036 error = WSAGETSELECTERROR(curr->lparam);
5037 curr = curr->next;
5038 }
5039
5040 len += sprintf(message + len, "%s(%d) ", name, error);
5041 }
5042 if (len > 1) len--;
5043 strcpy( message + len, "]" );
5044 return message;
5045 }
5046
5047 static void flush_events(SOCKET s, HANDLE hEvent)
5048 {
5049 WSANETWORKEVENTS netEvents;
5050 struct async_message *prev = NULL, *curr = messages_received;
5051 int ret;
5052 DWORD dwRet;
5053
5054 if (hEvent != INVALID_HANDLE_VALUE)
5055 {
5056 dwRet = WaitForSingleObject(hEvent, 100);
5057 if (dwRet == WAIT_OBJECT_0)
5058 {
5059 ret = WSAEnumNetworkEvents(s, hEvent, &netEvents);
5060 if (ret)
5061 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
5062 }
5063 }
5064 else
5065 {
5066 while (curr)
5067 {
5068 if (curr->socket == s)
5069 {
5070 if (prev) prev->next = curr->next;
5071 else messages_received = curr->next;
5072
5073 HeapFree(GetProcessHeap(), 0, curr);
5074
5075 if (prev) curr = prev->next;
5076 else curr = messages_received;
5077 }
5078 else
5079 {
5080 prev = curr;
5081 curr = curr->next;
5082 }
5083 }
5084 }
5085 }
5086
5087 static int match_event_sequence(SOCKET s, WSANETWORKEVENTS *netEvents, const LPARAM *seq)
5088 {
5089 int event, index, error, events;
5090 struct async_message *curr;
5091
5092 if (netEvents)
5093 {
5094 events = netEvents->lNetworkEvents;
5095 while (*seq)
5096 {
5097 event = WSAGETSELECTEVENT(*seq);
5098 error = WSAGETSELECTERROR(*seq);
5099 get_event_details(event, &index, NULL);
5100
5101 if (!(events & event) && index != -1)
5102 return 0;
5103 if (events & event && index != -1)
5104 {
5105 if (netEvents->iErrorCode[index] != error)
5106 return 0;
5107 }
5108 events &= ~event;
5109 seq++;
5110 }
5111 if (events)
5112 return 0;
5113 }
5114 else
5115 {
5116 curr = messages_received;
5117 while (curr)
5118 {
5119 if (curr->socket == s)
5120 {
5121 if (!*seq) return 0;
5122 if (*seq != curr->lparam) return 0;
5123 seq++;
5124 }
5125 curr = curr->next;
5126 }
5127 if (*seq)
5128 return 0;
5129 }
5130 return 1;
5131 }
5132
5133 /* checks for a sequence of events, (order only checked if window is used) */
5134 static void ok_event_sequence(SOCKET s, HANDLE hEvent, const LPARAM *seq, const LPARAM **broken_seqs, int completelyBroken)
5135 {
5136 MSG msg;
5137 WSANETWORKEVENTS events, *netEvents = NULL;
5138 int ret;
5139 DWORD dwRet;
5140
5141 if (hEvent != INVALID_HANDLE_VALUE)
5142 {
5143 netEvents = &events;
5144
5145 dwRet = WaitForSingleObject(hEvent, 200);
5146 if (dwRet == WAIT_OBJECT_0)
5147 {
5148 ret = WSAEnumNetworkEvents(s, hEvent, netEvents);
5149 if (ret)
5150 {
5151 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
5152 return;
5153 }
5154 }
5155 else
5156 memset(netEvents, 0, sizeof(*netEvents));
5157 }
5158 else
5159 {
5160 Sleep(200);
5161 /* Run the message loop a little */
5162 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
5163 {
5164 DispatchMessageA(&msg);
5165 }
5166 }
5167
5168 if (match_event_sequence(s, netEvents, seq))
5169 {
5170 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq));
5171 flush_events(s, hEvent);
5172 return;
5173 }
5174
5175 if (broken_seqs)
5176 {
5177 for (; *broken_seqs; broken_seqs++)
5178 {
5179 if (match_event_sequence(s, netEvents, *broken_seqs))
5180 {
5181 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s, netEvents), dbgstr_event_seq(seq));
5182 flush_events(s, hEvent);
5183 return;
5184 }
5185 }
5186 }
5187
5188 winetest_ok(broken(completelyBroken), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq),
5189 dbgstr_event_seq_result(s, netEvents));
5190 flush_events(s, hEvent);
5191 }
5192
5193 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
5194
5195 static void test_events(int useMessages)
5196 {
5197 SOCKET server = INVALID_SOCKET;
5198 SOCKET src = INVALID_SOCKET, src2 = INVALID_SOCKET;
5199 SOCKET dst = INVALID_SOCKET, dst2 = INVALID_SOCKET;
5200 struct sockaddr_in addr;
5201 HANDLE hThread = NULL;
5202 HANDLE hEvent = INVALID_HANDLE_VALUE, hEvent2 = INVALID_HANDLE_VALUE;
5203 WNDCLASSEXA wndclass;
5204 HWND hWnd = NULL;
5205 char *buffer = NULL;
5206 int bufferSize = 1024*1024;
5207 WSABUF bufs;
5208 OVERLAPPED ov, ov2;
5209 DWORD flags = 0;
5210 DWORD bytesReturned;
5211 DWORD id;
5212 int len;
5213 int ret;
5214 DWORD dwRet;
5215 BOOL bret;
5216 static char szClassName[] = "wstestclass";
5217 const LPARAM *broken_seq[3];
5218 static const LPARAM empty_seq[] = { 0 };
5219 static const LPARAM close_seq[] = { WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
5220 static const LPARAM write_seq[] = { WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5221 static const LPARAM read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0), 0 };
5222 static const LPARAM oob_seq[] = { WSAMAKESELECTREPLY(FD_OOB, 0), 0 };
5223 static const LPARAM connect_seq[] = { WSAMAKESELECTREPLY(FD_CONNECT, 0),
5224 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5225 static const LPARAM read_read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5226 WSAMAKESELECTREPLY(FD_READ, 0), 0 };
5227 static const LPARAM read_write_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5228 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
5229 static const LPARAM read_close_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
5230 WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
5231
5232 memset(&ov, 0, sizeof(ov));
5233 memset(&ov2, 0, sizeof(ov2));
5234
5235 /* don't use socketpair, we want connection event */
5236 src = socket(AF_INET, SOCK_STREAM, 0);
5237 if (src == INVALID_SOCKET)
5238 {
5239 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5240 goto end;
5241 }
5242
5243 ret = set_blocking(src, TRUE);
5244 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5245
5246 src2 = socket(AF_INET, SOCK_STREAM, 0);
5247 if (src2 == INVALID_SOCKET)
5248 {
5249 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5250 goto end;
5251 }
5252
5253 ret = set_blocking(src2, TRUE);
5254 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5255
5256 len = sizeof(BOOL);
5257 if (getsockopt(src, SOL_SOCKET, SO_OOBINLINE, (void *)&bret, &len) == SOCKET_ERROR)
5258 {
5259 ok(0, "failed to get oobinline status, %d\n", GetLastError());
5260 goto end;
5261 }
5262 ok(bret == FALSE, "OOB not inline\n");
5263
5264 if (useMessages)
5265 {
5266 trace("Event test using messages\n");
5267
5268 wndclass.cbSize = sizeof(wndclass);
5269 wndclass.style = CS_HREDRAW | CS_VREDRAW;
5270 wndclass.lpfnWndProc = ws2_test_WndProc;
5271 wndclass.cbClsExtra = 0;
5272 wndclass.cbWndExtra = 0;
5273 wndclass.hInstance = GetModuleHandleA(NULL);
5274 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
5275 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
5276 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
5277 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
5278 wndclass.lpszClassName = szClassName;
5279 wndclass.lpszMenuName = NULL;
5280 RegisterClassExA(&wndclass);
5281
5282 hWnd = CreateWindowA(szClassName, "WS2Test", WS_OVERLAPPEDWINDOW,
5283 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
5284 if (!hWnd)
5285 {
5286 ok(0, "failed to create window: %d\n", GetLastError());
5287 return;
5288 }
5289
5290 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5291 if (ret)
5292 {
5293 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5294 goto end;
5295 }
5296
5297 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5298 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5299
5300 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5301 if (ret)
5302 {
5303 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5304 goto end;
5305 }
5306
5307 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5308 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5309 }
5310 else
5311 {
5312 trace("Event test using events\n");
5313
5314 hEvent = WSACreateEvent();
5315 if (hEvent == INVALID_HANDLE_VALUE)
5316 {
5317 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5318 goto end;
5319 }
5320
5321 hEvent2 = WSACreateEvent();
5322 if (hEvent2 == INVALID_HANDLE_VALUE)
5323 {
5324 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5325 goto end;
5326 }
5327
5328 ret = WSAEventSelect(src, hEvent, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5329 if (ret)
5330 {
5331 ok(0, "WSAEventSelect failed, error %d\n", ret);
5332 goto end;
5333 }
5334
5335 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5336 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5337
5338 ret = WSAEventSelect(src2, hEvent2, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
5339 if (ret)
5340 {
5341 ok(0, "WSAEventSelect failed, error %d\n", ret);
5342 goto end;
5343 }
5344
5345 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
5346 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5347 }
5348
5349 server = socket(AF_INET, SOCK_STREAM, 0);
5350 if (server == INVALID_SOCKET)
5351 {
5352 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5353 goto end;
5354 }
5355
5356 memset(&addr, 0, sizeof(addr));
5357 addr.sin_family = AF_INET;
5358 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
5359 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
5360 if (ret != 0)
5361 {
5362 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5363 goto end;
5364 }
5365
5366 len = sizeof(addr);
5367 ret = getsockname(server, (struct sockaddr*)&addr, &len);
5368 if (ret != 0)
5369 {
5370 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5371 goto end;
5372 }
5373
5374 ret = listen(server, 2);
5375 if (ret != 0)
5376 {
5377 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5378 goto end;
5379 }
5380
5381 ret = connect(src, (struct sockaddr*)&addr, sizeof(addr));
5382 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
5383 {
5384 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5385 goto end;
5386 }
5387
5388 ret = connect(src2, (struct sockaddr*)&addr, sizeof(addr));
5389 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
5390 {
5391 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5392 goto end;
5393 }
5394
5395 len = sizeof(addr);
5396 dst = accept(server, (struct sockaddr*)&addr, &len);
5397 if (dst == INVALID_SOCKET)
5398 {
5399 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5400 goto end;
5401 }
5402
5403 len = sizeof(addr);
5404 dst2 = accept(server, (struct sockaddr*)&addr, &len);
5405 if (dst2 == INVALID_SOCKET)
5406 {
5407 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5408 goto end;
5409 }
5410
5411 closesocket(server);
5412 server = INVALID_SOCKET;
5413
5414 /* On Windows it seems when a non-blocking socket sends to a
5415 blocking socket on the same host, the send() is BLOCKING,
5416 so make both sockets non-blocking. src is already non-blocking
5417 from the async select */
5418
5419 if (set_blocking(dst, FALSE))
5420 {
5421 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
5422 goto end;
5423 }
5424
5425 buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufferSize);
5426 if (buffer == NULL)
5427 {
5428 ok(0, "could not allocate memory for test\n");
5429 goto end;
5430 }
5431
5432 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5433 if (ov.hEvent == NULL)
5434 {
5435 ok(0, "could not create event object, errno = %d\n", GetLastError());
5436 goto end;
5437 }
5438
5439 ov2.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5440 if (ov2.hEvent == NULL)
5441 {
5442 ok(0, "could not create event object, errno = %d\n", GetLastError());
5443 goto end;
5444 }
5445
5446 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
5447 ok_event_seq(src, hEvent, connect_seq, NULL, 1);
5448 ok_event_seq(src2, hEvent2, connect_seq, NULL, 1);
5449 /* broken on all windows - FD_CONNECT error is garbage */
5450
5451 /* Test simple send/recv */
5452 SetLastError(0xdeadbeef);
5453 ret = send(dst, buffer, 100, 0);
5454 ok(ret == 100, "Failed to send buffer %d err %d\n", ret, GetLastError());
5455 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5456 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5457
5458 SetLastError(0xdeadbeef);
5459 ret = recv(src, buffer, 1, MSG_PEEK);
5460 ok(ret == 1, "Failed to peek at recv buffer %d err %d\n", ret, GetLastError());
5461 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5462 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5463
5464 SetLastError(0xdeadbeef);
5465 ret = recv(src, buffer, 50, 0);
5466 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5467 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5468 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5469
5470 ret = recv(src, buffer, 50, 0);
5471 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5472 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5473
5474 /* fun fact - events are re-enabled even on failure, but only for messages */
5475 ret = send(dst, "1", 1, 0);
5476 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5477 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5478
5479 ret = recv(src, buffer, -1, 0);
5480 ok(ret == SOCKET_ERROR && (GetLastError() == WSAEFAULT || GetLastError() == WSAENOBUFS),
5481 "Failed to recv buffer %d err %d\n", ret, GetLastError());
5482 if (useMessages)
5483 {
5484 broken_seq[0] = empty_seq; /* win9x */
5485 broken_seq[1] = NULL;
5486 todo_wine ok_event_seq(src, hEvent, read_seq, broken_seq, 0);
5487 }
5488 else
5489 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5490
5491 SetLastError(0xdeadbeef);
5492 ret = recv(src, buffer, 1, 0);
5493 ok(ret == 1, "Failed to recv buffer %d err %d\n", ret, GetLastError());
5494 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5495 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5496
5497 /* Interaction with overlapped */
5498 bufs.len = sizeof(char);
5499 bufs.buf = buffer;
5500 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
5501 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
5502 "WSARecv failed - %d error %d\n", ret, GetLastError());
5503
5504 bufs.len = sizeof(char);
5505 bufs.buf = buffer+1;
5506 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov2, NULL);
5507 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
5508 "WSARecv failed - %d error %d\n", ret, GetLastError());
5509
5510 ret = send(dst, "12", 2, 0);
5511 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
5512 broken_seq[0] = read_read_seq; /* win9x */
5513 broken_seq[1] = NULL;
5514 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
5515
5516 dwRet = WaitForSingleObject(ov.hEvent, 100);
5517 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5518 if (dwRet == WAIT_OBJECT_0)
5519 {
5520 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
5521 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5522 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
5523 ok(buffer[0] == '1', "Got %c instead of 1\n", buffer[0]);
5524 }
5525
5526 dwRet = WaitForSingleObject(ov2.hEvent, 100);
5527 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5528 if (dwRet == WAIT_OBJECT_0)
5529 {
5530 bret = GetOverlappedResult((HANDLE)src, &ov2, &bytesReturned, FALSE);
5531 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5532 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
5533 ok(buffer[1] == '2', "Got %c instead of 2\n", buffer[1]);
5534 }
5535
5536 SetLastError(0xdeadbeef);
5537 ret = send(dst, "1", 1, 0);
5538 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5539 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5540 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5541
5542 ret = recv(src, buffer, 1, 0);
5543 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5544 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5545
5546 /* Notifications are delivered as soon as possible, blocked only on
5547 * async requests on the same type */
5548 bufs.len = sizeof(char);
5549 bufs.buf = buffer;
5550 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
5551 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
5552 "WSARecv failed - %d error %d\n", ret, GetLastError());
5553
5554 if (0) {
5555 ret = send(dst, "1", 1, MSG_OOB);
5556 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5557 ok_event_seq(src, hEvent, oob_seq, NULL, 0);
5558 }
5559
5560 dwRet = WaitForSingleObject(ov.hEvent, 100);
5561 ok(dwRet == WAIT_TIMEOUT, "OOB message activated read?: %d - %d\n", dwRet, GetLastError());
5562
5563 ret = send(dst, "2", 1, 0);
5564 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
5565 broken_seq[0] = read_seq; /* win98 */
5566 broken_seq[1] = NULL;
5567 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
5568
5569 dwRet = WaitForSingleObject(ov.hEvent, 100);
5570 ok(dwRet == WAIT_OBJECT_0 || broken(dwRet == WAIT_TIMEOUT),
5571 "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
5572 if (dwRet == WAIT_OBJECT_0)
5573 {
5574 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
5575 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
5576 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
5577 ok(buffer[0] == '2', "Got %c instead of 2\n", buffer[0]);
5578 }
5579 else if (dwRet == WAIT_TIMEOUT)
5580 {
5581 /* this happens on win98. We get an FD_READ later on the next test */
5582 CancelIo((HANDLE) src);
5583 }
5584
5585 if (0) {
5586 ret = recv(src, buffer, 1, MSG_OOB);
5587 todo_wine ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5588 /* We get OOB notification, but no data on wine */
5589 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5590 }
5591
5592 /* Flood the send queue */
5593 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
5594 if (hThread == NULL)
5595 {
5596 ok(0, "CreateThread failed, error %d\n", GetLastError());
5597 goto end;
5598 }
5599
5600 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
5601 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
5602
5603 /* Now if we send a ton of data and the 'server' does not drain it fast
5604 * enough (set drain_pause to be sure), the socket send buffer will only
5605 * take some of it, and we will get a short write. This will trigger
5606 * another FD_WRITE event as soon as data is sent and more space becomes
5607 * available, but not any earlier. */
5608 drain_pause = TRUE;
5609 do
5610 {
5611 ret = send(src, buffer, bufferSize, 0);
5612 } while (ret == bufferSize);
5613 drain_pause = FALSE;
5614 if (ret >= 0 || WSAGetLastError() == WSAEWOULDBLOCK)
5615 {
5616 Sleep(400); /* win9x */
5617 broken_seq[0] = read_write_seq;
5618 broken_seq[1] = NULL;
5619 ok_event_seq(src, hEvent, write_seq, broken_seq, 0);
5620 }
5621 else
5622 {
5623 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
5624 }
5625
5626 /* Test how FD_CLOSE is handled */
5627 ret = send(dst, "12", 2, 0);
5628 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
5629
5630 /* Wait a little and let the send complete */
5631 Sleep(100);
5632 closesocket(dst);
5633 dst = INVALID_SOCKET;
5634 Sleep(100);
5635
5636 /* We can never implement this in wine, best we can hope for is
5637 sending FD_CLOSE after the reads complete */
5638 broken_seq[0] = read_seq; /* win9x */
5639 broken_seq[1] = NULL;
5640 todo_wine ok_event_seq(src, hEvent, read_close_seq, broken_seq, 0);
5641
5642 ret = recv(src, buffer, 1, 0);
5643 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5644 ok_event_seq(src, hEvent, read_seq, NULL, 0);
5645
5646 ret = recv(src, buffer, 1, 0);
5647 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5648 /* want it? it's here, but you can't have it */
5649 broken_seq[0] = close_seq; /* win9x */
5650 broken_seq[1] = NULL;
5651 todo_wine ok_event_seq(src, hEvent, empty_seq, /* wine sends FD_CLOSE here */
5652 broken_seq, 0);
5653
5654 /* Test how FD_CLOSE is handled */
5655 ret = send(dst2, "12", 2, 0);
5656 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
5657
5658 Sleep(200);
5659 shutdown(dst2, SD_SEND);
5660 Sleep(200);
5661
5662 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
5663 regressions, don't mark them as todo_wine, and mark windows as broken */
5664 broken_seq[0] = read_close_seq;
5665 broken_seq[1] = close_seq;
5666 broken_seq[2] = NULL;
5667 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
5668
5669 ret = recv(src2, buffer, 1, 0);
5670 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5671 broken_seq[0] = close_seq; /* win98 */
5672 broken_seq[1] = NULL;
5673 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
5674
5675 ret = recv(src2, buffer, 1, 0);
5676 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
5677 broken_seq[0] = empty_seq;
5678 broken_seq[1] = NULL;
5679 ok_event_seq(src2, hEvent2, close_seq, broken_seq, 0);
5680
5681 ret = send(src2, "1", 1, 0);
5682 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
5683 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
5684
5685 ret = send(src2, "1", 1, 0);
5686 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
5687 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
5688
5689 if (useMessages)
5690 {
5691 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, 0);
5692 if (ret)
5693 {
5694 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5695 goto end;
5696 }
5697
5698 ret = set_blocking(src, TRUE);
5699 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5700
5701 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, 0);
5702 if (ret)
5703 {
5704 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5705 goto end;
5706 }
5707
5708 ret = set_blocking(src2, TRUE);
5709 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5710 }
5711 else
5712 {
5713 ret = WSAEventSelect(src, hEvent2, 0);
5714 if (ret)
5715 {
5716 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5717 goto end;
5718 }
5719
5720 ret = set_blocking(src, TRUE);
5721 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5722
5723 ret = WSAEventSelect(src2, hEvent2, 0);
5724 if (ret)
5725 {
5726 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
5727 goto end;
5728 }
5729
5730 ret = set_blocking(src2, TRUE);
5731 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
5732 }
5733
5734 end:
5735 if (src != INVALID_SOCKET)
5736 {
5737 flush_events(src, hEvent);
5738 closesocket(src);
5739 }
5740 if (src2 != INVALID_SOCKET)
5741 {
5742 flush_events(src2, hEvent2);
5743 closesocket(src2);
5744 }
5745 HeapFree(GetProcessHeap(), 0, buffer);
5746 if (server != INVALID_SOCKET)
5747 closesocket(server);
5748 if (dst != INVALID_SOCKET)
5749 closesocket(dst);
5750 if (dst2 != INVALID_SOCKET)
5751 closesocket(dst2);
5752 if (hThread != NULL)
5753 CloseHandle(hThread);
5754 if (hWnd != NULL)
5755 DestroyWindow(hWnd);
5756 if (hEvent != NULL)
5757 CloseHandle(hEvent);
5758 if (hEvent2 != NULL)
5759 CloseHandle(hEvent2);
5760 if (ov.hEvent != NULL)
5761 CloseHandle(ov.hEvent);
5762 if (ov2.hEvent != NULL)
5763 CloseHandle(ov2.hEvent);
5764 }
5765
5766 static void test_ipv6only(void)
5767 {
5768 SOCKET v4 = INVALID_SOCKET,
5769 v6 = INVALID_SOCKET;
5770 struct sockaddr_in sin4;
5771 struct sockaddr_in6 sin6;
5772 int ret;
5773
5774 memset(&sin4, 0, sizeof(sin4));
5775 sin4.sin_family = AF_INET;
5776 sin4.sin_port = htons(SERVERPORT);
5777
5778 memset(&sin6, 0, sizeof(sin6));
5779 sin6.sin6_family = AF_INET6;
5780 sin6.sin6_port = htons(SERVERPORT);
5781
5782 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
5783 if (v6 == INVALID_SOCKET) {
5784 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
5785 WSAGetLastError(), WSAEAFNOSUPPORT);
5786 goto end;
5787 }
5788 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
5789 if (ret) {
5790 skip("Could not bind IPv6 address (LastError: %d).\n",
5791 WSAGetLastError());
5792 goto end;
5793 }
5794
5795 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
5796 if (v4 == INVALID_SOCKET) {
5797 skip("Could not create IPv4 socket (LastError: %d).\n",
5798 WSAGetLastError());
5799 goto end;
5800 }
5801 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
5802 ok(!ret, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
5803 WSAGetLastError(), WSAEADDRINUSE);
5804
5805 end:
5806 if (v4 != INVALID_SOCKET)
5807 closesocket(v4);
5808 if (v6 != INVALID_SOCKET)
5809 closesocket(v6);
5810 }
5811
5812 static void test_WSASendMsg(void)
5813 {
5814 SOCKET sock, dst;
5815 struct sockaddr_in sendaddr, sockaddr;
5816 GUID WSASendMsg_GUID = WSAID_WSASENDMSG;
5817 LPFN_WSASENDMSG pWSASendMsg = NULL;
5818 char teststr[12] = "hello world", buffer[32];
5819 WSABUF iovec[2];
5820 WSAMSG msg;
5821 DWORD bytesSent, err;
5822 int ret, addrlen;
5823
5824 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
5825
5826 sock = socket(AF_INET, SOCK_DGRAM, 0);
5827 ok(sock != INVALID_SOCKET, "socket() failed\n");
5828
5829 /* Obtain the WSASendMsg function */
5830 WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsg_GUID, sizeof(WSASendMsg_GUID),
5831 &pWSASendMsg, sizeof(pWSASendMsg), &err, NULL, NULL);
5832 if (!pWSASendMsg)
5833 {
5834 closesocket(sock);
5835 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
5836 return;
5837 }
5838
5839 /* fake address for now */
5840 sendaddr.sin_family = AF_INET;
5841 sendaddr.sin_port = htons(139);
5842 sendaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5843
5844 memset(&msg, 0, sizeof(msg));
5845 iovec[0].buf = teststr;
5846 iovec[0].len = sizeof(teststr);
5847 iovec[1].buf = teststr;
5848 iovec[1].len = sizeof(teststr) / 2;
5849 msg.name = (struct sockaddr *) &sendaddr;
5850 msg.namelen = sizeof(sendaddr);
5851 msg.lpBuffers = iovec;
5852 msg.dwBufferCount = 1; /* send only one buffer for now */
5853
5854 WSASetLastError(0xdeadbeef);
5855 ret = pWSASendMsg(INVALID_SOCKET, &msg, 0, NULL, NULL, NULL);
5856 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5857 err = WSAGetLastError();
5858 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
5859
5860 WSASetLastError(0xdeadbeef);
5861 ret = pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL);
5862 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5863 err = WSAGetLastError();
5864 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
5865
5866 WSASetLastError(0xdeadbeef);
5867 ret = pWSASendMsg(sock, NULL, 0, &bytesSent, NULL, NULL);
5868 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5869 err = WSAGetLastError();
5870 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
5871
5872 WSASetLastError(0xdeadbeef);
5873 ret = pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL);
5874 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5875 err = WSAGetLastError();
5876 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
5877
5878 closesocket(sock);
5879
5880 sock = socket(AF_INET, SOCK_DGRAM, 0);
5881 ok(sock != INVALID_SOCKET, "socket() failed\n");
5882
5883 dst = socket(AF_INET, SOCK_DGRAM, 0);
5884 ok(dst != INVALID_SOCKET, "socket() failed\n");
5885
5886 memset(&sockaddr, 0, sizeof(sockaddr));
5887 sockaddr.sin_family = AF_INET;
5888 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5889 ok(!bind(dst, (struct sockaddr*)&sockaddr, sizeof(sockaddr)),
5890 "bind should have worked\n");
5891
5892 /* read address to find out the port number to be used in send */
5893 memset(&sendaddr, 0, sizeof(sendaddr));
5894 addrlen = sizeof(sendaddr);
5895 ok(!getsockname(dst, (struct sockaddr *) &sendaddr, &addrlen),
5896 "getsockname should have worked\n");
5897 ok(sendaddr.sin_port, "socket port should be != 0\n");
5898
5899 /* ensure the sending socket is not bound */
5900 WSASetLastError(0xdeadbeef);
5901 addrlen = sizeof(sockaddr);
5902 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
5903 ok(ret == SOCKET_ERROR, "getsockname should have failed\n");
5904 err = WSAGetLastError();
5905 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
5906
5907 set_blocking(sock, TRUE);
5908
5909 bytesSent = 0;
5910 SetLastError(0xdeadbeef);
5911 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
5912 ok(!ret, "WSASendMsg should have worked\n");
5913 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
5914 "Expected 0, got %d\n", GetLastError());
5915 ok(bytesSent == iovec[0].len, "incorret bytes sent, expected %d, sent %d\n",
5916 iovec[0].len, bytesSent);
5917
5918 /* receive data */
5919 addrlen = sizeof(sockaddr);
5920 memset(buffer, 0, sizeof(buffer));
5921 SetLastError(0xdeadbeef);
5922 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
5923 ok(ret == bytesSent, "got %d, expected %d\n",
5924 ret, bytesSent);
5925 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5926
5927 /* A successful call to WSASendMsg must have bound the socket */
5928 addrlen = sizeof(sockaddr);
5929 sockaddr.sin_port = 0;
5930 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5931 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
5932 ok(!ret, "getsockname should have worked\n");
5933 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
5934 inet_ntoa(sockaddr.sin_addr));
5935 ok(sockaddr.sin_port, "sin_port should be != 0\n");
5936
5937 msg.dwBufferCount = 2; /* send both buffers */
5938
5939 bytesSent = 0;
5940 SetLastError(0xdeadbeef);
5941 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
5942 ok(!ret, "WSASendMsg should have worked\n");
5943 ok(bytesSent == iovec[0].len + iovec[1].len, "incorret bytes sent, expected %d, sent %d\n",
5944 iovec[0].len + iovec[1].len, bytesSent);
5945 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
5946 "Expected 0, got %d\n", GetLastError());
5947
5948 /* receive data */
5949 addrlen = sizeof(sockaddr);
5950 memset(buffer, 0, sizeof(buffer));
5951 SetLastError(0xdeadbeef);
5952 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
5953 ok(ret == bytesSent, "got %d, expected %d\n",
5954 ret, bytesSent);
5955 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
5956
5957 closesocket(sock);
5958 closesocket(dst);
5959
5960 /* a bad call to WSASendMsg will also bind the socket */
5961 addrlen = sizeof(sockaddr);
5962 sockaddr.sin_port = 0;
5963 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5964 sock = socket(AF_INET, SOCK_DGRAM, 0);
5965 ok(sock != INVALID_SOCKET, "socket() failed\n");
5966 ok(pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
5967 todo_wine {
5968 ok(!getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have worked\n");
5969 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
5970 inet_ntoa(sockaddr.sin_addr));
5971 ok(sockaddr.sin_port, "sin_port should be > 0\n");
5972 }
5973 closesocket(sock);
5974
5975 /* a bad call without msg parameter will not trigger the auto-bind */
5976 sock = socket(AF_INET, SOCK_DGRAM, 0);
5977 ok(sock != INVALID_SOCKET, "socket() failed\n");
5978 ok(pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
5979 ok(getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have failed\n");
5980 err = WSAGetLastError();
5981 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
5982 closesocket(sock);
5983
5984 /* SOCK_STREAM sockets are not supported */
5985 bytesSent = 0;
5986 sock = socket(AF_INET, SOCK_STREAM, 0);
5987 ok(sock != INVALID_SOCKET, "socket() failed\n");
5988 SetLastError(0xdeadbeef);
5989 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
5990 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5991 err = WSAGetLastError();
5992 todo_wine
5993 ok(err == WSAEINVAL, "expected 10014, got %d instead\n", err);
5994 closesocket(sock);
5995 }
5996
5997 static void test_WSASendTo(void)
5998 {
5999 SOCKET s;
6000 struct sockaddr_in addr;
6001 char buf[12] = "hello world";
6002 WSABUF data_buf;
6003 DWORD bytesSent;
6004 int ret;
6005
6006 addr.sin_family = AF_INET;
6007 addr.sin_port = htons(139);
6008 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6009 data_buf.len = sizeof(buf);
6010 data_buf.buf = buf;
6011
6012 if( (s = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
6013 ok(0, "socket() failed error: %d\n", WSAGetLastError());
6014 return;
6015 }
6016
6017 WSASetLastError(12345);
6018 ret = WSASendTo(INVALID_SOCKET, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
6019 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
6020 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
6021
6022 WSASetLastError(12345);
6023 ret = WSASendTo(s, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
6024 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
6025 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
6026
6027 WSASetLastError(12345);
6028 if(WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL)) {
6029 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
6030 return;
6031 }
6032 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
6033 "a successful call to WSASendTo()\n");
6034 }
6035
6036 static DWORD WINAPI recv_thread(LPVOID arg)
6037 {
6038 SOCKET sock = *(SOCKET *)arg;
6039 char buffer[32];
6040 WSABUF wsa;
6041 WSAOVERLAPPED ov;
6042 DWORD flags = 0;
6043
6044 wsa.buf = buffer;
6045 wsa.len = sizeof(buffer);
6046 ov.hEvent = WSACreateEvent();
6047 WSARecv(sock, &wsa, 1, NULL, &flags, &ov, NULL);
6048
6049 WaitForSingleObject(ov.hEvent, 1000);
6050 WSACloseEvent(ov.hEvent);
6051 return 0;
6052 }
6053
6054 static void test_WSARecv(void)
6055 {
6056 SOCKET src, dest, server = INVALID_SOCKET;
6057 char buf[20];
6058 WSABUF bufs;
6059 WSAOVERLAPPED ov;
6060 DWORD bytesReturned, flags, id;
6061 struct linger ling;
6062 struct sockaddr_in addr;
6063 int iret, len;
6064 DWORD dwret;
6065 BOOL bret;
6066 HANDLE thread;
6067
6068 tcp_socketpair(&src, &dest);
6069 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
6070 {
6071 skip("failed to create sockets\n");
6072 goto end;
6073 }
6074
6075 memset(&ov, 0, sizeof(ov));
6076 flags = 0;
6077 bufs.len = 2;
6078 bufs.buf = buf;
6079
6080 /* Send 4 bytes and receive in two calls of 2 */
6081 SetLastError(0xdeadbeef);
6082 iret = send(src, "test", 4, 0);
6083 ok(iret == 4, "Expected 4, got %d\n", iret);
6084 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6085 SetLastError(0xdeadbeef);
6086 bytesReturned = 0xdeadbeef;
6087 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, NULL, NULL);
6088 ok(!iret, "Expected 0, got %d\n", iret);
6089 ok(bytesReturned, "Expected 2, got %d\n", bytesReturned);
6090 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6091 SetLastError(0xdeadbeef);
6092 bytesReturned = 0xdeadbeef;
6093 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, NULL, NULL);
6094 ok(!iret, "Expected 0, got %d\n", iret);
6095 ok(bytesReturned, "Expected 2, got %d\n", bytesReturned);
6096 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6097
6098 bufs.len = 4;
6099 SetLastError(0xdeadbeef);
6100 iret = send(src, "test", 4, 0);
6101 ok(iret == 4, "Expected 4, got %d\n", iret);
6102 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6103 SetLastError(0xdeadbeef);
6104 bytesReturned = 0xdeadbeef;
6105 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, NULL, NULL);
6106 ok(!iret, "Expected 0, got %d\n", iret);
6107 ok(bytesReturned, "Expected 4, got %d\n", bytesReturned);
6108 ok(GetLastError() == ERROR_SUCCESS, "Expected 0, got %d\n", GetLastError());
6109
6110 bufs.len = sizeof(buf);
6111
6112 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6113 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
6114 if (!ov.hEvent)
6115 goto end;
6116
6117 ling.l_onoff = 1;
6118 ling.l_linger = 0;
6119 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
6120 ok(!iret, "Failed to set linger %d\n", GetLastError());
6121
6122 iret = WSARecv(dest, &bufs, 1, NULL, &flags, &ov, NULL);
6123 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6124
6125 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
6126 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
6127
6128 closesocket(src);
6129 src = INVALID_SOCKET;
6130
6131 dwret = WaitForSingleObject(ov.hEvent, 1000);
6132 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %d + errno %d\n", dwret, GetLastError());
6133
6134 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
6135 todo_wine ok(!bret && (GetLastError() == ERROR_NETNAME_DELETED || broken(GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */),
6136 "Did not get disconnect event: %d, error %d\n", bret, GetLastError());
6137 ok(bytesReturned == 0, "Bytes received is %d\n", bytesReturned);
6138 closesocket(dest);
6139 dest = INVALID_SOCKET;
6140
6141 src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
6142 ok(src != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6143 if (src == INVALID_SOCKET) goto end;
6144
6145 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
6146 ok(server != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6147 if (server == INVALID_SOCKET) goto end;
6148
6149 memset(&addr, 0, sizeof(addr));
6150 addr.sin_family = AF_INET;
6151 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
6152 iret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
6153 if (iret) goto end;
6154
6155 len = sizeof(addr);
6156 iret = getsockname(server, (struct sockaddr *)&addr, &len);
6157 if (iret) goto end;
6158
6159 iret = listen(server, 1);
6160 if (iret) goto end;
6161
6162 iret = connect(src, (struct sockaddr *)&addr, sizeof(addr));
6163 if (iret) goto end;
6164
6165 len = sizeof(addr);
6166 dest = accept(server, (struct sockaddr *)&addr, &len);
6167 ok(dest != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
6168 if (dest == INVALID_SOCKET) goto end;
6169
6170 send(src, "test message", sizeof("test message"), 0);
6171 thread = CreateThread(NULL, 0, recv_thread, &dest, 0, &id);
6172 WaitForSingleObject(thread, 3000);
6173 CloseHandle(thread);
6174
6175 end:
6176 if (server != INVALID_SOCKET)
6177 closesocket(server);
6178 if (dest != INVALID_SOCKET)
6179 closesocket(dest);
6180 if (src != INVALID_SOCKET)
6181 closesocket(src);
6182 if (ov.hEvent)
6183 WSACloseEvent(ov.hEvent);
6184 }
6185
6186 static void test_GetAddrInfoW(void)
6187 {
6188 static const WCHAR port[] = {'8','0',0};
6189 static const WCHAR empty[] = {0};
6190 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
6191 static const WCHAR nxdomain[] =
6192 {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
6193 static const WCHAR zero[] = {'0',0};
6194 int i, ret;
6195 ADDRINFOW *result, *result2, *p, hint;
6196
6197 if (!pGetAddrInfoW || !pFreeAddrInfoW)
6198 {
6199 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
6200 return;
6201 }
6202 memset(&hint, 0, sizeof(ADDRINFOW));
6203
6204 result = (ADDRINFOW *)0xdeadbeef;
6205 WSASetLastError(0xdeadbeef);
6206 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
6207 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6208 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6209 ok(result == NULL, "got %p\n", result);
6210
6211 result = NULL;
6212 WSASetLastError(0xdeadbeef);
6213 ret = pGetAddrInfoW(empty, NULL, NULL, &result);
6214 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6215 ok(result != NULL, "GetAddrInfoW failed\n");
6216 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6217 pFreeAddrInfoW(result);
6218
6219 result = NULL;
6220 ret = pGetAddrInfoW(NULL, zero, NULL, &result);
6221 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6222 ok(result != NULL, "GetAddrInfoW failed\n");
6223
6224 result2 = NULL;
6225 ret = pGetAddrInfoW(NULL, empty, NULL, &result2);
6226 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6227 ok(result2 != NULL, "GetAddrInfoW failed\n");
6228 compare_addrinfow(result, result2);
6229 pFreeAddrInfoW(result);
6230 pFreeAddrInfoW(result2);
6231
6232 result = NULL;
6233 ret = pGetAddrInfoW(empty, zero, NULL, &result);
6234 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6235 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6236 ok(result != NULL, "GetAddrInfoW failed\n");
6237
6238 result2 = NULL;
6239 ret = pGetAddrInfoW(empty, empty, NULL, &result2);
6240 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6241 ok(result2 != NULL, "GetAddrInfoW failed\n");
6242 compare_addrinfow(result, result2);
6243 pFreeAddrInfoW(result);
6244 pFreeAddrInfoW(result2);
6245
6246 result = NULL;
6247 ret = pGetAddrInfoW(localhost, NULL, NULL, &result);
6248 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6249 pFreeAddrInfoW(result);
6250
6251 result = NULL;
6252 ret = pGetAddrInfoW(localhost, empty, NULL, &result);
6253 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6254 pFreeAddrInfoW(result);
6255
6256 result = NULL;
6257 ret = pGetAddrInfoW(localhost, zero, NULL, &result);
6258 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6259 pFreeAddrInfoW(result);
6260
6261 result = NULL;
6262 ret = pGetAddrInfoW(localhost, port, NULL, &result);
6263 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6264 pFreeAddrInfoW(result);
6265
6266 result = NULL;
6267 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
6268 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6269 pFreeAddrInfoW(result);
6270
6271 result = NULL;
6272 SetLastError(0xdeadbeef);
6273 ret = pGetAddrInfoW(localhost, port, &hint, &result);
6274 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6275 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6276 pFreeAddrInfoW(result);
6277
6278 result = (ADDRINFOW *)0xdeadbeef;
6279 WSASetLastError(0xdeadbeef);
6280 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
6281 if(ret == 0)
6282 {
6283 skip("nxdomain returned success. Broken ISP redirects?\n");
6284 return;
6285 }
6286 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6287 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6288 ok(result == NULL, "got %p\n", result);
6289
6290 result = (ADDRINFOW *)0xdeadbeef;
6291 WSASetLastError(0xdeadbeef);
6292 ret = pGetAddrInfoW(nxdomain, NULL, NULL, &result);
6293 if(ret == 0)
6294 {
6295 skip("nxdomain returned success. Broken ISP redirects?\n");
6296 return;
6297 }
6298 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6299 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6300 ok(result == NULL, "got %p\n", result);
6301
6302 for (i = 0;i < (sizeof(hinttests) / sizeof(hinttests[0]));i++)
6303 {
6304 hint.ai_family = hinttests[i].family;
6305 hint.ai_socktype = hinttests[i].socktype;
6306 hint.ai_protocol = hinttests[i].protocol;
6307
6308 result = NULL;
6309 SetLastError(0xdeadbeef);
6310 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
6311 if (!ret)
6312 {
6313 if (hinttests[i].error)
6314 ok(0, "test %d: GetAddrInfoW succeeded unexpectedly\n", i);
6315 else
6316 {
6317 p = result;
6318 do
6319 {
6320 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
6321 if (hinttests[i].family == AF_UNSPEC)
6322 ok(p->ai_family == AF_INET || p->ai_family == AF_INET6,
6323 "test %d: expected AF_INET or AF_INET6, got %d\n",
6324 i, p->ai_family);
6325 else
6326 ok(p->ai_family == hinttests[i].family,
6327 "test %d: expected family %d, got %d\n",
6328 i, hinttests[i].family, p->ai_family);
6329
6330 ok(p->ai_socktype == hinttests[i].socktype,
6331 "test %d: expected type %d, got %d\n",
6332 i, hinttests[i].socktype, p->ai_socktype);
6333 ok(p->ai_protocol == hinttests[i].protocol,
6334 "test %d: expected protocol %d, got %d\n",
6335 i, hinttests[i].protocol, p->ai_protocol);
6336 p = p->ai_next;
6337 }
6338 while (p);
6339 }
6340 pFreeAddrInfoW(result);
6341 }
6342 else
6343 {
6344 DWORD err = WSAGetLastError();
6345 if (hinttests[i].error)
6346 ok(hinttests[i].error == err, "test %d: GetAddrInfoW failed with error %d, expected %d\n",
6347 i, err, hinttests[i].error);
6348 else
6349 ok(0, "test %d: GetAddrInfoW failed with %d (err %d)\n", i, ret, err);
6350 }
6351 }
6352 }
6353
6354 static void test_getaddrinfo(void)
6355 {
6356 int i, ret;
6357 ADDRINFOA *result, *result2, *p, hint;
6358
6359 if (!pgetaddrinfo || !pfreeaddrinfo)
6360 {
6361 win_skip("getaddrinfo and/or freeaddrinfo not present\n");
6362 return;
6363 }
6364 memset(&hint, 0, sizeof(ADDRINFOA));
6365
6366 result = (ADDRINFOA *)0xdeadbeef;
6367 WSASetLastError(0xdeadbeef);
6368 ret = pgetaddrinfo(NULL, NULL, NULL, &result);
6369 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6370 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6371 ok(result == NULL, "got %p\n", result);
6372
6373 result = NULL;
6374 WSASetLastError(0xdeadbeef);
6375 ret = pgetaddrinfo("", NULL, NULL, &result);
6376 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6377 ok(result != NULL, "getaddrinfo failed\n");
6378 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6379 pfreeaddrinfo(result);
6380
6381 result = NULL;
6382 ret = pgetaddrinfo(NULL, "0", NULL, &result);
6383 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6384 ok(result != NULL, "getaddrinfo failed\n");
6385
6386 result2 = NULL;
6387 ret = pgetaddrinfo(NULL, "", NULL, &result2);
6388 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6389 ok(result2 != NULL, "getaddrinfo failed\n");
6390 compare_addrinfo(result, result2);
6391 pfreeaddrinfo(result);
6392 pfreeaddrinfo(result2);
6393
6394 result = NULL;
6395 WSASetLastError(0xdeadbeef);
6396 ret = pgetaddrinfo("", "0", NULL, &result);
6397 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6398 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6399 ok(result != NULL, "getaddrinfo failed\n");
6400
6401 result2 = NULL;
6402 ret = pgetaddrinfo("", "", NULL, &result2);
6403 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6404 ok(result2 != NULL, "getaddrinfo failed\n");
6405 compare_addrinfo(result, result2);
6406 pfreeaddrinfo(result);
6407 pfreeaddrinfo(result2);
6408
6409 result = NULL;
6410 ret = pgetaddrinfo("localhost", NULL, NULL, &result);
6411 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6412 pfreeaddrinfo(result);
6413
6414 result = NULL;
6415 ret = pgetaddrinfo("localhost", "", NULL, &result);
6416 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6417 pfreeaddrinfo(result);
6418
6419 result = NULL;
6420 ret = pgetaddrinfo("localhost", "0", NULL, &result);
6421 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6422 pfreeaddrinfo(result);
6423
6424 result = NULL;
6425 ret = pgetaddrinfo("localhost", "80", NULL, &result);
6426 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6427 pfreeaddrinfo(result);
6428
6429 result = NULL;
6430 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
6431 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6432 pfreeaddrinfo(result);
6433
6434 result = NULL;
6435 WSASetLastError(0xdeadbeef);
6436 ret = pgetaddrinfo("localhost", "80", &hint, &result);
6437 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
6438 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6439 pfreeaddrinfo(result);
6440
6441 result = (ADDRINFOA *)0xdeadbeef;
6442 WSASetLastError(0xdeadbeef);
6443 ret = pgetaddrinfo("nxdomain.codeweavers.com", NULL, NULL, &result);
6444 if(ret == 0)
6445 {
6446 skip("nxdomain returned success. Broken ISP redirects?\n");
6447 return;
6448 }
6449 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
6450 ok(WSAGetLastError() == WSAHOST_NOT_FOUND, "expected 11001, got %d\n", WSAGetLastError());
6451 ok(result == NULL, "got %p\n", result);
6452
6453 for (i = 0;i < (sizeof(hinttests) / sizeof(hinttests[0]));i++)
6454 {
6455 hint.ai_family = hinttests[i].family;
6456 hint.ai_socktype = hinttests[i].socktype;
6457 hint.ai_protocol = hinttests[i].protocol;
6458
6459 result = NULL;
6460 SetLastError(0xdeadbeef);
6461 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
6462 if(!ret)
6463 {
6464 if (hinttests[i].error)
6465 ok(0, "test %d: getaddrinfo succeeded unexpectedly\n", i);
6466 else
6467 {
6468 p = result;
6469 do
6470 {
6471 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
6472 if (hinttests[i].family == AF_UNSPEC)
6473 ok(p->ai_family == AF_INET || p->ai_family == AF_INET6,
6474 "test %d: expected AF_INET or AF_INET6, got %d\n",
6475 i, p->ai_family);
6476 else
6477 ok(p->ai_family == hinttests[i].family,
6478 "test %d: expected family %d, got %d\n",
6479 i, hinttests[i].family, p->ai_family);
6480
6481 ok(p->ai_socktype == hinttests[i].socktype,
6482 "test %d: expected type %d, got %d\n",
6483 i, hinttests[i].socktype, p->ai_socktype);
6484 ok(p->ai_protocol == hinttests[i].protocol,
6485 "test %d: expected protocol %d, got %d\n",
6486 i, hinttests[i].protocol, p->ai_protocol);
6487 p = p->ai_next;
6488 }
6489 while (p);
6490 }
6491 pfreeaddrinfo(result);
6492 }
6493 else
6494 {
6495 DWORD err = WSAGetLastError();
6496 if (hinttests[i].error)
6497 ok(hinttests[i].error == err, "test %d: getaddrinfo failed with error %d, expected %d\n",
6498 i, err, hinttests[i].error);
6499 else
6500 ok(0, "test %d: getaddrinfo failed with %d (err %d)\n", i, ret, err);
6501 }
6502 }
6503 }
6504
6505 static void test_ConnectEx(void)
6506 {
6507 SOCKET listener = INVALID_SOCKET;
6508 SOCKET acceptor = INVALID_SOCKET;
6509 SOCKET connector = INVALID_SOCKET;
6510 struct sockaddr_in address, conaddress;
6511 int addrlen;
6512 OVERLAPPED overlapped;
6513 LPFN_CONNECTEX pConnectEx;
6514 GUID connectExGuid = WSAID_CONNECTEX;
6515 DWORD bytesReturned;
6516 char buffer[1024];
6517 BOOL bret;
6518 DWORD dwret;
6519 int iret;
6520
6521 memset(&overlapped, 0, sizeof(overlapped));
6522
6523 listener = socket(AF_INET, SOCK_STREAM, 0);
6524 if (listener == INVALID_SOCKET) {
6525 skip("could not create listener socket, error %d\n", WSAGetLastError());
6526 goto end;
6527 }
6528
6529 connector = socket(AF_INET, SOCK_STREAM, 0);
6530 if (connector == INVALID_SOCKET) {
6531 skip("could not create connector socket, error %d\n", WSAGetLastError());
6532 goto end;
6533 }
6534
6535 memset(&address, 0, sizeof(address));
6536 address.sin_family = AF_INET;
6537 address.sin_addr.s_addr = inet_addr("127.0.0.1");
6538 iret = bind(listener, (struct sockaddr*)&address, sizeof(address));
6539 if (iret != 0) {
6540 skip("failed to bind, error %d\n", WSAGetLastError());
6541 goto end;
6542 }
6543
6544 addrlen = sizeof(address);
6545 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
6546 if (iret != 0) {
6547 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
6548 goto end;
6549 }
6550
6551 if (set_blocking(listener, TRUE)) {
6552 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
6553 goto end;
6554 }
6555
6556 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectExGuid, sizeof(connectExGuid),
6557 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
6558 if (iret) {
6559 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret, WSAGetLastError());
6560 goto end;
6561 }
6562
6563 bret = pConnectEx(INVALID_SOCKET, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
6564 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "ConnectEx on invalid socket "
6565 "returned %d + errno %d\n", bret, WSAGetLastError());
6566
6567 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
6568 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "ConnectEx on a unbound socket "
6569 "returned %d + errno %d\n", bret, WSAGetLastError());
6570 if (bret == TRUE || WSAGetLastError() != WSAEINVAL)
6571 {
6572 acceptor = accept(listener, NULL, NULL);
6573 if (acceptor != INVALID_SOCKET) {
6574 closesocket(acceptor);
6575 acceptor = INVALID_SOCKET;
6576 }
6577
6578 closesocket(connector);
6579 connector = socket(AF_INET, SOCK_STREAM, 0);
6580 if (connector == INVALID_SOCKET) {
6581 skip("could not create connector socket, error %d\n", WSAGetLastError());
6582 goto end;
6583 }
6584 }
6585
6586 /* ConnectEx needs a bound socket */
6587 memset(&conaddress, 0, sizeof(conaddress));
6588 conaddress.sin_family = AF_INET;
6589 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
6590 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
6591 if (iret != 0) {
6592 skip("failed to bind, error %d\n", WSAGetLastError());
6593 goto end;
6594 }
6595
6596 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, NULL);
6597 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "ConnectEx on a NULL overlapped "
6598 "returned %d + errno %d\n", bret, WSAGetLastError());
6599
6600 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6601 if (overlapped.hEvent == NULL) {
6602 skip("could not create event object, errno = %d\n", GetLastError());
6603 goto end;
6604 }
6605
6606 iret = listen(listener, 1);
6607 if (iret != 0) {
6608 skip("listening failed, errno = %d\n", WSAGetLastError());
6609 goto end;
6610 }
6611
6612 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
6613 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
6614 "returned %d + errno %d\n", bret, WSAGetLastError());
6615 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
6616 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
6617
6618 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
6619 ok(bret, "Connecting failed, error %d\n", GetLastError());
6620 ok(bytesReturned == 0, "Bytes sent is %d\n", bytesReturned);
6621
6622 closesocket(connector);
6623 connector = socket(AF_INET, SOCK_STREAM, 0);
6624 if (connector == INVALID_SOCKET) {
6625 skip("could not create connector socket, error %d\n", WSAGetLastError());
6626 goto end;
6627 }
6628 /* ConnectEx needs a bound socket */
6629 memset(&conaddress, 0, sizeof(conaddress));
6630 conaddress.sin_family = AF_INET;
6631 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
6632 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
6633 if (iret != 0) {
6634 skip("failed to bind, error %d\n", WSAGetLastError());
6635 goto end;
6636 }
6637
6638 acceptor = accept(listener, NULL, NULL);
6639 if (acceptor != INVALID_SOCKET) {
6640 closesocket(acceptor);
6641 }
6642
6643 buffer[0] = '1';
6644 buffer[1] = '2';
6645 buffer[2] = '3';
6646 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, buffer, 3, &bytesReturned, &overlapped);
6647 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
6648 "returned %d + errno %d\n", bret, WSAGetLastError());
6649 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
6650 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
6651
6652 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
6653 ok(bret, "Connecting failed, error %d\n", GetLastError());
6654 ok(bytesReturned == 3, "Bytes sent is %d\n", bytesReturned);
6655
6656 acceptor = accept(listener, NULL, NULL);
6657 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
6658
6659 bytesReturned = recv(acceptor, buffer, 3, 0);
6660 buffer[4] = 0;
6661 ok(bytesReturned == 3, "Didn't get all sent data, got only %d\n", bytesReturned);
6662 ok(buffer[0] == '1' && buffer[1] == '2' && buffer[2] == '3',
6663 "Failed to get the right data, expected '123', got '%s'\n", buffer);
6664
6665 closesocket(connector);
6666 connector = socket(AF_INET, SOCK_STREAM, 0);
6667 if (connector == INVALID_SOCKET) {
6668 skip("could not create connector socket, error %d\n", WSAGetLastError());
6669 goto end;
6670 }
6671 /* ConnectEx needs a bound socket */
6672 memset(&conaddress, 0, sizeof(conaddress));
6673 conaddress.sin_family = AF_INET;
6674 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
6675 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
6676 if (iret != 0) {
6677 skip("failed to bind, error %d\n", WSAGetLastError());
6678 goto end;
6679 }
6680
6681 if (acceptor != INVALID_SOCKET) {
6682 closesocket(acceptor);
6683 acceptor = INVALID_SOCKET;
6684 }
6685
6686 /* Connect with error */
6687 closesocket(listener);
6688 listener = INVALID_SOCKET;
6689
6690 address.sin_port = htons(1);
6691
6692 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
6693 ok(bret == FALSE && GetLastError(), "ConnectEx to bad destination failed: "
6694 "returned %d + errno %d\n", bret, GetLastError());
6695
6696 if (GetLastError() == ERROR_IO_PENDING)
6697 {
6698 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
6699 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
6700
6701 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
6702 ok(bret == FALSE && GetLastError() == ERROR_CONNECTION_REFUSED,
6703 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
6704 }
6705 else {
6706 ok(GetLastError() == WSAECONNREFUSED,
6707 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
6708 }
6709
6710 end:
6711 if (overlapped.hEvent)
6712 WSACloseEvent(overlapped.hEvent);
6713 if (listener != INVALID_SOCKET)
6714 closesocket(listener);
6715 if (acceptor != INVALID_SOCKET)
6716 closesocket(acceptor);
6717 if (connector != INVALID_SOCKET)
6718 closesocket(connector);
6719 }
6720
6721 static void test_AcceptEx(void)
6722 {
6723 SOCKET listener = INVALID_SOCKET;
6724 SOCKET acceptor = INVALID_SOCKET;
6725 SOCKET connector = INVALID_SOCKET;
6726 SOCKET connector2 = INVALID_SOCKET;
6727 struct sockaddr_in bindAddress, peerAddress, *readBindAddress, *readRemoteAddress;
6728 int socklen, optlen;
6729 GUID acceptExGuid = WSAID_ACCEPTEX, getAcceptExGuid = WSAID_GETACCEPTEXSOCKADDRS;
6730 LPFN_ACCEPTEX pAcceptEx = NULL;
6731 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs = NULL;
6732 fd_set fds_accept, fds_send;
6733 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
6734 int got, conn1, i;
6735 DWORD bytesReturned, connect_time;
6736 char buffer[1024], ipbuffer[32];
6737 OVERLAPPED overlapped;
6738 int iret, localSize = sizeof(struct sockaddr_in), remoteSize = localSize;
6739 BOOL bret;
6740 DWORD dwret;
6741
6742 memset(&overlapped, 0, sizeof(overlapped));
6743
6744 listener = socket(AF_INET, SOCK_STREAM, 0);
6745 if (listener == INVALID_SOCKET) {
6746 skip("could not create listener socket, error %d\n", WSAGetLastError());
6747 goto end;
6748 }
6749
6750 acceptor = socket(AF_INET, SOCK_STREAM, 0);
6751 if (acceptor == INVALID_SOCKET) {
6752 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6753 goto end;
6754 }
6755
6756 connector = socket(AF_INET, SOCK_STREAM, 0);
6757 if (connector == INVALID_SOCKET) {
6758 skip("could not create connector socket, error %d\n", WSAGetLastError());
6759 goto end;
6760 }
6761
6762 memset(&bindAddress, 0, sizeof(bindAddress));
6763 bindAddress.sin_family = AF_INET;
6764 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
6765 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
6766 if (iret != 0) {
6767 skip("failed to bind, error %d\n", WSAGetLastError());
6768 goto end;
6769 }
6770
6771 socklen = sizeof(bindAddress);
6772 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
6773 if (iret != 0) {
6774 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
6775 goto end;
6776 }
6777
6778 if (set_blocking(listener, FALSE)) {
6779 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
6780 goto end;
6781 }
6782
6783 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
6784 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
6785 if (iret) {
6786 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
6787 goto end;
6788 }
6789
6790 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &getAcceptExGuid, sizeof(getAcceptExGuid),
6791 &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &bytesReturned, NULL, NULL);
6792 if (iret) {
6793 skip("WSAIoctl failed to get GetAcceptExSockaddrs with ret %d + errno %d\n", iret, WSAGetLastError());
6794 goto end;
6795 }
6796
6797 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6798 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6799 &bytesReturned, &overlapped);
6800 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
6801 "returned %d + errno %d\n", bret, WSAGetLastError());
6802
6803 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6804 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6805 &bytesReturned, &overlapped);
6806 todo_wine
6807 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
6808 "returned %d + errno %d\n", bret, WSAGetLastError());
6809
6810 iret = listen(listener, 5);
6811 if (iret != 0) {
6812 skip("listening failed, errno = %d\n", WSAGetLastError());
6813 goto end;
6814 }
6815
6816 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6817 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6818 &bytesReturned, &overlapped);
6819 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid accepting socket "
6820 "returned %d + errno %d\n", bret, WSAGetLastError());
6821
6822 bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6823 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6824 &bytesReturned, &overlapped);
6825 ok(bret == FALSE &&
6826 (WSAGetLastError() == WSAEINVAL ||
6827 broken(WSAGetLastError() == WSAEFAULT)), /* NT4 */
6828 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
6829
6830 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
6831 &bytesReturned, &overlapped);
6832 ok(bret == FALSE && (WSAGetLastError() == ERROR_IO_PENDING || broken(WSAGetLastError() == WSAEINVAL)) /* NT4 */,
6833 "AcceptEx on too small local address size returned %d + errno %d\n",
6834 bret, WSAGetLastError());
6835 bret = CancelIo((HANDLE) listener);
6836 ok(bret, "Failed to cancel pending accept socket\n");
6837
6838 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 15,
6839 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
6840 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx on too small local address "
6841 "size returned %d + errno %d\n",
6842 bret, WSAGetLastError());
6843 bret = CancelIo((HANDLE) listener);
6844 ok(bret, "Failed to cancel pending accept socket\n");
6845
6846 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
6847 &bytesReturned, &overlapped);
6848 ok(bret == FALSE && (WSAGetLastError() == WSAEFAULT || broken(WSAGetLastError() == WSAEINVAL)) /* NT4 */,
6849 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
6850
6851 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
6852 sizeof(struct sockaddr_in) + 15, &bytesReturned, &overlapped);
6853 ok(bret == FALSE && (WSAGetLastError() == ERROR_IO_PENDING || broken(WSAGetLastError() == WSAEINVAL)) /* NT4 */,
6854 "AcceptEx on too small remote address size returned %d + errno %d\n", bret, WSAGetLastError());
6855 bret = CancelIo((HANDLE) listener);
6856 ok(bret, "Failed to cancel pending accept socket\n");
6857
6858 bret = pAcceptEx(listener, acceptor, buffer, 0,
6859 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6860 &bytesReturned, NULL);
6861 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
6862 "returned %d + errno %d\n", bret, WSAGetLastError());
6863
6864 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, 0, &bytesReturned, NULL);
6865 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
6866 "returned %d + errno %d\n", bret, WSAGetLastError());
6867
6868 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
6869 if (overlapped.hEvent == NULL) {
6870 skip("could not create event object, errno = %d\n", GetLastError());
6871 goto end;
6872 }
6873
6874 bret = pAcceptEx(listener, acceptor, buffer, 0,
6875 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6876 &bytesReturned, &overlapped);
6877 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
6878
6879 bret = pAcceptEx(listener, acceptor, buffer, 0,
6880 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6881 &bytesReturned, &overlapped);
6882 todo_wine ok((bret == FALSE && WSAGetLastError() == WSAEINVAL) || broken(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) /* NT4 */,
6883 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
6884 if (bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) {
6885 /* We need to cancel this call, otherwise things fail */
6886 bret = CancelIo((HANDLE) listener);
6887 ok(bret, "Failed to cancel failed test. Bailing...\n");
6888 if (!bret) return;
6889 WaitForSingleObject(overlapped.hEvent, 0);
6890
6891 bret = pAcceptEx(listener, acceptor, buffer, 0,
6892 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6893 &bytesReturned, &overlapped);
6894 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
6895 }
6896
6897 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
6898 todo_wine ok((iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL) || broken(!iret) /* NT4 */,
6899 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
6900 if (!iret || (iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)) {
6901 /* We need to cancel this call, otherwise things fail */
6902 closesocket(acceptor);
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
6909 bret = CancelIo((HANDLE) listener);
6910 ok(bret, "Failed to cancel failed test. Bailing...\n");
6911 if (!bret) return;
6912
6913 bret = pAcceptEx(listener, acceptor, buffer, 0,
6914 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6915 &bytesReturned, &overlapped);
6916 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
6917 }
6918
6919 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
6920 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6921
6922 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
6923 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
6924
6925 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
6926 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
6927 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
6928
6929 closesocket(connector);
6930 connector = INVALID_SOCKET;
6931 closesocket(acceptor);
6932
6933 /* Test short reads */
6934
6935 acceptor = socket(AF_INET, SOCK_STREAM, 0);
6936 if (acceptor == INVALID_SOCKET) {
6937 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6938 goto end;
6939 }
6940 connector = socket(AF_INET, SOCK_STREAM, 0);
6941 if (connector == INVALID_SOCKET) {
6942 skip("could not create connector socket, error %d\n", WSAGetLastError());
6943 goto end;
6944 }
6945 bret = pAcceptEx(listener, acceptor, buffer, 2,
6946 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6947 &bytesReturned, &overlapped);
6948 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
6949
6950 connect_time = 0xdeadbeef;
6951 optlen = sizeof(connect_time);
6952 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
6953 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
6954 ok(connect_time == ~0u, "unexpected connect time %u\n", connect_time);
6955
6956 /* AcceptEx() still won't complete until we send data */
6957 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
6958 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6959
6960 connect_time = 0xdeadbeef;
6961 optlen = sizeof(connect_time);
6962 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
6963 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
6964 ok(connect_time < 0xdeadbeef, "unexpected connect time %u\n", connect_time);
6965
6966 dwret = WaitForSingleObject(overlapped.hEvent, 0);
6967 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %d + errno %d\n", dwret, GetLastError());
6968
6969 iret = getsockname( connector, (struct sockaddr *)&peerAddress, &remoteSize);
6970 ok( !iret, "getsockname failed.\n");
6971
6972 /* AcceptEx() could complete any time now */
6973 iret = send(connector, buffer, 1, 0);
6974 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
6975
6976 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
6977 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
6978
6979 /* Check if the buffer from AcceptEx is decoded correctly */
6980 pGetAcceptExSockaddrs(buffer, 2, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6981 (struct sockaddr **)&readBindAddress, &localSize,
6982 (struct sockaddr **)&readRemoteAddress, &remoteSize);
6983 strcpy( ipbuffer, inet_ntoa(readBindAddress->sin_addr));
6984 ok( readBindAddress->sin_addr.s_addr == bindAddress.sin_addr.s_addr,
6985 "Local socket address is different %s != %s\n",
6986 ipbuffer, inet_ntoa(bindAddress.sin_addr));
6987 ok( readBindAddress->sin_port == bindAddress.sin_port,
6988 "Local socket port is different: %d != %d\n",
6989 readBindAddress->sin_port, bindAddress.sin_port);
6990 strcpy( ipbuffer, inet_ntoa(readRemoteAddress->sin_addr));
6991 ok( readRemoteAddress->sin_addr.s_addr == peerAddress.sin_addr.s_addr,
6992 "Remote socket address is different %s != %s\n",
6993 ipbuffer, inet_ntoa(peerAddress.sin_addr));
6994 ok( readRemoteAddress->sin_port == peerAddress.sin_port,
6995 "Remote socket port is different: %d != %d\n",
6996 readRemoteAddress->sin_port, peerAddress.sin_port);
6997
6998 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
6999 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7000 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7001
7002 closesocket(connector);
7003 connector = INVALID_SOCKET;
7004 closesocket(acceptor);
7005
7006 /* Test CF_DEFER & AcceptEx interaction */
7007
7008 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7009 if (acceptor == INVALID_SOCKET) {
7010 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7011 goto end;
7012 }
7013 connector = socket(AF_INET, SOCK_STREAM, 0);
7014 if (connector == INVALID_SOCKET) {
7015 skip("could not create connector socket, error %d\n", WSAGetLastError());
7016 goto end;
7017 }
7018 connector2 = socket(AF_INET, SOCK_STREAM, 0);
7019 if (connector == INVALID_SOCKET) {
7020 skip("could not create connector socket, error %d\n", WSAGetLastError());
7021 goto end;
7022 }
7023
7024 if (set_blocking(connector, FALSE)) {
7025 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7026 goto end;
7027 }
7028
7029 if (set_blocking(connector2, FALSE)) {
7030 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7031 goto end;
7032 }
7033
7034 /* Connect socket #1 */
7035 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7036 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7037
7038 FD_ZERO ( &fds_accept );
7039 FD_ZERO ( &fds_send );
7040
7041 FD_SET ( listener, &fds_accept );
7042 FD_SET ( connector, &fds_send );
7043
7044 buffer[0] = '0';
7045 got = 0;
7046 conn1 = 0;
7047
7048 for (i = 0; i < 4000; ++i)
7049 {
7050 fd_set fds_openaccept = fds_accept, fds_opensend = fds_send;
7051
7052 wsa_ok ( ( select ( 0, &fds_openaccept, &fds_opensend, NULL, &timeout ) ), SOCKET_ERROR !=,
7053 "acceptex test(%d): could not select on socket, errno %d\n" );
7054
7055 /* check for incoming requests */
7056 if ( FD_ISSET ( listener, &fds_openaccept ) ) {
7057 got++;
7058 if (got == 1) {
7059 SOCKET tmp = WSAAccept(listener, NULL, NULL, (LPCONDITIONPROC) AlwaysDeferConditionFunc, 0);
7060 ok(tmp == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
7061 bret = pAcceptEx(listener, acceptor, buffer, 0,
7062 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7063 &bytesReturned, &overlapped);
7064 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7065 }
7066 else if (got == 2) {
7067 /* this should be socket #2 */
7068 SOCKET tmp = accept(listener, NULL, NULL);
7069 ok(tmp != INVALID_SOCKET, "accept failed %d\n", WSAGetLastError());
7070 closesocket(tmp);
7071 }
7072 else {
7073 ok(FALSE, "Got more than 2 connections?\n");
7074 }
7075 }
7076 if ( conn1 && FD_ISSET ( connector2, &fds_opensend ) ) {
7077 /* Send data on second socket, and stop */
7078 send(connector2, "2", 1, 0);
7079 FD_CLR ( connector2, &fds_send );
7080
7081 break;
7082 }
7083 if ( FD_ISSET ( connector, &fds_opensend ) ) {
7084 /* Once #1 is connected, allow #2 to connect */
7085 conn1 = 1;
7086
7087 send(connector, "1", 1, 0);
7088 FD_CLR ( connector, &fds_send );
7089
7090 iret = connect(connector2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7091 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7092 FD_SET ( connector2, &fds_send );
7093 }
7094 }
7095
7096 ok (got == 2 || broken(got == 1) /* NT4 */,
7097 "Did not get both connections, got %d\n", got);
7098
7099 dwret = WaitForSingleObject(overlapped.hEvent, 0);
7100 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7101
7102 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7103 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7104 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7105
7106 set_blocking(acceptor, TRUE);
7107 iret = recv( acceptor, buffer, 2, 0);
7108 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
7109
7110 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
7111
7112 closesocket(connector);
7113 connector = INVALID_SOCKET;
7114 closesocket(acceptor);
7115
7116 /* clean up in case of failures */
7117 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
7118 closesocket(acceptor);
7119
7120 /* Disconnect during receive? */
7121
7122 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7123 if (acceptor == INVALID_SOCKET) {
7124 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7125 goto end;
7126 }
7127 connector = socket(AF_INET, SOCK_STREAM, 0);
7128 if (connector == INVALID_SOCKET) {
7129 skip("could not create connector socket, error %d\n", WSAGetLastError());
7130 goto end;
7131 }
7132 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7133 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7134 &bytesReturned, &overlapped);
7135 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7136
7137 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7138 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7139
7140 closesocket(connector);
7141 connector = INVALID_SOCKET;
7142
7143 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7144 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7145
7146 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7147 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
7148 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
7149
7150 closesocket(acceptor);
7151
7152 /* Test closing with pending requests */
7153
7154 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7155 if (acceptor == INVALID_SOCKET) {
7156 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7157 goto end;
7158 }
7159 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7160 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7161 &bytesReturned, &overlapped);
7162 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7163
7164 closesocket(acceptor);
7165
7166 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7167 todo_wine ok(dwret == WAIT_OBJECT_0 || broken(dwret == WAIT_TIMEOUT) /* NT4/2000 */,
7168 "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7169
7170 if (dwret != WAIT_TIMEOUT) {
7171 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7172 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
7173 }
7174 else {
7175 bret = CancelIo((HANDLE) listener);
7176 ok(bret, "Failed to cancel failed test. Bailing...\n");
7177 if (!bret) return;
7178 WaitForSingleObject(overlapped.hEvent, 0);
7179 }
7180
7181 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7182 if (acceptor == INVALID_SOCKET) {
7183 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7184 goto end;
7185 }
7186 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7187 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7188 &bytesReturned, &overlapped);
7189 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7190
7191 CancelIo((HANDLE) acceptor);
7192
7193 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7194 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %d + errno %d\n", dwret, GetLastError());
7195
7196 closesocket(acceptor);
7197
7198 acceptor = socket(AF_INET, SOCK_STREAM, 0);
7199 if (acceptor == INVALID_SOCKET) {
7200 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7201 goto end;
7202 }
7203 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
7204 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7205 &bytesReturned, &overlapped);
7206 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
7207
7208 closesocket(listener);
7209 listener = INVALID_SOCKET;
7210
7211 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
7212 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
7213
7214 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
7215 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
7216
7217 end:
7218 if (overlapped.hEvent)
7219 WSACloseEvent(overlapped.hEvent);
7220 if (listener != INVALID_SOCKET)
7221 closesocket(listener);
7222 if (acceptor != INVALID_SOCKET)
7223 closesocket(acceptor);
7224 if (connector != INVALID_SOCKET)
7225 closesocket(connector);
7226 if (connector2 != INVALID_SOCKET)
7227 closesocket(connector2);
7228 }
7229
7230 static void test_getpeername(void)
7231 {
7232 SOCKET sock;
7233 struct sockaddr_in sa, sa_out;
7234 SOCKADDR_STORAGE ss;
7235 int sa_len;
7236 const char buf[] = "hello world";
7237 int ret;
7238
7239 /* Test the parameter validation order. */
7240 ret = getpeername(INVALID_SOCKET, NULL, NULL);
7241 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
7242 ok(WSAGetLastError() == WSAENOTSOCK,
7243 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
7244
7245 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
7246 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
7247 if (sock == INVALID_SOCKET)
7248 {
7249 skip("Socket creation failed with %d\n", WSAGetLastError());
7250 return;
7251 }
7252
7253 ret = getpeername(sock, NULL, NULL);
7254 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
7255 ok(WSAGetLastError() == WSAENOTCONN ||
7256 broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
7257 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
7258
7259 memset(&sa, 0, sizeof(sa));
7260 sa.sin_family = AF_INET;
7261 sa.sin_port = htons(139);
7262 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
7263
7264 /* sendto does not change a socket's connection state. */
7265 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
7266 ok(ret != SOCKET_ERROR,
7267 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
7268
7269 ret = getpeername(sock, NULL, NULL);
7270 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
7271 ok(WSAGetLastError() == WSAENOTCONN ||
7272 broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
7273 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
7274
7275 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
7276 ok(ret == 0,
7277 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
7278
7279 ret = getpeername(sock, NULL, NULL);
7280 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
7281 ok(WSAGetLastError() == WSAEFAULT,
7282 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7283
7284 /* Test crashes on Wine. */
7285 if (0)
7286 {
7287 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
7288 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
7289 ok(WSAGetLastError() == WSAEFAULT,
7290 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7291 }
7292
7293 ret = getpeername(sock, (struct sockaddr*)&sa_out, NULL);
7294 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
7295 ok(WSAGetLastError() == WSAEFAULT,
7296 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7297
7298 sa_len = 0;
7299 ret = getpeername(sock, NULL, &sa_len);
7300 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
7301 ok(WSAGetLastError() == WSAEFAULT,
7302 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7303 ok(!sa_len, "got %d\n", sa_len);
7304
7305 sa_len = 0;
7306 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
7307 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
7308 ok(WSAGetLastError() == WSAEFAULT,
7309 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
7310 ok(!sa_len, "got %d\n", sa_len);
7311
7312 sa_len = sizeof(ss);
7313 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
7314 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
7315 ok(!memcmp(&sa, &ss, sizeof(sa)),
7316 "Expected the returned structure to be identical to the connect structure\n");
7317 ok(sa_len == sizeof(sa), "got %d\n", sa_len);
7318
7319 closesocket(sock);
7320 }
7321
7322 static void test_sioRoutingInterfaceQuery(void)
7323 {
7324 int ret;
7325 SOCKET sock;
7326 SOCKADDR_IN sin = { 0 }, sout = { 0 };
7327 DWORD bytesReturned;
7328
7329 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
7330 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
7331 if (sock == INVALID_SOCKET)
7332 {
7333 skip("Socket creation failed with %d\n", WSAGetLastError());
7334 return;
7335 }
7336 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, NULL, 0, NULL, 0, NULL,
7337 NULL, NULL);
7338 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
7339 "expected WSAEFAULT, got %d\n", WSAGetLastError());
7340 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
7341 NULL, 0, NULL, NULL, NULL);
7342 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
7343 "expected WSAEFAULT, got %d\n", WSAGetLastError());
7344 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
7345 NULL, 0, &bytesReturned, NULL, NULL);
7346 ok(ret == SOCKET_ERROR &&
7347 (WSAGetLastError() == WSAEFAULT /* Win98 */ ||
7348 WSAGetLastError() == WSAEINVAL /* NT4 */||
7349 WSAGetLastError() == WSAEAFNOSUPPORT),
7350 "expected WSAEFAULT or WSAEINVAL or WSAEAFNOSUPPORT, got %d\n",
7351 WSAGetLastError());
7352 sin.sin_family = AF_INET;
7353 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
7354 NULL, 0, &bytesReturned, NULL, NULL);
7355 ok(ret == SOCKET_ERROR &&
7356 (WSAGetLastError() == WSAEFAULT /* Win98 */ ||
7357 WSAGetLastError() == WSAEINVAL),
7358 "expected WSAEFAULT or WSAEINVAL, got %d\n", WSAGetLastError());
7359 sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
7360 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
7361 NULL, 0, &bytesReturned, NULL, NULL);
7362 ok(ret == SOCKET_ERROR &&
7363 (WSAGetLastError() == WSAEINVAL /* NT4 */ ||
7364 WSAGetLastError() == WSAEFAULT),
7365 "expected WSAEINVAL or WSAEFAULT, got %d\n", WSAGetLastError());
7366 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
7367 &sout, sizeof(sout), &bytesReturned, NULL, NULL);
7368 ok(!ret || broken(WSAGetLastError() == WSAEINVAL /* NT4 */),
7369 "WSAIoctl failed: %d\n", WSAGetLastError());
7370 if (!ret)
7371 {
7372 ok(sout.sin_family == AF_INET, "expected AF_INET, got %d\n",
7373 sout.sin_family);
7374 /* We expect the source address to be INADDR_LOOPBACK as well, but
7375 * there's no guarantee that a route to the loopback address exists,
7376 * so rather than introduce spurious test failures we do not test the
7377 * source address.
7378 */
7379 }
7380 closesocket(sock);
7381 }
7382
7383 static void test_sioAddressListChange(void)
7384 {
7385 struct sockaddr_in bindAddress;
7386 struct in_addr net_address;
7387 WSAOVERLAPPED overlapped;
7388 struct hostent *h;
7389 DWORD num_bytes;
7390 SOCKET sock;
7391 int acount;
7392 int ret;
7393
7394 if (!winetest_interactive)
7395 {
7396 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
7397 return;
7398 }
7399
7400 /* Use gethostbyname to find the list of local network interfaces */
7401 h = gethostbyname("");
7402 if (!h)
7403 {
7404 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, gethostbyname failed with %u\n",
7405 WSAGetLastError());
7406 return;
7407 }
7408 for (acount = 0; h->h_addr_list[acount]; acount++);
7409 if (acount == 0)
7410 {
7411 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
7412 return;
7413 }
7414 net_address.s_addr = *(ULONG *) h->h_addr_list[0];
7415
7416 /* Bind an overlapped socket to the first found network interface */
7417 sock = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
7418 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
7419 if (sock == INVALID_SOCKET)
7420 {
7421 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, socket creation failed with %u\n",
7422 WSAGetLastError());
7423 return;
7424 }
7425 memset(&bindAddress, 0, sizeof(bindAddress));
7426 bindAddress.sin_family = AF_INET;
7427 bindAddress.sin_addr.s_addr = net_address.s_addr;
7428 ret = bind(sock, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7429 if (ret != 0)
7430 {
7431 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, failed to bind, error %u\n", WSAGetLastError());
7432 goto end;
7433 }
7434
7435 /* Wait for address changes, request that the user connects/disconnects an interface */
7436 memset(&overlapped, 0, sizeof(overlapped));
7437 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
7438 ret = WSAIoctl(sock, SIO_ADDRESS_LIST_CHANGE, NULL, 0, NULL, 0, &num_bytes, &overlapped, NULL);
7439 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
7440 ok(WSAGetLastError() == WSA_IO_PENDING, "Expected pending last error %d\n", WSAGetLastError());
7441 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
7442 " change the ipv4 address of any of the local network interfaces (10 second timeout).\n");
7443 ret = WaitForSingleObject(overlapped.hEvent, 10000);
7444 ok(ret == WAIT_OBJECT_0, "failed to get overlapped event %u\n", ret);
7445
7446 end:
7447 closesocket(sock);
7448 }
7449
7450 static void test_synchronous_WSAIoctl(void)
7451 {
7452 HANDLE previous_port, io_port;
7453 WSAOVERLAPPED overlapped, *olp;
7454 SOCKET socket;
7455 ULONG on;
7456 ULONG_PTR key;
7457 DWORD num_bytes;
7458 BOOL ret;
7459 int res;
7460
7461 previous_port = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );
7462 ok( previous_port != NULL, "failed to create completion port %u\n", GetLastError() );
7463
7464 socket = WSASocketW( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED );
7465 ok( socket != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError() );
7466
7467 io_port = CreateIoCompletionPort( (HANDLE)socket, previous_port, 0, 0 );
7468 ok( io_port != NULL, "failed to create completion port %u\n", GetLastError() );
7469
7470 on = 1;
7471 memset( &overlapped, 0, sizeof(overlapped) );
7472 res = WSAIoctl( socket, FIONBIO, &on, sizeof(on), NULL, 0, &num_bytes, &overlapped, NULL );
7473 ok( !res, "WSAIoctl failed %d\n", WSAGetLastError() );
7474
7475 ret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 10000 );
7476 ok( ret, "failed to get completion status %u\n", GetLastError() );
7477
7478 CloseHandle( io_port );
7479 closesocket( socket );
7480 CloseHandle( previous_port );
7481 }
7482
7483 #define WM_ASYNCCOMPLETE (WM_USER + 100)
7484 static HWND create_async_message_window(void)
7485 {
7486 static const char class_name[] = "ws2_32 async message window class";
7487
7488 WNDCLASSEXA wndclass;
7489 HWND hWnd;
7490
7491 wndclass.cbSize = sizeof(wndclass);
7492 wndclass.style = CS_HREDRAW | CS_VREDRAW;
7493 wndclass.lpfnWndProc = DefWindowProcA;
7494 wndclass.cbClsExtra = 0;
7495 wndclass.cbWndExtra = 0;
7496 wndclass.hInstance = GetModuleHandleA(NULL);
7497 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
7498 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
7499 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
7500 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
7501 wndclass.lpszClassName = class_name;
7502 wndclass.lpszMenuName = NULL;
7503
7504 RegisterClassExA(&wndclass);
7505
7506 hWnd = CreateWindowA(class_name, "ws2_32 async message window", WS_OVERLAPPEDWINDOW,
7507 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
7508 if (!hWnd)
7509 {
7510 ok(0, "failed to create window: %u\n", GetLastError());
7511 return NULL;
7512 }
7513
7514 return hWnd;
7515 }
7516
7517 static void test_WSAAsyncGetServByPort(void)
7518 {
7519 HWND hwnd = create_async_message_window();
7520 HANDLE ret;
7521 char buffer[MAXGETHOSTSTRUCT];
7522
7523 if (!hwnd)
7524 return;
7525
7526 /* FIXME: The asynchronous window messages should be tested. */
7527
7528 /* Parameters are not checked when initiating the asynchronous operation. */
7529 ret = WSAAsyncGetServByPort(NULL, 0, 0, NULL, NULL, 0);
7530 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
7531
7532 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, 0, NULL, NULL, 0);
7533 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
7534
7535 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, NULL, 0);
7536 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
7537
7538 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, buffer, MAXGETHOSTSTRUCT);
7539 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
7540
7541 DestroyWindow(hwnd);
7542 }
7543
7544 static void test_WSAAsyncGetServByName(void)
7545 {
7546 HWND hwnd = create_async_message_window();
7547 HANDLE ret;
7548 char buffer[MAXGETHOSTSTRUCT];
7549
7550 if (!hwnd)
7551 return;
7552
7553 /* FIXME: The asynchronous window messages should be tested. */
7554
7555 /* Parameters are not checked when initiating the asynchronous operation. */
7556 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", NULL, NULL, 0);
7557 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
7558
7559 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", "", buffer, MAXGETHOSTSTRUCT);
7560 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
7561
7562 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", NULL, NULL, 0);
7563 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
7564
7565 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", "tcp", buffer, MAXGETHOSTSTRUCT);
7566 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
7567
7568 DestroyWindow(hwnd);
7569 }
7570
7571 /*
7572 * Provide consistent initialization for the AcceptEx IOCP tests.
7573 */
7574 static SOCKET setup_iocp_src(struct sockaddr_in *bindAddress)
7575 {
7576 SOCKET src, ret = INVALID_SOCKET;
7577 int iret, socklen;
7578
7579 src = socket(AF_INET, SOCK_STREAM, 0);
7580 if (src == INVALID_SOCKET)
7581 {
7582 skip("could not create listener socket, error %d\n", WSAGetLastError());
7583 goto end;
7584 }
7585
7586 memset(bindAddress, 0, sizeof(*bindAddress));
7587 bindAddress->sin_family = AF_INET;
7588 bindAddress->sin_addr.s_addr = inet_addr("127.0.0.1");
7589 iret = bind(src, (struct sockaddr*)bindAddress, sizeof(*bindAddress));
7590 if (iret != 0)
7591 {
7592 skip("failed to bind, error %d\n", WSAGetLastError());
7593 goto end;
7594 }
7595
7596 socklen = sizeof(*bindAddress);
7597 iret = getsockname(src, (struct sockaddr*)bindAddress, &socklen);
7598 if (iret != 0) {
7599 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
7600 goto end;
7601 }
7602
7603 if (set_blocking(src, FALSE))
7604 {
7605 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7606 goto end;
7607 }
7608
7609 iret = listen(src, 5);
7610 if (iret != 0)
7611 {
7612 skip("listening failed, errno = %d\n", WSAGetLastError());
7613 goto end;
7614 }
7615
7616 ret = src;
7617 end:
7618 if (src != ret && ret == INVALID_SOCKET)
7619 closesocket(src);
7620 return ret;
7621 }
7622
7623 static void test_completion_port(void)
7624 {
7625 HANDLE previous_port, io_port;
7626 WSAOVERLAPPED ov, *olp;
7627 SOCKET src, dest, dup, connector = INVALID_SOCKET;
7628 WSAPROTOCOL_INFOA info;
7629 char buf[1024];
7630 WSABUF bufs;
7631 DWORD num_bytes, flags;
7632 struct linger ling;
7633 int iret;
7634 BOOL bret;
7635 ULONG_PTR key;
7636 struct sockaddr_in bindAddress;
7637 GUID acceptExGuid = WSAID_ACCEPTEX;
7638 LPFN_ACCEPTEX pAcceptEx = NULL;
7639
7640 memset(buf, 0, sizeof(buf));
7641 previous_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
7642 ok( previous_port != NULL, "Failed to create completion port %u\n", GetLastError());
7643
7644 memset(&ov, 0, sizeof(ov));
7645
7646 tcp_socketpair(&src, &dest);
7647 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
7648 {
7649 skip("failed to create sockets\n");
7650 goto end;
7651 }
7652
7653 bufs.len = sizeof(buf);
7654 bufs.buf = buf;
7655 flags = 0;
7656
7657 ling.l_onoff = 1;
7658 ling.l_linger = 0;
7659 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
7660 ok(!iret, "Failed to set linger %d\n", GetLastError());
7661
7662 io_port = CreateIoCompletionPort( (HANDLE)dest, previous_port, 125, 0 );
7663 ok(io_port != NULL, "Failed to create completion port %u\n", GetLastError());
7664
7665 SetLastError(0xdeadbeef);
7666
7667 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
7668 ok(iret == SOCKET_ERROR, "WSARecv returned %d\n", iret);
7669 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
7670
7671 Sleep(100);
7672
7673 closesocket(src);
7674 src = INVALID_SOCKET;
7675
7676 SetLastError(0xdeadbeef);
7677 key = 0xdeadbeef;
7678 num_bytes = 0xdeadbeef;
7679 olp = (WSAOVERLAPPED *)0xdeadbeef;
7680
7681 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
7682 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret);
7683 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED, "Last error was %d\n", GetLastError());
7684 ok(key == 125, "Key is %lu\n", key);
7685 ok(num_bytes == 0, "Number of bytes received is %u\n", num_bytes);
7686 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
7687
7688 SetLastError(0xdeadbeef);
7689 key = 0xdeadbeef;
7690 num_bytes = 0xdeadbeef;
7691 olp = (WSAOVERLAPPED *)0xdeadbeef;
7692
7693 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
7694 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret );
7695 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7696 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7697 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7698 ok(!olp, "Overlapped structure is at %p\n", olp);
7699
7700 if (dest != INVALID_SOCKET)
7701 closesocket(dest);
7702
7703 memset(&ov, 0, sizeof(ov));
7704
7705 tcp_socketpair(&src, &dest);
7706 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
7707 {
7708 skip("failed to create sockets\n");
7709 goto end;
7710 }
7711
7712 bufs.len = sizeof(buf);
7713 bufs.buf = buf;
7714 flags = 0;
7715
7716 ling.l_onoff = 1;
7717 ling.l_linger = 0;
7718 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
7719 ok(!iret, "Failed to set linger %d\n", GetLastError());
7720
7721 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
7722 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
7723
7724 set_blocking(dest, FALSE);
7725
7726 closesocket(src);
7727 src = INVALID_SOCKET;
7728
7729 Sleep(100);
7730
7731 num_bytes = 0xdeadbeef;
7732 SetLastError(0xdeadbeef);
7733
7734 iret = WSASend(dest, &bufs, 1, &num_bytes, 0, &ov, NULL);
7735 ok(iret == SOCKET_ERROR, "WSASend failed - %d\n", iret);
7736 ok(GetLastError() == WSAECONNRESET, "Last error was %d\n", GetLastError());
7737 ok(num_bytes == 0xdeadbeef, "Managed to send %d\n", num_bytes);
7738
7739 SetLastError(0xdeadbeef);
7740 key = 0xdeadbeef;
7741 num_bytes = 0xdeadbeef;
7742 olp = (WSAOVERLAPPED *)0xdeadbeef;
7743
7744 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
7745 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
7746 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7747 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7748 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7749 ok(!olp, "Overlapped structure is at %p\n", olp);
7750
7751 if (dest != INVALID_SOCKET)
7752 closesocket(dest);
7753
7754 dest = socket(AF_INET, SOCK_STREAM, 0);
7755 if (dest == INVALID_SOCKET)
7756 {
7757 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7758 goto end;
7759 }
7760
7761 iret = WSAIoctl(dest, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
7762 &pAcceptEx, sizeof(pAcceptEx), &num_bytes, NULL, NULL);
7763 if (iret)
7764 {
7765 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
7766 goto end;
7767 }
7768
7769 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
7770
7771 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
7772 goto end;
7773
7774 SetLastError(0xdeadbeef);
7775
7776 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
7777 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7778 &num_bytes, &ov);
7779 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
7780 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
7781
7782 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
7783 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
7784
7785 closesocket(src);
7786 src = INVALID_SOCKET;
7787
7788 SetLastError(0xdeadbeef);
7789 key = 0xdeadbeef;
7790 num_bytes = 0xdeadbeef;
7791 olp = (WSAOVERLAPPED *)0xdeadbeef;
7792
7793 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
7794 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7795 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
7796 ok(key == 125, "Key is %lu\n", key);
7797 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
7798 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
7799 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
7800
7801 SetLastError(0xdeadbeef);
7802 key = 0xdeadbeef;
7803 num_bytes = 0xdeadbeef;
7804 olp = (WSAOVERLAPPED *)0xdeadbeef;
7805 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
7806 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7807 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7808 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7809 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7810 ok(!olp, "Overlapped structure is at %p\n", olp);
7811
7812 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
7813
7814 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
7815 goto end;
7816
7817 SetLastError(0xdeadbeef);
7818
7819 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
7820 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
7821
7822 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
7823 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7824 &num_bytes, &ov);
7825 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
7826 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
7827
7828 closesocket(src);
7829 src = INVALID_SOCKET;
7830
7831 SetLastError(0xdeadbeef);
7832 key = 0xdeadbeef;
7833 num_bytes = 0xdeadbeef;
7834 olp = (WSAOVERLAPPED *)0xdeadbeef;
7835
7836 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
7837 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7838 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
7839 ok(key == 125, "Key is %lu\n", key);
7840 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
7841 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
7842 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
7843
7844 SetLastError(0xdeadbeef);
7845 key = 0xdeadbeef;
7846 num_bytes = 0xdeadbeef;
7847 olp = (WSAOVERLAPPED *)0xdeadbeef;
7848 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
7849 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7850 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7851 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7852 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7853 ok(!olp, "Overlapped structure is at %p\n", olp);
7854
7855 /* Test IOCP with duplicated handle */
7856
7857 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
7858 goto end;
7859
7860 SetLastError(0xdeadbeef);
7861
7862 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
7863 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
7864
7865 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
7866 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
7867 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
7868
7869 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
7870 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7871 &num_bytes, &ov);
7872 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
7873 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
7874
7875 SetLastError(0xdeadbeef);
7876 key = 0xdeadbeef;
7877 num_bytes = 0xdeadbeef;
7878 olp = (WSAOVERLAPPED *)0xdeadbeef;
7879 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
7880 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7881 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7882 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7883 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7884 ok(!olp, "Overlapped structure is at %p\n", olp);
7885
7886 closesocket(src);
7887 src = INVALID_SOCKET;
7888 closesocket(dup);
7889 dup = INVALID_SOCKET;
7890
7891 SetLastError(0xdeadbeef);
7892 key = 0xdeadbeef;
7893 num_bytes = 0xdeadbeef;
7894 olp = (WSAOVERLAPPED *)0xdeadbeef;
7895 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
7896 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7897 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
7898 ok(key == 125, "Key is %lu\n", key);
7899 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
7900 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
7901 ok(olp && olp->Internal == (ULONG)STATUS_CANCELLED, "Internal status is %lx\n", olp ? olp->Internal : 0);
7902
7903 SetLastError(0xdeadbeef);
7904 key = 0xdeadbeef;
7905 num_bytes = 0xdeadbeef;
7906 olp = (WSAOVERLAPPED *)0xdeadbeef;
7907 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
7908 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7909 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7910 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7911 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7912 ok(!olp, "Overlapped structure is at %p\n", olp);
7913
7914 /* Test IOCP with duplicated handle (closing duplicated handle) */
7915
7916 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
7917 goto end;
7918
7919 SetLastError(0xdeadbeef);
7920
7921 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
7922 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
7923
7924 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
7925 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
7926 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
7927
7928 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
7929 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7930 &num_bytes, &ov);
7931 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
7932 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
7933
7934 closesocket(dup);
7935 dup = INVALID_SOCKET;
7936
7937 SetLastError(0xdeadbeef);
7938 key = 0xdeadbeef;
7939 num_bytes = 0xdeadbeef;
7940 olp = (WSAOVERLAPPED *)0xdeadbeef;
7941 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
7942 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7943 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7944 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7945 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7946 ok(!olp, "Overlapped structure is at %p\n", olp);
7947
7948 SetLastError(0xdeadbeef);
7949 key = 0xdeadbeef;
7950 num_bytes = 0xdeadbeef;
7951 olp = (WSAOVERLAPPED *)0xdeadbeef;
7952 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
7953 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7954 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7955 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7956 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7957 ok(!olp, "Overlapped structure is at %p\n", olp);
7958
7959 closesocket(src);
7960 src = INVALID_SOCKET;
7961
7962 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
7963 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7964 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
7965 ok(key == 125, "Key is %lu\n", key);
7966 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
7967 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
7968 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
7969
7970 SetLastError(0xdeadbeef);
7971 key = 0xdeadbeef;
7972 num_bytes = 0xdeadbeef;
7973 olp = (WSAOVERLAPPED *)0xdeadbeef;
7974 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
7975 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7976 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7977 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7978 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7979 ok(!olp, "Overlapped structure is at %p\n", olp);
7980
7981 /* Test IOCP with duplicated handle (closing original handle) */
7982
7983 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
7984 goto end;
7985
7986 SetLastError(0xdeadbeef);
7987
7988 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
7989 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
7990
7991 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
7992 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
7993 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
7994
7995 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
7996 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7997 &num_bytes, &ov);
7998 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
7999 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8000
8001 closesocket(src);
8002 src = INVALID_SOCKET;
8003
8004 SetLastError(0xdeadbeef);
8005 key = 0xdeadbeef;
8006 num_bytes = 0xdeadbeef;
8007 olp = (WSAOVERLAPPED *)0xdeadbeef;
8008 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8009 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8010 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8011 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8012 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8013 ok(!olp, "Overlapped structure is at %p\n", olp);
8014
8015 closesocket(dup);
8016 dup = INVALID_SOCKET;
8017
8018 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8019 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8020 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
8021 ok(key == 125, "Key is %lu\n", key);
8022 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8023 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8024 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
8025
8026 SetLastError(0xdeadbeef);
8027 key = 0xdeadbeef;
8028 num_bytes = 0xdeadbeef;
8029 olp = (WSAOVERLAPPED *)0xdeadbeef;
8030 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8031 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8032 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8033 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8034 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8035 ok(!olp, "Overlapped structure is at %p\n", olp);
8036
8037 /* Test IOCP without AcceptEx */
8038
8039 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8040 goto end;
8041
8042 SetLastError(0xdeadbeef);
8043
8044 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8045 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8046
8047 closesocket(src);
8048 src = INVALID_SOCKET;
8049
8050 SetLastError(0xdeadbeef);
8051 key = 0xdeadbeef;
8052 num_bytes = 0xdeadbeef;
8053 olp = (WSAOVERLAPPED *)0xdeadbeef;
8054 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8055 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8056 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8057 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8058 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8059 ok(!olp, "Overlapped structure is at %p\n", olp);
8060
8061 /* */
8062
8063 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8064 goto end;
8065
8066 connector = socket(AF_INET, SOCK_STREAM, 0);
8067 if (connector == INVALID_SOCKET) {
8068 skip("could not create connector socket, error %d\n", WSAGetLastError());
8069 goto end;
8070 }
8071
8072 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8073 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8074
8075 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
8076 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8077
8078 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8079 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8080 &num_bytes, &ov);
8081 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8082 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8083
8084 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8085 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8086
8087 closesocket(connector);
8088 connector = INVALID_SOCKET;
8089
8090 SetLastError(0xdeadbeef);
8091 key = 0xdeadbeef;
8092 num_bytes = 0xdeadbeef;
8093 olp = (WSAOVERLAPPED *)0xdeadbeef;
8094
8095 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8096 ok(bret == TRUE, "failed to get completion status %u\n", bret);
8097 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8098 ok(key == 125, "Key is %lu\n", key);
8099 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8100 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8101 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
8102
8103 SetLastError(0xdeadbeef);
8104 key = 0xdeadbeef;
8105 num_bytes = 0xdeadbeef;
8106 olp = (WSAOVERLAPPED *)0xdeadbeef;
8107 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8108 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8109 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8110 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8111 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8112 ok(!olp, "Overlapped structure is at %p\n", olp);
8113
8114 if (dest != INVALID_SOCKET)
8115 closesocket(dest);
8116 if (src != INVALID_SOCKET)
8117 closesocket(dest);
8118
8119 /* */
8120
8121 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8122 goto end;
8123
8124 dest = socket(AF_INET, SOCK_STREAM, 0);
8125 if (dest == INVALID_SOCKET)
8126 {
8127 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8128 goto end;
8129 }
8130
8131 connector = socket(AF_INET, SOCK_STREAM, 0);
8132 if (connector == INVALID_SOCKET) {
8133 skip("could not create connector socket, error %d\n", WSAGetLastError());
8134 goto end;
8135 }
8136
8137 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8138 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8139
8140 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
8141 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8142
8143 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8144 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8145 &num_bytes, &ov);
8146 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8147 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8148
8149 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8150 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8151
8152 iret = send(connector, buf, 1, 0);
8153 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
8154
8155 Sleep(100);
8156
8157 closesocket(dest);
8158 dest = INVALID_SOCKET;
8159
8160 SetLastError(0xdeadbeef);
8161 key = 0xdeadbeef;
8162 num_bytes = 0xdeadbeef;
8163 olp = (WSAOVERLAPPED *)0xdeadbeef;
8164
8165 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8166 ok(bret == TRUE, "failed to get completion status %u\n", bret);
8167 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
8168 ok(key == 125, "Key is %lu\n", key);
8169 ok(num_bytes == 1, "Number of bytes transferred is %u\n", num_bytes);
8170 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8171 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
8172
8173 SetLastError(0xdeadbeef);
8174 key = 0xdeadbeef;
8175 num_bytes = 0xdeadbeef;
8176 olp = (WSAOVERLAPPED *)0xdeadbeef;
8177 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8178 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8179 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8180 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8181 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8182 ok(!olp, "Overlapped structure is at %p\n", olp);
8183
8184 if (src != INVALID_SOCKET)
8185 closesocket(src);
8186 if (connector != INVALID_SOCKET)
8187 closesocket(connector);
8188
8189 /* */
8190
8191 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
8192 goto end;
8193
8194 dest = socket(AF_INET, SOCK_STREAM, 0);
8195 if (dest == INVALID_SOCKET)
8196 {
8197 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8198 goto end;
8199 }
8200
8201 connector = socket(AF_INET, SOCK_STREAM, 0);
8202 if (connector == INVALID_SOCKET) {
8203 skip("could not create connector socket, error %d\n", WSAGetLastError());
8204 goto end;
8205 }
8206
8207 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
8208 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8209
8210 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
8211 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
8212
8213 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
8214 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
8215 &num_bytes, &ov);
8216 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
8217 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
8218
8219 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
8220 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
8221
8222 closesocket(dest);
8223 dest = INVALID_SOCKET;
8224
8225 SetLastError(0xdeadbeef);
8226 key = 0xdeadbeef;
8227 num_bytes = 0xdeadbeef;
8228 olp = (WSAOVERLAPPED *)0xdeadbeef;
8229
8230 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
8231 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8232 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED ||
8233 GetLastError() == ERROR_OPERATION_ABORTED ||
8234 GetLastError() == ERROR_CONNECTION_ABORTED ||
8235 GetLastError() == ERROR_PIPE_NOT_CONNECTED /* win 2000 */,
8236 "Last error was %d\n", GetLastError());
8237 ok(key == 125, "Key is %lu\n", key);
8238 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
8239 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
8240 todo_wine ok(olp && (olp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT ||
8241 olp->Internal == (ULONG)STATUS_CANCELLED ||
8242 olp->Internal == (ULONG)STATUS_CONNECTION_ABORTED ||
8243 olp->Internal == (ULONG)STATUS_PIPE_DISCONNECTED /* win 2000 */),
8244 "Internal status is %lx\n", olp ? olp->Internal : 0);
8245
8246 SetLastError(0xdeadbeef);
8247 key = 0xdeadbeef;
8248 num_bytes = 0xdeadbeef;
8249 olp = (WSAOVERLAPPED *)0xdeadbeef;
8250 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
8251 ok(bret == FALSE, "failed to get completion status %u\n", bret);
8252 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
8253 ok(key == 0xdeadbeef, "Key is %lu\n", key);
8254 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
8255 ok(!olp, "Overlapped structure is at %p\n", olp);
8256
8257
8258 end:
8259 if (dest != INVALID_SOCKET)
8260 closesocket(dest);
8261 if (src != INVALID_SOCKET)
8262 closesocket(src);
8263 if (connector != INVALID_SOCKET)
8264 closesocket(connector);
8265 CloseHandle(previous_port);
8266 }
8267
8268 static void test_address_list_query(void)
8269 {
8270 SOCKET_ADDRESS_LIST *address_list;
8271 DWORD bytes_returned, size;
8272 unsigned int i;
8273 SOCKET s;
8274 int ret;
8275
8276 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
8277 ok(s != INVALID_SOCKET, "Failed to create socket, error %d.\n", WSAGetLastError());
8278
8279 bytes_returned = 0;
8280 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, 0, &bytes_returned, NULL, NULL);
8281 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
8282 if(WSAGetLastError() == WSAEINVAL)
8283 {
8284 win_skip("Windows <= NT4 is not supported in this test\n");
8285 closesocket(s);
8286 return;
8287 }
8288 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
8289 ok(bytes_returned >= FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]),
8290 "Got unexpected bytes_returned %u.\n", bytes_returned);
8291
8292 size = bytes_returned;
8293 bytes_returned = 0;
8294 address_list = HeapAlloc(GetProcessHeap(), 0, size * 2);
8295 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, size * 2, &bytes_returned, NULL, NULL);
8296 ok(!ret, "Got unexpected ret %d, error %d.\n", ret, WSAGetLastError());
8297 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
8298
8299 bytes_returned = FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[address_list->iAddressCount]);
8300 for (i = 0; i < address_list->iAddressCount; ++i)
8301 {
8302 bytes_returned += address_list->Address[i].iSockaddrLength;
8303 }
8304 ok(size == bytes_returned, "Got unexpected size %u, expected %u.\n", size, bytes_returned);
8305
8306 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, size, NULL, NULL, NULL);
8307 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
8308 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
8309
8310 bytes_returned = 0xdeadbeef;
8311 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, NULL, size, &bytes_returned, NULL, NULL);
8312 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
8313 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
8314 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
8315
8316 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list, 1, &bytes_returned, NULL, NULL);
8317 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
8318 ok(WSAGetLastError() == WSAEINVAL, "Got unexpected error %d.\n", WSAGetLastError());
8319 ok(bytes_returned == 0, "Got unexpected bytes_returned %u.\n", bytes_returned);
8320
8321 ret = WSAIoctl(s, SIO_ADDRESS_LIST_QUERY, NULL, 0, address_list,
8322 FIELD_OFFSET(SOCKET_ADDRESS_LIST, Address[0]), &bytes_returned, NULL, NULL);
8323 ok(ret == SOCKET_ERROR, "Got unexpected ret %d.\n", ret);
8324 ok(WSAGetLastError() == WSAEFAULT, "Got unexpected error %d.\n", WSAGetLastError());
8325 ok(bytes_returned == size, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned, size);
8326
8327 HeapFree(GetProcessHeap(), 0, address_list);
8328 closesocket(s);
8329 }
8330
8331 static DWORD WINAPI inet_ntoa_thread_proc(void *param)
8332 {
8333 ULONG addr;
8334 const char *str;
8335 HANDLE *event = param;
8336
8337 addr = inet_addr("4.3.2.1");
8338 ok(addr == htonl(0x04030201), "expected 0x04030201, got %08x\n", addr);
8339 str = inet_ntoa(*(struct in_addr *)&addr);
8340 ok(!strcmp(str, "4.3.2.1"), "expected 4.3.2.1, got %s\n", str);
8341
8342 SetEvent(event[0]);
8343 WaitForSingleObject(event[1], 3000);
8344
8345 return 0;
8346 }
8347
8348 static void test_inet_ntoa(void)
8349 {
8350 ULONG addr;
8351 const char *str;
8352 HANDLE thread, event[2];
8353 DWORD tid;
8354
8355 addr = inet_addr("1.2.3.4");
8356 ok(addr == htonl(0x01020304), "expected 0x01020304, got %08x\n", addr);
8357 str = inet_ntoa(*(struct in_addr *)&addr);
8358 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
8359
8360 event[0] = CreateEventW(NULL, TRUE, FALSE, NULL);
8361 event[1] = CreateEventW(NULL, TRUE, FALSE, NULL);
8362
8363 thread = CreateThread(NULL, 0, inet_ntoa_thread_proc, event, 0, &tid);
8364 WaitForSingleObject(event[0], 3000);
8365
8366 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
8367
8368 SetEvent(event[1]);
8369 WaitForSingleObject(thread, 3000);
8370
8371 CloseHandle(event[0]);
8372 CloseHandle(event[1]);
8373 CloseHandle(thread);
8374 }
8375
8376 static void test_WSALookupService(void)
8377 {
8378 char buffer[4096], strbuff[128];
8379 WSAQUERYSETW *qs = NULL;
8380 HANDLE hnd;
8381 PNLA_BLOB netdata;
8382 int ret;
8383 DWORD error, offset, bsize;
8384
8385 if (!pWSALookupServiceBeginW || !pWSALookupServiceEnd || !pWSALookupServiceNextW)
8386 {
8387 win_skip("WSALookupServiceBeginW or WSALookupServiceEnd or WSALookupServiceNextW not found\n");
8388 return;
8389 }
8390
8391 qs = (WSAQUERYSETW *)buffer;
8392 memset(qs, 0, sizeof(*qs));
8393
8394 /* invalid parameter tests */
8395 ret = pWSALookupServiceBeginW(NULL, 0, &hnd);
8396 error = WSAGetLastError();
8397 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
8398 todo_wine
8399 ok(error == WSAEFAULT, "expected 10014, got %d\n", error);
8400
8401 ret = pWSALookupServiceBeginW(qs, 0, NULL);
8402 error = WSAGetLastError();
8403 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
8404 todo_wine
8405 ok(error == WSAEFAULT, "expected 10014, got %d\n", error);
8406
8407 ret = pWSALookupServiceBeginW(qs, 0, &hnd);
8408 error = WSAGetLastError();
8409 ok(ret == SOCKET_ERROR, "WSALookupServiceBeginW should have failed\n");
8410 todo_wine
8411 ok(error == WSAEINVAL
8412 || broken(error == ERROR_INVALID_PARAMETER) /* == XP */
8413 || broken(error == WSAEFAULT) /* == NT */
8414 || broken(error == WSASERVICE_NOT_FOUND) /* == 2000 */,
8415 "expected 10022, got %d\n", error);
8416
8417 ret = pWSALookupServiceEnd(NULL);
8418 error = WSAGetLastError();
8419 todo_wine
8420 ok(ret == SOCKET_ERROR, "WSALookupServiceEnd should have failed\n");
8421 todo_wine
8422 ok(error == ERROR_INVALID_HANDLE, "expected 6, got %d\n", error);
8423
8424 /* standard network list query */
8425 qs->dwSize = sizeof(*qs);
8426 hnd = (HANDLE)0xdeadbeef;
8427 ret = pWSALookupServiceBeginW(qs, LUP_RETURN_ALL | LUP_DEEP, &hnd);
8428 error = WSAGetLastError();
8429 if(ret && error == ERROR_INVALID_PARAMETER)
8430 {
8431 win_skip("the current WSALookupServiceBeginW test is not supported in win <= 2000\n");
8432 return;
8433 }
8434
8435 todo_wine
8436 ok(!ret, "WSALookupServiceBeginW failed unexpectedly with error %d\n", error);
8437 todo_wine
8438 ok(hnd != (HANDLE)0xdeadbeef, "Handle was not filled\n");
8439
8440 offset = 0;
8441 do
8442 {
8443 memset(qs, 0, sizeof(*qs));
8444 bsize = sizeof(buffer);
8445
8446 if (pWSALookupServiceNextW(hnd, 0, &bsize, qs) == SOCKET_ERROR)
8447 {
8448 error = WSAGetLastError();
8449 if (error == WSA_E_NO_MORE) break;
8450 ok(0, "Error %d happened while listing services\n", error);
8451 break;
8452 }
8453
8454 WideCharToMultiByte(CP_ACP, 0, qs->lpszServiceInstanceName, -1,
8455 strbuff, sizeof(strbuff), NULL, NULL);
8456 trace("Network Name: %s\n", strbuff);
8457
8458 /* network data is written in the blob field */
8459 if (qs->lpBlob)
8460 {
8461 /* each network may have multiple NLA_BLOB information structures */
8462 do
8463 {
8464 netdata = (PNLA_BLOB) &qs->lpBlob->pBlobData[offset];
8465 switch (netdata->header.type)
8466 {
8467 case NLA_RAW_DATA:
8468 trace("\tNLA Data Type: NLA_RAW_DATA\n");
8469 break;
8470 case NLA_INTERFACE:
8471 trace("\tNLA Data Type: NLA_INTERFACE\n");
8472 trace("\t\tType: %d\n", netdata->data.interfaceData.dwType);
8473 trace("\t\tSpeed: %d\n", netdata->data.interfaceData.dwSpeed);
8474 trace("\t\tAdapter Name: %s\n", netdata->data.interfaceData.adapterName);
8475 break;
8476 case NLA_802_1X_LOCATION:
8477 trace("\tNLA Data Type: NLA_802_1X_LOCATION\n");
8478 trace("\t\tInformation: %s\n", netdata->data.locationData.information);
8479 break;
8480 case NLA_CONNECTIVITY:
8481 switch (netdata->data.connectivity.type)
8482 {
8483 case NLA_NETWORK_AD_HOC:
8484 trace("\t\tNetwork Type: AD HOC\n");
8485 break;
8486 case NLA_NETWORK_MANAGED:
8487 trace("\t\tNetwork Type: Managed\n");
8488 break;
8489 case NLA_NETWORK_UNMANAGED:
8490 trace("\t\tNetwork Type: Unmanaged\n");
8491 break;
8492 case NLA_NETWORK_UNKNOWN:
8493 trace("\t\tNetwork Type: Unknown\n");
8494 }
8495 switch (netdata->data.connectivity.internet)
8496 {
8497 case NLA_INTERNET_NO:
8498 trace("\t\tInternet connectivity: No\n");
8499 break;
8500 case NLA_INTERNET_YES:
8501 trace("\t\tInternet connectivity: Yes\n");
8502 break;
8503 case NLA_INTERNET_UNKNOWN:
8504 trace("\t\tInternet connectivity: Unknown\n");
8505 break;
8506 }
8507 break;
8508 case NLA_ICS:
8509 trace("\tNLA Data Type: NLA_ICS\n");
8510 trace("\t\tSpeed: %d\n",
8511 netdata->data.ICS.remote.speed);
8512 trace("\t\tType: %d\n",
8513 netdata->data.ICS.remote.type);
8514 trace("\t\tState: %d\n",
8515 netdata->data.ICS.remote.state);
8516 WideCharToMultiByte(CP_ACP, 0, netdata->data.ICS.remote.machineName, -1,
8517 strbuff, sizeof(strbuff), NULL, NULL);
8518 trace("\t\tMachine Name: %s\n", strbuff);
8519 WideCharToMultiByte(CP_ACP, 0, netdata->data.ICS.remote.sharedAdapterName, -1,
8520 strbuff, sizeof(strbuff), NULL, NULL);
8521 trace("\t\tShared Adapter Name: %s\n", strbuff);
8522 break;
8523 default:
8524 trace("\tNLA Data Type: Unknown\n");
8525 break;
8526 }
8527 }
8528 while (offset);
8529 }
8530 }
8531 while (1);
8532
8533 ret = pWSALookupServiceEnd(hnd);
8534 ok(!ret, "WSALookupServiceEnd failed unexpectedly\n");
8535 }
8536
8537 /**************** Main program ***************/
8538
8539 START_TEST( sock )
8540 {
8541 int i;
8542
8543 /* Leave these tests at the beginning. They depend on WSAStartup not having been
8544 * called, which is done by Init() below. */
8545 test_WithoutWSAStartup();
8546 test_WithWSAStartup();
8547
8548 Init();
8549
8550 test_inet_ntoa();
8551 test_inet_pton();
8552 test_set_getsockopt();
8553 test_so_reuseaddr();
8554 test_ip_pktinfo();
8555 test_extendedSocketOptions();
8556
8557 for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
8558 {
8559 trace ( " **** STARTING TEST %d ****\n", i );
8560 do_test ( &tests[i] );
8561 trace ( " **** TEST %d COMPLETE ****\n", i );
8562 }
8563
8564 test_UDP();
8565
8566 test_getservbyname();
8567 test_WSASocket();
8568 test_WSADuplicateSocket();
8569 test_WSAEnumNetworkEvents();
8570
8571 test_WSAAddressToStringA();
8572 test_WSAAddressToStringW();
8573
8574 test_WSAStringToAddressA();
8575 test_WSAStringToAddressW();
8576
8577 test_errors();
8578 test_listen();
8579 test_select();
8580 test_accept();
8581 test_getpeername();
8582 test_getsockname();
8583 test_inet_addr();
8584 test_addr_to_print();
8585 test_ioctlsocket();
8586 test_dns();
8587 test_gethostbyname_hack();
8588 test_gethostname();
8589
8590 test_WSASendMsg();
8591 test_WSASendTo();
8592 test_WSARecv();
8593
8594 test_events(0);
8595 test_events(1);
8596
8597 test_ipv6only();
8598 test_GetAddrInfoW();
8599 test_getaddrinfo();
8600 test_AcceptEx();
8601 test_ConnectEx();
8602
8603 test_sioRoutingInterfaceQuery();
8604 test_sioAddressListChange();
8605
8606 test_WSALookupService();
8607
8608 test_WSAAsyncGetServByPort();
8609 test_WSAAsyncGetServByName();
8610
8611 test_completion_port();
8612 test_address_list_query();
8613
8614 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
8615 test_send();
8616 test_synchronous_WSAIoctl();
8617
8618 Exit();
8619 }
Windows API implementation