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