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