projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[FUSION_WINETEST] - Fix a warning. Already applied upstream.
[reactos.git] / rostests / winetests / ws2_32 / sock.c
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 <windows.h>
26
27 #include <ws2tcpip.h>
28 #include <mswsock.h>
29 #include <stdio.h>
30 #include "wine/test.h"
31
32 #define MAX_CLIENTS 4 /* Max number of clients */
33 #define NUM_TESTS 4 /* Number of tests performed */
34 #define FIRST_CHAR 'A' /* First character in transferred pattern */
35 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
36 #define BIND_TRIES 6 /* Number of bind() attempts */
37 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
38 after server initialization, if something hangs */
39
40 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
41
42 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
43 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
44
45 #define SERVERIP "127.0.0.1" /* IP to bind to */
46 #define SERVERPORT 9374 /* Port number to bind to */
47
48 #define wsa_ok(op, cond, msg) \
49 do { \
50 int tmp, err = 0; \
51 tmp = op; \
52 if ( !(cond tmp) ) err = WSAGetLastError(); \
53 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
54 } while (0);
55
56 /* Function pointers */
57 static void (WINAPI *pFreeAddrInfoW)(PADDRINFOW) = 0;
58 static int (WINAPI *pGetAddrInfoW)(LPCWSTR,LPCWSTR,const ADDRINFOW *,PADDRINFOW *) = 0;
59 static PCSTR (WINAPI *pInetNtop)(INT,LPVOID,LPSTR,ULONG) = 0;
60
61 /**************** Structs and typedefs ***************/
62
63 typedef struct thread_info
64 {
65 HANDLE thread;
66 DWORD id;
67 } thread_info;
68
69 /* Information in the server about open client connections */
70 typedef struct sock_info
71 {
72 SOCKET s;
73 struct sockaddr_in addr;
74 struct sockaddr_in peer;
75 char *buf;
76 int n_recvd;
77 int n_sent;
78 } sock_info;
79
80 /* Test parameters for both server & client */
81 typedef struct test_params
82 {
83 int sock_type;
84 int sock_prot;
85 const char *inet_addr;
86 short inet_port;
87 int chunk_size;
88 int n_chunks;
89 int n_clients;
90 } test_params;
91
92 /* server-specific test parameters */
93 typedef struct server_params
94 {
95 test_params *general;
96 DWORD sock_flags;
97 int buflen;
98 } server_params;
99
100 /* client-specific test parameters */
101 typedef struct client_params
102 {
103 test_params *general;
104 DWORD sock_flags;
105 int buflen;
106 } client_params;
107
108 /* This type combines all information for setting up a test scenario */
109 typedef struct test_setup
110 {
111 test_params general;
112 LPVOID srv;
113 server_params srv_params;
114 LPVOID clt;
115 client_params clt_params;
116 } test_setup;
117
118 /* Thread local storage for server */
119 typedef struct server_memory
120 {
121 SOCKET s;
122 struct sockaddr_in addr;
123 sock_info sock[MAX_CLIENTS];
124 } server_memory;
125
126 /* Thread local storage for client */
127 typedef struct client_memory
128 {
129 SOCKET s;
130 struct sockaddr_in addr;
131 char *send_buf;
132 char *recv_buf;
133 } client_memory;
134
135 /* SelectReadThread thread parameters */
136 typedef struct select_thread_params
137 {
138 SOCKET s;
139 BOOL ReadKilled;
140 } select_thread_params;
141
142 /**************** Static variables ***************/
143
144 static DWORD tls; /* Thread local storage index */
145 static HANDLE thread[1+MAX_CLIENTS];
146 static DWORD thread_id[1+MAX_CLIENTS];
147 static HANDLE server_ready;
148 static HANDLE client_ready[MAX_CLIENTS];
149 static int client_id;
150
151 /**************** General utility functions ***************/
152
153 static int tcp_socketpair(SOCKET *src, SOCKET *dst)
154 {
155 SOCKET server = INVALID_SOCKET;
156 struct sockaddr_in addr;
157 int len;
158 int ret;
159
160 *src = INVALID_SOCKET;
161 *dst = INVALID_SOCKET;
162
163 *src = socket(AF_INET, SOCK_STREAM, 0);
164 if (*src == INVALID_SOCKET)
165 goto end;
166
167 server = socket(AF_INET, SOCK_STREAM, 0);
168 if (server == INVALID_SOCKET)
169 goto end;
170
171 memset(&addr, 0, sizeof(addr));
172 addr.sin_family = AF_INET;
173 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
174 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
175 if (ret != 0)
176 goto end;
177
178 len = sizeof(addr);
179 ret = getsockname(server, (struct sockaddr*)&addr, &len);
180 if (ret != 0)
181 goto end;
182
183 ret = listen(server, 1);
184 if (ret != 0)
185 goto end;
186
187 ret = connect(*src, (struct sockaddr*)&addr, sizeof(addr));
188 if (ret != 0)
189 goto end;
190
191 len = sizeof(addr);
192 *dst = accept(server, (struct sockaddr*)&addr, &len);
193
194 end:
195 if (server != INVALID_SOCKET)
196 closesocket(server);
197 if (*src != INVALID_SOCKET && *dst != INVALID_SOCKET)
198 return 0;
199 closesocket(*src);
200 closesocket(*dst);
201 return -1;
202 }
203
204 static void set_so_opentype ( BOOL overlapped )
205 {
206 int optval = !overlapped, newval, len = sizeof (int);
207
208 ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
209 (LPVOID) &optval, sizeof (optval) ) == 0,
210 "setting SO_OPENTYPE failed\n" );
211 ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
212 (LPVOID) &newval, &len ) == 0,
213 "getting SO_OPENTYPE failed\n" );
214 ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
215 }
216
217 static int set_blocking ( SOCKET s, BOOL blocking )
218 {
219 u_long val = !blocking;
220 return ioctlsocket ( s, FIONBIO, &val );
221 }
222
223 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
224 {
225 char c, *p;
226 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
227 memset ( p, c, chunk_size );
228 }
229
230 static int test_buffer ( char *buf, int chunk_size, int n_chunks )
231 {
232 char c, *p;
233 int i;
234 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
235 {
236 for ( i = 0; i < chunk_size; i++ )
237 if ( p[i] != c ) return i;
238 }
239 return -1;
240 }
241
242 /*
243 * This routine is called when a client / server does not expect any more data,
244 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
245 */
246 static void read_zero_bytes ( SOCKET s )
247 {
248 char buf[256];
249 int tmp, n = 0;
250 while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
251 n += tmp;
252 ok ( n <= 0, "garbage data received: %d bytes\n", n );
253 }
254
255 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int sendlen )
256 {
257 char* last = buf + buflen, *p;
258 int n = 1;
259 for ( p = buf; n > 0 && p < last; p += n )
260 n = send ( s, p, min ( sendlen, last - p ), 0 );
261 wsa_ok ( n, 0 <=, "do_synchronous_send (%x): error %d\n" );
262 return p - buf;
263 }
264
265 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int recvlen )
266 {
267 char* last = buf + buflen, *p;
268 int n = 1;
269 for ( p = buf; n > 0 && p < last; p += n )
270 n = recv ( s, p, min ( recvlen, last - p ), 0 );
271 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
272 return p - buf;
273 }
274
275 static int do_synchronous_recvfrom ( SOCKET s, char *buf, int buflen,int flags,struct sockaddr *from, int *fromlen, int recvlen )
276 {
277 char* last = buf + buflen, *p;
278 int n = 1;
279 for ( p = buf; n > 0 && p < last; p += n )
280 n = recvfrom ( s, p, min ( recvlen, last - p ), 0, from, fromlen );
281 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
282 return p - buf;
283 }
284
285 /*
286 * Call this routine right after thread startup.
287 * SO_OPENTYPE must by 0, regardless what the server did.
288 */
289 static void check_so_opentype (void)
290 {
291 int tmp = 1, len;
292 len = sizeof (tmp);
293 getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
294 ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
295 }
296
297 /**************** Server utility functions ***************/
298
299 /*
300 * Even if we have closed our server socket cleanly,
301 * the OS may mark the address "in use" for some time -
302 * this happens with native Linux apps, too.
303 */
304 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
305 {
306 int err, wsaerr = 0, n_try = BIND_TRIES;
307
308 while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
309 ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
310 n_try-- >= 0)
311 {
312 trace ( "address in use, waiting ...\n" );
313 Sleep ( 1000 * BIND_SLEEP );
314 }
315 ok ( err == 0, "failed to bind: %d\n", wsaerr );
316 }
317
318 static void server_start ( server_params *par )
319 {
320 int i;
321 test_params *gen = par->general;
322 server_memory *mem = LocalAlloc ( LPTR, sizeof ( server_memory ) );
323
324 TlsSetValue ( tls, mem );
325 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
326 NULL, 0, par->sock_flags );
327 ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
328
329 mem->addr.sin_family = AF_INET;
330 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
331 mem->addr.sin_port = htons ( gen->inet_port );
332
333 for (i = 0; i < MAX_CLIENTS; i++)
334 {
335 mem->sock[i].s = INVALID_SOCKET;
336 mem->sock[i].buf = LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
337 mem->sock[i].n_recvd = 0;
338 mem->sock[i].n_sent = 0;
339 }
340
341 if ( gen->sock_type == SOCK_STREAM )
342 do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
343 }
344
345 static void server_stop (void)
346 {
347 int i;
348 server_memory *mem = TlsGetValue ( tls );
349
350 for (i = 0; i < MAX_CLIENTS; i++ )
351 {
352 LocalFree ( mem->sock[i].buf );
353 if ( mem->sock[i].s != INVALID_SOCKET )
354 closesocket ( mem->sock[i].s );
355 }
356 ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
357 LocalFree ( mem );
358 ExitThread ( GetCurrentThreadId () );
359 }
360
361 /**************** Client utilitiy functions ***************/
362
363 static void client_start ( client_params *par )
364 {
365 test_params *gen = par->general;
366 client_memory *mem = LocalAlloc (LPTR, sizeof (client_memory));
367
368 TlsSetValue ( tls, mem );
369
370 WaitForSingleObject ( server_ready, INFINITE );
371
372 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
373 NULL, 0, par->sock_flags );
374
375 mem->addr.sin_family = AF_INET;
376 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
377 mem->addr.sin_port = htons ( gen->inet_port );
378
379 ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
380
381 mem->send_buf = LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
382 mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
383 fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
384
385 SetEvent ( client_ready[client_id] );
386 /* Wait for the other clients to come up */
387 WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
388 }
389
390 static void client_stop (void)
391 {
392 client_memory *mem = TlsGetValue ( tls );
393 wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%x): %d\n" );
394 LocalFree ( mem->send_buf );
395 LocalFree ( mem );
396 ExitThread(0);
397 }
398
399 /**************** Servers ***************/
400
401 /*
402 * simple_server: A very basic server doing synchronous IO.
403 */
404 static VOID WINAPI simple_server ( server_params *par )
405 {
406 test_params *gen = par->general;
407 server_memory *mem;
408 int pos, n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
409 id = GetCurrentThreadId();
410
411 trace ( "simple_server (%x) starting\n", id );
412
413 set_so_opentype ( FALSE ); /* non-overlapped */
414 server_start ( par );
415 mem = TlsGetValue ( tls );
416
417 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
418 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%x): listen failed: %d\n");
419
420 trace ( "simple_server (%x) ready\n", id );
421 SetEvent ( server_ready ); /* notify clients */
422
423 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
424 {
425 trace ( "simple_server (%x): waiting for client\n", id );
426
427 /* accept a single connection */
428 tmp = sizeof ( mem->sock[0].peer );
429 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
430 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%x): accept failed: %d\n" );
431
432 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
433 "simple_server (%x): strange peer address\n", id );
434
435 /* Receive data & check it */
436 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
437 ok ( n_recvd == n_expected,
438 "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
439 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
440 ok ( pos == -1, "simple_server (%x): test pattern error: %d\n", id, pos);
441
442 /* Echo data back */
443 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
444 ok ( n_sent == n_expected,
445 "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
446
447 /* cleanup */
448 read_zero_bytes ( mem->sock[0].s );
449 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "simple_server (%x): closesocket error: %d\n" );
450 mem->sock[0].s = INVALID_SOCKET;
451 }
452
453 trace ( "simple_server (%x) exiting\n", id );
454 server_stop ();
455 }
456
457 /*
458 * select_server: A non-blocking server.
459 */
460 static VOID WINAPI select_server ( server_params *par )
461 {
462 test_params *gen = par->general;
463 server_memory *mem;
464 int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
465 id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
466 n_set, delta, n_ready;
467 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
468 fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
469
470 trace ( "select_server (%x) starting\n", id );
471
472 set_so_opentype ( FALSE ); /* non-overlapped */
473 server_start ( par );
474 mem = TlsGetValue ( tls );
475
476 wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
477 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%x): listen failed: %d\n");
478
479 trace ( "select_server (%x) ready\n", id );
480 SetEvent ( server_ready ); /* notify clients */
481
482 FD_ZERO ( &fds_openrecv );
483 FD_ZERO ( &fds_recv );
484 FD_ZERO ( &fds_send );
485 FD_ZERO ( &fds_opensend );
486
487 FD_SET ( mem->s, &fds_openrecv );
488
489 while(1)
490 {
491 fds_recv = fds_openrecv;
492 fds_send = fds_opensend;
493
494 n_set = 0;
495
496 wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
497 "select_server (%x): select() failed: %d\n" );
498
499 /* check for incoming requests */
500 if ( FD_ISSET ( mem->s, &fds_recv ) ) {
501 n_set += 1;
502
503 trace ( "select_server (%x): accepting client connection\n", id );
504
505 /* accept a single connection */
506 tmp = sizeof ( mem->sock[n_connections].peer );
507 mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
508 wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%x): accept() failed: %d\n" );
509
510 ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
511 "select_server (%x): strange peer address\n", id );
512
513 /* add to list of open connections */
514 FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
515 FD_SET ( mem->sock[n_connections].s, &fds_opensend );
516
517 n_connections++;
518 }
519
520 /* handle open requests */
521
522 for ( i = 0; i < n_connections; i++ )
523 {
524 if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
525 n_set += 1;
526
527 if ( mem->sock[i].n_recvd < n_expected ) {
528 /* Receive data & check it */
529 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 );
530 ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
531 mem->sock[i].n_recvd += n_recvd;
532
533 if ( mem->sock[i].n_recvd == n_expected ) {
534 int pos = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
535 ok ( pos == -1, "select_server (%x): test pattern error: %d\n", id, pos );
536 FD_CLR ( mem->sock[i].s, &fds_openrecv );
537 }
538
539 ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
540 }
541 }
542
543 /* only echo back what we've received */
544 delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
545
546 if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
547 n_set += 1;
548
549 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
550 /* Echo data back */
551 n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
552 ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
553 mem->sock[i].n_sent += n_sent;
554
555 if ( mem->sock[i].n_sent == n_expected ) {
556 FD_CLR ( mem->sock[i].s, &fds_opensend );
557 }
558
559 ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
560 }
561 }
562 }
563
564 /* check that select returned the correct number of ready sockets */
565 ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
566
567 /* check if all clients are done */
568 if ( ( fds_opensend.fd_count == 0 )
569 && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
570 && ( n_connections == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
571 break;
572 }
573 }
574
575 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
576 {
577 /* cleanup */
578 read_zero_bytes ( mem->sock[i].s );
579 wsa_ok ( closesocket ( mem->sock[i].s ), 0 ==, "select_server (%x): closesocket error: %d\n" );
580 mem->sock[i].s = INVALID_SOCKET;
581 }
582
583 trace ( "select_server (%x) exiting\n", id );
584 server_stop ();
585 }
586
587 /**************** Clients ***************/
588
589 /*
590 * simple_client: A very basic client doing synchronous IO.
591 */
592 static VOID WINAPI simple_client ( client_params *par )
593 {
594 test_params *gen = par->general;
595 client_memory *mem;
596 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
597
598 id = GetCurrentThreadId();
599 trace ( "simple_client (%x): starting\n", id );
600 /* wait here because we want to call set_so_opentype before creating a socket */
601 WaitForSingleObject ( server_ready, INFINITE );
602 trace ( "simple_client (%x): server ready\n", id );
603
604 check_so_opentype ();
605 set_so_opentype ( FALSE ); /* non-overlapped */
606 client_start ( par );
607 mem = TlsGetValue ( tls );
608
609 /* Connect */
610 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
611 0 ==, "simple_client (%x): connect error: %d\n" );
612 ok ( set_blocking ( mem->s, TRUE ) == 0,
613 "simple_client (%x): failed to set blocking mode\n", id );
614 trace ( "simple_client (%x) connected\n", id );
615
616 /* send data to server */
617 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, par->buflen );
618 ok ( n_sent == n_expected,
619 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
620
621 /* shutdown send direction */
622 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
623
624 /* Receive data echoed back & check it */
625 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, par->buflen );
626 ok ( n_recvd == n_expected,
627 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
628
629 /* check data */
630 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
631 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
632
633 /* cleanup */
634 read_zero_bytes ( mem->s );
635 trace ( "simple_client (%x) exiting\n", id );
636 client_stop ();
637 }
638
639 /*
640 * simple_mixed_client: mixing send and recvfrom
641 */
642 static VOID WINAPI simple_mixed_client ( client_params *par )
643 {
644 test_params *gen = par->general;
645 client_memory *mem;
646 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
647 int fromLen = sizeof(mem->addr);
648 struct sockaddr test;
649
650 id = GetCurrentThreadId();
651 trace ( "simple_client (%x): starting\n", id );
652 /* wait here because we want to call set_so_opentype before creating a socket */
653 WaitForSingleObject ( server_ready, INFINITE );
654 trace ( "simple_client (%x): server ready\n", id );
655
656 check_so_opentype ();
657 set_so_opentype ( FALSE ); /* non-overlapped */
658 client_start ( par );
659 mem = TlsGetValue ( tls );
660
661 /* Connect */
662 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
663 0 ==, "simple_client (%x): connect error: %d\n" );
664 ok ( set_blocking ( mem->s, TRUE ) == 0,
665 "simple_client (%x): failed to set blocking mode\n", id );
666 trace ( "simple_client (%x) connected\n", id );
667
668 /* send data to server */
669 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, par->buflen );
670 ok ( n_sent == n_expected,
671 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
672
673 /* shutdown send direction */
674 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
675
676 /* this shouldn't change, since lpFrom, is not updated on
677 connection oriented sockets - exposed by bug 11640
678 */
679 ((struct sockaddr_in*)&test)->sin_addr.s_addr = inet_addr("0.0.0.0");
680
681 /* Receive data echoed back & check it */
682 n_recvd = do_synchronous_recvfrom ( mem->s,
683 mem->recv_buf,
684 n_expected,
685 0,
686 (struct sockaddr *)&test,
687 &fromLen,
688 par->buflen );
689 ok ( n_recvd == n_expected,
690 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
691
692 /* check that lpFrom was not updated */
693 ok(0 ==
694 strcmp(
695 inet_ntoa(((struct sockaddr_in*)&test)->sin_addr),
696 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
697
698 /* check data */
699 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
700 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
701
702 /* cleanup */
703 read_zero_bytes ( mem->s );
704 trace ( "simple_client (%x) exiting\n", id );
705 client_stop ();
706 }
707
708 /*
709 * event_client: An event-driven client
710 */
711 static void WINAPI event_client ( client_params *par )
712 {
713 test_params *gen = par->general;
714 client_memory *mem;
715 int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
716 tmp, err, n;
717 HANDLE event;
718 WSANETWORKEVENTS wsa_events;
719 char *send_last, *recv_last, *send_p, *recv_p;
720 LONG mask = FD_READ | FD_WRITE | FD_CLOSE;
721
722 trace ( "event_client (%x): starting\n", id );
723 client_start ( par );
724 trace ( "event_client (%x): server ready\n", id );
725
726 mem = TlsGetValue ( tls );
727
728 /* Prepare event notification for connect, makes socket nonblocking */
729 event = WSACreateEvent ();
730 WSAEventSelect ( mem->s, event, FD_CONNECT );
731 tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
732 if ( tmp != 0 ) {
733 err = WSAGetLastError ();
734 ok ( err == WSAEWOULDBLOCK, "event_client (%x): connect error: %d\n", id, err );
735 tmp = WaitForSingleObject ( event, INFINITE );
736 ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
737 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
738 wsa_ok ( err, 0 ==, "event_client (%x): WSAEnumNetworkEvents error: %d\n" );
739 err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
740 ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
741 if ( err ) goto out;
742 }
743
744 trace ( "event_client (%x) connected\n", id );
745
746 WSAEventSelect ( mem->s, event, mask );
747
748 recv_p = mem->recv_buf;
749 recv_last = mem->recv_buf + n_expected;
750 send_p = mem->send_buf;
751 send_last = mem->send_buf + n_expected;
752
753 while ( TRUE )
754 {
755 err = WaitForSingleObject ( event, INFINITE );
756 ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
757
758 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
759 wsa_ok ( err, 0 ==, "event_client (%x): WSAEnumNetworkEvents error: %d\n" );
760
761 if ( wsa_events.lNetworkEvents & FD_WRITE )
762 {
763 err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
764 ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
765
766 if ( err== 0 )
767 do
768 {
769 n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
770 if ( n < 0 )
771 {
772 err = WSAGetLastError ();
773 ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
774 }
775 else
776 send_p += n;
777 }
778 while ( n >= 0 && send_p < send_last );
779
780 if ( send_p == send_last )
781 {
782 trace ( "event_client (%x): all data sent - shutdown\n", id );
783 shutdown ( mem->s, SD_SEND );
784 mask &= ~FD_WRITE;
785 WSAEventSelect ( mem->s, event, mask );
786 }
787 }
788 if ( wsa_events.lNetworkEvents & FD_READ )
789 {
790 err = wsa_events.iErrorCode[ FD_READ_BIT ];
791 ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
792 if ( err != 0 ) break;
793
794 /* First read must succeed */
795 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
796 wsa_ok ( n, 0 <=, "event_client (%x): recv error: %d\n" );
797
798 while ( n >= 0 ) {
799 recv_p += n;
800 if ( recv_p == recv_last )
801 {
802 mask &= ~FD_READ;
803 trace ( "event_client (%x): all data received\n", id );
804 WSAEventSelect ( mem->s, event, mask );
805 break;
806 }
807 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
808 if ( n < 0 && ( err = WSAGetLastError()) != WSAEWOULDBLOCK )
809 ok ( 0, "event_client (%x): read error: %d\n", id, err );
810
811 }
812 }
813 if ( wsa_events.lNetworkEvents & FD_CLOSE )
814 {
815 trace ( "event_client (%x): close event\n", id );
816 err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
817 ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
818 break;
819 }
820 }
821
822 n = send_p - mem->send_buf;
823 ok ( send_p == send_last,
824 "simple_client (%x): sent less data than expected: %d of %d\n", id, n, n_expected );
825 n = recv_p - mem->recv_buf;
826 ok ( recv_p == recv_last,
827 "simple_client (%x): received less data than expected: %d of %d\n", id, n, n_expected );
828 n = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
829 ok ( n == -1, "event_client (%x): test pattern error: %d\n", id, n);
830
831 out:
832 WSACloseEvent ( event );
833 trace ( "event_client (%x) exiting\n", id );
834 client_stop ();
835 }
836
837 /* Tests for WSAStartup */
838
839 /* This should fail. WSAStartup should be called before any network function is used. */
840 static void test_WithoutWSAStartup(void)
841 {
842 LPVOID ptr;
843
844 WSASetLastError(0xdeadbeef);
845 ptr = gethostbyname("localhost");
846
847 todo_wine ok(ptr == NULL, "gethostbyname() succeeded unexpectedly: %d\n", WSAGetLastError());
848 todo_wine ok(WSAGetLastError() == WSANOTINITIALISED, "gethostbyname() failed with unexpected error: %d\n",
849 WSAGetLastError());
850 }
851
852 static void test_WithWSAStartup(void)
853 {
854 WSADATA data;
855 WORD version = MAKEWORD( 2, 2 );
856 INT res;
857 LPVOID ptr;
858
859 res = WSAStartup( version, &data );
860 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
861
862 ptr = gethostbyname("localhost");
863 ok(ptr != NULL, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
864
865 WSACleanup();
866 }
867
868 /**************** Main program utility functions ***************/
869
870 static void Init (void)
871 {
872 WORD ver = MAKEWORD (2, 2);
873 WSADATA data;
874 HMODULE hws2_32 = GetModuleHandle("ws2_32.dll");
875
876 pFreeAddrInfoW = (void *)GetProcAddress(hws2_32, "FreeAddrInfoW");
877 pGetAddrInfoW = (void *)GetProcAddress(hws2_32, "GetAddrInfoW");
878 pInetNtop = (void *)GetProcAddress(hws2_32, "inet_ntop");
879
880 ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
881 tls = TlsAlloc();
882 }
883
884 static void Exit (void)
885 {
886 INT ret, err;
887 TlsFree ( tls );
888 ret = WSACleanup();
889 err = WSAGetLastError();
890 ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
891 ret = WSACleanup();
892 err = WSAGetLastError();
893 ok ( (ret == SOCKET_ERROR && err == WSANOTINITIALISED) ||
894 broken(ret == 0), /* WinME */
895 "WSACleanup returned %d GetLastError is %d\n", ret, err);
896 }
897
898 static void StartServer (LPTHREAD_START_ROUTINE routine,
899 test_params *general, server_params *par)
900 {
901 par->general = general;
902 thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
903 ok ( thread[0] != NULL, "Failed to create server thread\n" );
904 }
905
906 static void StartClients (LPTHREAD_START_ROUTINE routine,
907 test_params *general, client_params *par)
908 {
909 int i;
910 par->general = general;
911 for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
912 {
913 client_id = i - 1;
914 thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
915 ok ( thread[i] != NULL, "Failed to create client thread\n" );
916 /* Make sure the client is up and running */
917 WaitForSingleObject ( client_ready[client_id], INFINITE );
918 };
919 }
920
921 static void do_test( test_setup *test )
922 {
923 DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
924 DWORD wait;
925
926 server_ready = CreateEventA ( NULL, TRUE, FALSE, NULL );
927 for (i = 0; i <= n; i++)
928 client_ready[i] = CreateEventA ( NULL, TRUE, FALSE, NULL );
929
930 StartServer ( test->srv, &test->general, &test->srv_params );
931 StartClients ( test->clt, &test->general, &test->clt_params );
932 WaitForSingleObject ( server_ready, INFINITE );
933
934 wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
935 ok ( wait <= WAIT_OBJECT_0 + n ,
936 "some threads have not completed: %x\n", wait );
937
938 if ( ! ( wait <= WAIT_OBJECT_0 + n ) )
939 {
940 for (i = 0; i <= n; i++)
941 {
942 trace ("terminating thread %08x\n", thread_id[i]);
943 if ( WaitForSingleObject ( thread[i], 0 ) != WAIT_OBJECT_0 )
944 TerminateThread ( thread [i], 0 );
945 }
946 }
947 CloseHandle ( server_ready );
948 for (i = 0; i <= n; i++)
949 CloseHandle ( client_ready[i] );
950 }
951
952 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
953 /* optname = SO_LINGER */
954 LINGER linger_testvals[] = {
955 {0,0},
956 {0,73},
957 {1,0},
958 {5,189}
959 };
960
961 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
962 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
963 bug in the linux kernel (fixed in 2.6.8) */
964 #define SOCKTIMEOUT2 997000 /* 997 seconds */
965
966 static void test_set_getsockopt(void)
967 {
968 SOCKET s;
969 int i, err, lasterr;
970 int timeout;
971 LINGER lingval;
972 int size;
973
974 s = socket(AF_INET, SOCK_STREAM, 0);
975 ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
976 if( s == INVALID_SOCKET) return;
977 /* SO_RCVTIMEO */
978 timeout = SOCKTIMEOUT1;
979 size = sizeof(timeout);
980 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
981 if( !err)
982 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
983 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
984 ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
985
986 timeout = 0;
987 size = sizeof(timeout);
988 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
989 if( !err)
990 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
991 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
992 ok( timeout == 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
993
994 /* SO_SNDTIMEO */
995 timeout = SOCKTIMEOUT2; /* 997 seconds. See remark above */
996 size = sizeof(timeout);
997 err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
998 if( !err)
999 err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
1000 ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1001 ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
1002 /* SO_LINGER */
1003 for( i = 0; i < sizeof(linger_testvals)/sizeof(LINGER);i++) {
1004 size = sizeof(lingval);
1005 lingval = linger_testvals[i];
1006 err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, size);
1007 if( !err)
1008 err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, &size);
1009 ok( !err, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1010 ok( !lingval.l_onoff == !linger_testvals[i].l_onoff &&
1011 (lingval.l_linger == linger_testvals[i].l_linger ||
1012 (!lingval.l_linger && !linger_testvals[i].l_onoff))
1013 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i,
1014 lingval.l_onoff, lingval.l_linger,
1015 linger_testvals[i].l_onoff, linger_testvals[i].l_linger);
1016 }
1017 /* Test for erroneously passing a value instead of a pointer as optval */
1018 size = sizeof(char);
1019 err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
1020 ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
1021 "instead of failing.\n");
1022 lasterr = WSAGetLastError();
1023 ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
1024 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1025 lasterr, WSAEFAULT);
1026
1027 /* SO_RCVTIMEO with invalid values for level */
1028 size = sizeof(timeout);
1029 timeout = SOCKTIMEOUT1;
1030 SetLastError(0xdeadbeef);
1031 err = setsockopt(s, 0xffffffff, SO_RCVTIMEO, (char *) &timeout, size);
1032 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1033 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1034 err, WSAGetLastError());
1035
1036 timeout = SOCKTIMEOUT1;
1037 SetLastError(0xdeadbeef);
1038 err = setsockopt(s, 0x00008000, SO_RCVTIMEO, (char *) &timeout, size);
1039 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1040 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1041 err, WSAGetLastError());
1042
1043 closesocket(s);
1044 }
1045
1046 static void test_so_reuseaddr(void)
1047 {
1048 struct sockaddr_in saddr;
1049 SOCKET s1,s2;
1050 unsigned int rc,reuse;
1051 int size;
1052
1053 saddr.sin_family = AF_INET;
1054 saddr.sin_port = htons(9375);
1055 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1056
1057 s1=socket(AF_INET, SOCK_STREAM, 0);
1058 ok(s1!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1059 rc = bind(s1, (struct sockaddr*)&saddr, sizeof(saddr));
1060 ok(rc!=SOCKET_ERROR, "bind(s1) failed error: %d\n", WSAGetLastError());
1061
1062 s2=socket(AF_INET, SOCK_STREAM, 0);
1063 ok(s2!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1064
1065 reuse=0x1234;
1066 size=sizeof(reuse);
1067 rc=getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size );
1068 ok(rc==0 && reuse==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc,reuse);
1069
1070 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1071 ok(rc==SOCKET_ERROR, "bind() succeeded\n");
1072
1073 reuse = 1;
1074 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
1075 ok(rc==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1076
1077 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1078 * a port immediately after closing another socket on that port, so
1079 * basically following the BSD socket semantics here. */
1080 closesocket(s1);
1081 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1082 ok(rc==0, "bind() failed error: %d\n", WSAGetLastError());
1083
1084 closesocket(s2);
1085 }
1086
1087 /************* Array containing the tests to run **********/
1088
1089 #define STD_STREAM_SOCKET \
1090 SOCK_STREAM, \
1091 0, \
1092 SERVERIP, \
1093 SERVERPORT
1094
1095 static test_setup tests [NUM_TESTS] =
1096 {
1097 /* Test 0: synchronous client and server */
1098 {
1099 {
1100 STD_STREAM_SOCKET,
1101 2048,
1102 16,
1103 2
1104 },
1105 simple_server,
1106 {
1107 NULL,
1108 0,
1109 64
1110 },
1111 simple_client,
1112 {
1113 NULL,
1114 0,
1115 128
1116 }
1117 },
1118 /* Test 1: event-driven client, synchronous server */
1119 {
1120 {
1121 STD_STREAM_SOCKET,
1122 2048,
1123 16,
1124 2
1125 },
1126 simple_server,
1127 {
1128 NULL,
1129 0,
1130 64
1131 },
1132 event_client,
1133 {
1134 NULL,
1135 WSA_FLAG_OVERLAPPED,
1136 128
1137 }
1138 },
1139 /* Test 2: synchronous client, non-blocking server via select() */
1140 {
1141 {
1142 STD_STREAM_SOCKET,
1143 2048,
1144 16,
1145 2
1146 },
1147 select_server,
1148 {
1149 NULL,
1150 0,
1151 64
1152 },
1153 simple_client,
1154 {
1155 NULL,
1156 0,
1157 128
1158 }
1159 },
1160 /* Test 3: synchronous mixed client and server */
1161 {
1162 {
1163 STD_STREAM_SOCKET,
1164 2048,
1165 16,
1166 2
1167 },
1168 simple_server,
1169 {
1170 NULL,
1171 0,
1172 64
1173 },
1174 simple_mixed_client,
1175 {
1176 NULL,
1177 0,
1178 128
1179 }
1180 }
1181 };
1182
1183 static void test_UDP(void)
1184 {
1185 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
1186 possible that this test fails due to dropped packets. */
1187
1188 /* peer 0 receives data from all other peers */
1189 struct sock_info peer[NUM_UDP_PEERS];
1190 char buf[16];
1191 int ss, i, n_recv, n_sent;
1192
1193 memset (buf,0,sizeof(buf));
1194 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
1195 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
1196
1197 peer[i].addr.sin_family = AF_INET;
1198 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
1199
1200 if ( i == 0 ) {
1201 peer[i].addr.sin_port = htons ( SERVERPORT );
1202 } else {
1203 peer[i].addr.sin_port = htons ( 0 );
1204 }
1205
1206 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
1207
1208 /* test getsockname() to get peer's port */
1209 ss = sizeof ( peer[i].addr );
1210 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
1211 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
1212 }
1213
1214 /* test getsockname() */
1215 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
1216
1217 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
1218 /* send client's ip */
1219 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
1220 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
1221 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
1222 }
1223
1224 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
1225 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
1226 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
1227 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
1228 }
1229 }
1230
1231 static void WINAPI do_getservbyname( HANDLE *starttest )
1232 {
1233 struct {
1234 const char *name;
1235 const char *proto;
1236 int port;
1237 } serv[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
1238
1239 int i, j;
1240 struct servent *pserv[2];
1241
1242 ok ( WaitForSingleObject ( *starttest, TEST_TIMEOUT * 1000 ) != WAIT_TIMEOUT, "test_getservbyname: timeout waiting for start signal\n");
1243
1244 /* ensure that necessary buffer resizes are completed */
1245 for ( j = 0; j < 2; j++) {
1246 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1247 }
1248
1249 for ( i = 0; i < NUM_QUERIES / 2; i++ ) {
1250 for ( j = 0; j < 2; j++ ) {
1251 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1252 ok ( pserv[j] != NULL, "getservbyname could not retrieve information for %s: %d\n", serv[j].name, WSAGetLastError() );
1253 ok ( pserv[j]->s_port == htons(serv[j].port), "getservbyname returned the wrong port for %s: %d\n", serv[j].name, ntohs(pserv[j]->s_port) );
1254 ok ( !strcmp ( pserv[j]->s_proto, serv[j].proto ), "getservbyname returned the wrong protocol for %s: %s\n", serv[j].name, pserv[j]->s_proto );
1255 ok ( !strcmp ( pserv[j]->s_name, serv[j].name ), "getservbyname returned the wrong name for %s: %s\n", serv[j].name, pserv[j]->s_name );
1256 }
1257
1258 ok ( pserv[0] == pserv[1], "getservbyname: winsock resized servent buffer when not necessary\n" );
1259 }
1260 }
1261
1262 static void test_getservbyname(void)
1263 {
1264 int i;
1265 HANDLE starttest, thread[NUM_THREADS];
1266 DWORD thread_id[NUM_THREADS];
1267
1268 starttest = CreateEvent ( NULL, 1, 0, "test_getservbyname_starttest" );
1269
1270 /* create threads */
1271 for ( i = 0; i < NUM_THREADS; i++ ) {
1272 thread[i] = CreateThread ( NULL, 0, (LPTHREAD_START_ROUTINE) &do_getservbyname, &starttest, 0, &thread_id[i] );
1273 }
1274
1275 /* signal threads to start */
1276 SetEvent ( starttest );
1277
1278 for ( i = 0; i < NUM_THREADS; i++) {
1279 WaitForSingleObject ( thread[i], TEST_TIMEOUT * 1000 );
1280 }
1281 }
1282
1283 static void test_WSASocket(void)
1284 {
1285 SOCKET sock = INVALID_SOCKET;
1286 WSAPROTOCOL_INFOA *pi;
1287 int providers[] = {6, 0};
1288 int ret, err;
1289 UINT pi_size;
1290
1291 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
1292 * to avoid a crash on win98.
1293 */
1294 pi_size = 0;
1295 ret = WSAEnumProtocolsA(providers, NULL, &pi_size);
1296 ok(ret == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
1297 ret);
1298 err = WSAGetLastError();
1299 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
1300 err, WSAENOBUFS);
1301
1302 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
1303 ok(pi != NULL, "Failed to allocate memory\n");
1304 if (pi == NULL) {
1305 skip("Can't continue without memory.\n");
1306 return;
1307 }
1308
1309 ret = WSAEnumProtocolsA(providers, pi, &pi_size);
1310 ok(ret != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
1311 WSAGetLastError());
1312
1313 if (ret <= 0) {
1314 skip("No protocols enumerated.\n");
1315 HeapFree(GetProcessHeap(), 0, pi);
1316 return;
1317 }
1318
1319 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
1320 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
1321 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
1322 WSAGetLastError());
1323
1324 closesocket(sock);
1325 HeapFree(GetProcessHeap(), 0, pi);
1326 }
1327
1328 static void test_WSAAddressToStringA(void)
1329 {
1330 SOCKET v6 = INVALID_SOCKET;
1331 INT ret;
1332 DWORD len;
1333 int GLE;
1334 SOCKADDR_IN sockaddr;
1335 CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1336
1337 CHAR expect1[] = "0.0.0.0";
1338 CHAR expect2[] = "255.255.255.255";
1339 CHAR expect3[] = "0.0.0.0:65535";
1340 CHAR expect4[] = "255.255.255.255:65535";
1341
1342 SOCKADDR_IN6 sockaddr6;
1343 CHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
1344
1345 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1346 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1347 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
1348
1349 CHAR expect6_1[] = "::1";
1350 CHAR expect6_2[] = "20ab::1";
1351 CHAR expect6_3[] = "[20ab::2001]:33274";
1352 CHAR expect6_3_2[] = "[20ab::2001%4660]:33274";
1353 CHAR expect6_3_3[] = "20ab::2001%4660";
1354
1355 len = 0;
1356
1357 sockaddr.sin_family = AF_INET;
1358 sockaddr.sin_port = 0;
1359 sockaddr.sin_addr.s_addr = 0;
1360
1361 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1362 GLE = WSAGetLastError();
1363 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
1364 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1365 GLE, ret );
1366
1367 len = sizeof(address);
1368
1369 sockaddr.sin_family = AF_INET;
1370 sockaddr.sin_port = 0;
1371 sockaddr.sin_addr.s_addr = 0;
1372
1373 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1374 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1375
1376 ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
1377 ok( len == sizeof( expect1 ), "Got size %d\n", len);
1378
1379 len = sizeof(address);
1380
1381 sockaddr.sin_family = AF_INET;
1382 sockaddr.sin_port = 0;
1383 sockaddr.sin_addr.s_addr = 0xffffffff;
1384
1385 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1386 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1387
1388 ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
1389
1390 len = sizeof(address);
1391
1392 sockaddr.sin_family = AF_INET;
1393 sockaddr.sin_port = 0xffff;
1394 sockaddr.sin_addr.s_addr = 0;
1395
1396 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1397 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1398
1399 ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
1400
1401 len = sizeof(address);
1402
1403 sockaddr.sin_family = AF_INET;
1404 sockaddr.sin_port = 0xffff;
1405 sockaddr.sin_addr.s_addr = 0xffffffff;
1406
1407 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1408 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1409
1410 ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
1411 ok( len == sizeof( expect4 ), "Got size %d\n", len);
1412
1413 /*check to see it IPv6 is available */
1414 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
1415 if (v6 == INVALID_SOCKET) {
1416 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
1417 WSAGetLastError(), WSAEAFNOSUPPORT);
1418 goto end;
1419 }
1420 /* Test a short IPv6 address */
1421 len = sizeof(address6);
1422
1423 sockaddr6.sin6_family = AF_INET6;
1424 sockaddr6.sin6_port = 0x0000;
1425 sockaddr6.sin6_scope_id = 0;
1426 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
1427
1428 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1429 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1430 ok( !strcmp( address6, expect6_1 ), "Expected: %s, got: %s\n", expect6_1, address6 );
1431 ok( len == sizeof(expect6_1), "Got size %d\n", len);
1432
1433 /* Test a longer IPv6 address */
1434 len = sizeof(address6);
1435
1436 sockaddr6.sin6_family = AF_INET6;
1437 sockaddr6.sin6_port = 0x0000;
1438 sockaddr6.sin6_scope_id = 0;
1439 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
1440
1441 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1442 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1443 ok( !strcmp( address6, expect6_2 ), "Expected: %s, got: %s\n", expect6_2, address6 );
1444 ok( len == sizeof(expect6_2), "Got size %d\n", len);
1445
1446 /* Test IPv6 address and port number */
1447 len = sizeof(address6);
1448
1449 sockaddr6.sin6_family = AF_INET6;
1450 sockaddr6.sin6_port = 0xfa81;
1451 sockaddr6.sin6_scope_id = 0;
1452 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
1453
1454 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1455 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1456 ok( !strcmp( address6, expect6_3 ), "Expected: %s, got: %s\n", expect6_3, address6 );
1457 ok( len == sizeof(expect6_3), "Got size %d\n", len);
1458
1459 /* Test IPv6 address, port number and scope_id */
1460 len = sizeof(address6);
1461
1462 sockaddr6.sin6_family = AF_INET6;
1463 sockaddr6.sin6_port = 0xfa81;
1464 sockaddr6.sin6_scope_id = 0x1234;
1465 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
1466
1467 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1468 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1469 ok( !strcmp( address6, expect6_3_2 ), "Expected: %s, got: %s\n", expect6_3_2, address6 );
1470 ok( len == sizeof(expect6_3_2), "Got size %d\n", len);
1471
1472 /* Test IPv6 address and scope_id */
1473 len = sizeof(address6);
1474
1475 sockaddr6.sin6_family = AF_INET6;
1476 sockaddr6.sin6_port = 0x0000;
1477 sockaddr6.sin6_scope_id = 0x1234;
1478 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
1479
1480 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1481 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1482 ok( !strcmp( address6, expect6_3_3 ), "Expected: %s, got: %s\n", expect6_3_3, address6 );
1483 ok( len == sizeof(expect6_3_3), "Got size %d\n", len);
1484
1485 end:
1486 if (v6 != INVALID_SOCKET)
1487 closesocket(v6);
1488 }
1489
1490 static void test_WSAAddressToStringW(void)
1491 {
1492 SOCKET v6 = INVALID_SOCKET;
1493 INT ret;
1494 DWORD len;
1495 int GLE;
1496 SOCKADDR_IN sockaddr;
1497 WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1498
1499 WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
1500 WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1501 WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
1502 WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1503 '6', '5', '5', '3', '5', 0 };
1504
1505 SOCKADDR_IN6 sockaddr6;
1506 WCHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
1507
1508 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1509 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1510 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
1511
1512 WCHAR expect6_1[] = {':',':','1',0};
1513 WCHAR expect6_2[] = {'2','0','a','b',':',':','1',0};
1514 WCHAR expect6_3[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
1515 WCHAR expect6_3_2[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
1516 WCHAR expect6_3_3[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
1517
1518 len = 0;
1519
1520 sockaddr.sin_family = AF_INET;
1521 sockaddr.sin_port = 0;
1522 sockaddr.sin_addr.s_addr = 0;
1523
1524 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1525 GLE = WSAGetLastError();
1526 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
1527 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1528 GLE, ret );
1529
1530 len = sizeof(address);
1531
1532 sockaddr.sin_family = AF_INET;
1533 sockaddr.sin_port = 0;
1534 sockaddr.sin_addr.s_addr = 0;
1535
1536 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1537 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1538
1539 ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
1540 ok( len == sizeof( expect1 )/sizeof( WCHAR ), "Got size %d\n", len);
1541
1542 len = sizeof(address);
1543
1544 sockaddr.sin_family = AF_INET;
1545 sockaddr.sin_port = 0;
1546 sockaddr.sin_addr.s_addr = 0xffffffff;
1547
1548 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1549 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1550
1551 ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
1552
1553 len = sizeof(address);
1554
1555 sockaddr.sin_family = AF_INET;
1556 sockaddr.sin_port = 0xffff;
1557 sockaddr.sin_addr.s_addr = 0;
1558
1559 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1560 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1561
1562 ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
1563
1564 len = sizeof(address);
1565
1566 sockaddr.sin_family = AF_INET;
1567 sockaddr.sin_port = 0xffff;
1568 sockaddr.sin_addr.s_addr = 0xffffffff;
1569
1570 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1571 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1572
1573 ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
1574 ok( len == sizeof( expect4 )/sizeof( WCHAR ), "Got %d\n", len);
1575
1576 /*check to see it IPv6 is available */
1577 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
1578 if (v6 == INVALID_SOCKET) {
1579 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
1580 WSAGetLastError(), WSAEAFNOSUPPORT);
1581 goto end;
1582 }
1583
1584 /* Test a short IPv6 address */
1585 len = sizeof(address6)/sizeof(WCHAR);
1586
1587 sockaddr6.sin6_family = AF_INET6;
1588 sockaddr6.sin6_port = 0x0000;
1589 sockaddr6.sin6_scope_id = 0;
1590 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
1591
1592 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1593 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1594 ok( !lstrcmpW( address6, expect6_1 ), "Wrong string returned\n" );
1595 ok( len == sizeof(expect6_1)/sizeof(WCHAR), "Got %d\n", len);
1596
1597 /* Test a longer IPv6 address */
1598 len = sizeof(address6)/sizeof(WCHAR);
1599
1600 sockaddr6.sin6_family = AF_INET6;
1601 sockaddr6.sin6_port = 0x0000;
1602 sockaddr6.sin6_scope_id = 0;
1603 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
1604
1605 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1606 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1607
1608 ok( !lstrcmpW( address6, expect6_2 ), "Wrong string returned\n" );
1609 ok( len == sizeof(expect6_2)/sizeof(WCHAR), "Got %d\n", len);
1610
1611 /* Test IPv6 address and port number */
1612 len = sizeof(address6)/sizeof(WCHAR);
1613
1614 sockaddr6.sin6_family = AF_INET6;
1615 sockaddr6.sin6_port = 0xfa81;
1616 sockaddr6.sin6_scope_id = 0;
1617 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
1618
1619 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1620 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1621 ok( !lstrcmpW( address6, expect6_3 ), "Wrong string returned\n" );
1622 ok( len == sizeof(expect6_3)/sizeof(WCHAR), "Got %d\n", len);
1623
1624 /* Test IPv6 address, port number and scope_id */
1625 len = sizeof(address6)/sizeof(WCHAR);
1626
1627 sockaddr6.sin6_family = AF_INET6;
1628 sockaddr6.sin6_port = 0xfa81;
1629 sockaddr6.sin6_scope_id = 0x1234;
1630 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
1631
1632 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1633 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1634 ok( !lstrcmpW( address6, expect6_3_2 ), "Wrong string returned\n" );
1635 ok( len == sizeof(expect6_3_2)/sizeof(WCHAR), "Got %d\n", len);
1636
1637 /* Test IPv6 address and scope_id */
1638 len = sizeof(address6)/sizeof(WCHAR);
1639
1640 sockaddr6.sin6_family = AF_INET6;
1641 sockaddr6.sin6_port = 0x0000;
1642 sockaddr6.sin6_scope_id = 0xfffe;
1643 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
1644
1645 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1646 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1647 ok( !lstrcmpW( address6, expect6_3_3 ), "Wrong string returned\n" );
1648 ok( len == sizeof(expect6_3_3)/sizeof(WCHAR), "Got %d\n", len);
1649
1650 end:
1651 if (v6 != INVALID_SOCKET)
1652 closesocket(v6);
1653 }
1654
1655 static void test_WSAStringToAddressA(void)
1656 {
1657 INT ret, len;
1658 SOCKADDR_IN sockaddr;
1659 SOCKADDR_IN6 sockaddr6;
1660 int GLE;
1661
1662 CHAR address1[] = "0.0.0.0";
1663 CHAR address2[] = "127.127.127.127";
1664 CHAR address3[] = "255.255.255.255";
1665 CHAR address4[] = "127.127.127.127:65535";
1666 CHAR address5[] = "255.255.255.255:65535";
1667 CHAR address6[] = "::1";
1668 CHAR address7[] = "[::1]";
1669 CHAR address8[] = "[::1]:65535";
1670
1671 len = 0;
1672 sockaddr.sin_family = AF_INET;
1673
1674 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1675 ok( ret == SOCKET_ERROR, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
1676 WSAGetLastError() );
1677
1678 len = sizeof(sockaddr);
1679 sockaddr.sin_port = 0;
1680 sockaddr.sin_addr.s_addr = 0;
1681
1682 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1683 ok( !ret && sockaddr.sin_addr.s_addr == 0,
1684 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1685
1686 len = sizeof(sockaddr);
1687 sockaddr.sin_port = 0;
1688 sockaddr.sin_addr.s_addr = 0;
1689
1690 ret = WSAStringToAddressA( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1691 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
1692 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1693
1694 len = sizeof(sockaddr);
1695 sockaddr.sin_port = 0;
1696 sockaddr.sin_addr.s_addr = 0;
1697
1698 ret = WSAStringToAddressA( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1699 GLE = WSAGetLastError();
1700 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
1701 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1702 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
1703
1704 len = sizeof(sockaddr);
1705 sockaddr.sin_port = 0;
1706 sockaddr.sin_addr.s_addr = 0;
1707
1708 ret = WSAStringToAddressA( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1709 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
1710 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1711
1712 len = sizeof(sockaddr);
1713 sockaddr.sin_port = 0;
1714 sockaddr.sin_addr.s_addr = 0;
1715
1716 ret = WSAStringToAddressA( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1717 GLE = WSAGetLastError();
1718 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
1719 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1720 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
1721
1722 len = sizeof(sockaddr6);
1723 memset(&sockaddr6, 0, len);
1724 sockaddr6.sin6_family = AF_INET6;
1725
1726 ret = WSAStringToAddressA( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1727 &len );
1728 GLE = WSAGetLastError();
1729 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1730 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
1731
1732 len = sizeof(sockaddr6);
1733 memset(&sockaddr6, 0, len);
1734 sockaddr6.sin6_family = AF_INET6;
1735
1736 ret = WSAStringToAddressA( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1737 &len );
1738 GLE = WSAGetLastError();
1739 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1740 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
1741
1742 len = sizeof(sockaddr6);
1743 memset(&sockaddr6, 0, len);
1744 sockaddr6.sin6_family = AF_INET6;
1745
1746 ret = WSAStringToAddressA( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1747 &len );
1748 GLE = WSAGetLastError();
1749 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
1750 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1751 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
1752
1753 }
1754
1755 static void test_WSAStringToAddressW(void)
1756 {
1757 INT ret, len;
1758 SOCKADDR_IN sockaddr;
1759 SOCKADDR_IN6 sockaddr6;
1760 int GLE;
1761
1762 WCHAR address1[] = { '0','.','0','.','0','.','0', 0 };
1763 WCHAR address2[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
1764 WCHAR address3[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1765 WCHAR address4[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
1766 ':', '6', '5', '5', '3', '5', 0 };
1767 WCHAR address5[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1768 '6', '5', '5', '3', '5', 0 };
1769 WCHAR address6[] = {':',':','1','\0'};
1770 WCHAR address7[] = {'[',':',':','1',']','\0'};
1771 WCHAR address8[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
1772
1773 len = 0;
1774 sockaddr.sin_family = AF_INET;
1775
1776 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1777 ok( ret == SOCKET_ERROR, "WSAStringToAddressW() failed unexpectedly: %d\n",
1778 WSAGetLastError() );
1779
1780 len = sizeof(sockaddr);
1781 sockaddr.sin_port = 0;
1782 sockaddr.sin_addr.s_addr = 0;
1783
1784 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1785 ok( !ret && sockaddr.sin_addr.s_addr == 0,
1786 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1787
1788 len = sizeof(sockaddr);
1789 sockaddr.sin_port = 0;
1790 sockaddr.sin_addr.s_addr = 0;
1791
1792 ret = WSAStringToAddressW( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1793 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
1794 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1795
1796 len = sizeof(sockaddr);
1797 sockaddr.sin_port = 0;
1798 sockaddr.sin_addr.s_addr = 0;
1799
1800 ret = WSAStringToAddressW( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1801 GLE = WSAGetLastError();
1802 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
1803 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1804 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
1805
1806 len = sizeof(sockaddr);
1807 sockaddr.sin_port = 0;
1808 sockaddr.sin_addr.s_addr = 0;
1809
1810 ret = WSAStringToAddressW( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1811 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
1812 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1813
1814 len = sizeof(sockaddr);
1815 sockaddr.sin_port = 0;
1816 sockaddr.sin_addr.s_addr = 0;
1817
1818 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1819 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
1820 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1821 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
1822
1823 len = sizeof(sockaddr6);
1824 memset(&sockaddr6, 0, len);
1825 sockaddr6.sin6_family = AF_INET6;
1826
1827 ret = WSAStringToAddressW( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1828 &len );
1829 GLE = WSAGetLastError();
1830 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1831 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
1832
1833 len = sizeof(sockaddr6);
1834 memset(&sockaddr6, 0, len);
1835 sockaddr6.sin6_family = AF_INET6;
1836
1837 ret = WSAStringToAddressW( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1838 &len );
1839 GLE = WSAGetLastError();
1840 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1841 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
1842
1843 len = sizeof(sockaddr6);
1844 memset(&sockaddr6, 0, len);
1845 sockaddr6.sin6_family = AF_INET6;
1846
1847 ret = WSAStringToAddressW( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1848 &len );
1849 GLE = WSAGetLastError();
1850 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
1851 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1852 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
1853
1854 }
1855
1856 static VOID WINAPI SelectReadThread(select_thread_params *par)
1857 {
1858 fd_set readfds;
1859 int ret;
1860 struct sockaddr_in addr;
1861 struct timeval select_timeout;
1862
1863 FD_ZERO(&readfds);
1864 FD_SET(par->s, &readfds);
1865 select_timeout.tv_sec=5;
1866 select_timeout.tv_usec=0;
1867 addr.sin_family = AF_INET;
1868 addr.sin_addr.s_addr = inet_addr(SERVERIP);
1869 addr.sin_port = htons(SERVERPORT);
1870
1871 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
1872 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
1873
1874 SetEvent(server_ready);
1875 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
1876 par->ReadKilled = (ret == 1);
1877 }
1878
1879 static void test_select(void)
1880 {
1881 SOCKET fdRead, fdWrite;
1882 fd_set readfds, writefds, exceptfds;
1883 unsigned int maxfd;
1884 int ret;
1885 struct timeval select_timeout;
1886 select_thread_params thread_params;
1887 HANDLE thread_handle;
1888 DWORD id;
1889
1890 fdRead = socket(AF_INET, SOCK_STREAM, 0);
1891 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
1892 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
1893 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
1894
1895 FD_ZERO(&readfds);
1896 FD_ZERO(&writefds);
1897 FD_ZERO(&exceptfds);
1898 FD_SET(fdRead, &readfds);
1899 FD_SET(fdWrite, &writefds);
1900 FD_SET(fdRead, &exceptfds);
1901 FD_SET(fdWrite, &exceptfds);
1902 select_timeout.tv_sec=0;
1903 select_timeout.tv_usec=500;
1904
1905 maxfd = fdRead;
1906 if (fdWrite > maxfd)
1907 maxfd = fdWrite;
1908
1909 todo_wine {
1910 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
1911 ok ( (ret == 0), "select should not return any socket handles\n");
1912 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
1913 ok ( !FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
1914 }
1915
1916 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
1917 ok ( !FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
1918
1919 todo_wine {
1920 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
1921 }
1922 ret = closesocket(fdWrite);
1923 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
1924
1925 thread_params.s = fdRead;
1926 thread_params.ReadKilled = FALSE;
1927 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
1928 thread_handle = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) &SelectReadThread, &thread_params, 0, &id );
1929 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
1930
1931 WaitForSingleObject (server_ready, INFINITE);
1932 Sleep(200);
1933 ret = closesocket(fdRead);
1934 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
1935
1936 WaitForSingleObject (thread_handle, 1000);
1937 ok ( (thread_params.ReadKilled) ||
1938 broken(thread_params.ReadKilled == 0), /*Win98*/
1939 "closesocket did not wakeup select\n");
1940
1941 }
1942
1943 static DWORD WINAPI AcceptKillThread(select_thread_params *par)
1944 {
1945 struct sockaddr_in address;
1946 int len = sizeof(address);
1947 SOCKET client_socket;
1948
1949 SetEvent(server_ready);
1950 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
1951 if (client_socket != INVALID_SOCKET)
1952 closesocket(client_socket);
1953 par->ReadKilled = (client_socket == INVALID_SOCKET);
1954 return 0;
1955 }
1956
1957
1958 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
1959 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
1960 GROUP FAR * g, DWORD_PTR dwCallbackData)
1961 {
1962 return CF_DEFER;
1963 }
1964
1965 static void test_accept(void)
1966 {
1967 int ret;
1968 SOCKET server_socket = INVALID_SOCKET, accepted = INVALID_SOCKET, connector = INVALID_SOCKET;
1969 struct sockaddr_in address;
1970 int socklen;
1971 select_thread_params thread_params;
1972 HANDLE thread_handle = NULL;
1973 DWORD id;
1974
1975 server_socket = socket(AF_INET, SOCK_STREAM, 0);
1976 if (server_socket == INVALID_SOCKET)
1977 {
1978 trace("error creating server socket: %d\n", WSAGetLastError());
1979 goto done;
1980 }
1981
1982 memset(&address, 0, sizeof(address));
1983 address.sin_addr.s_addr = inet_addr("127.0.0.1");
1984 address.sin_family = AF_INET;
1985 ret = bind(server_socket, (struct sockaddr*) &address, sizeof(address));
1986 if (ret != 0)
1987 {
1988 trace("error binding server socket: %d\n", WSAGetLastError());
1989 goto done;
1990 }
1991
1992 socklen = sizeof(address);
1993 ret = getsockname(server_socket, (struct sockaddr*)&address, &socklen);
1994 if (ret != 0) {
1995 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
1996 goto done;
1997 }
1998
1999 ret = listen(server_socket, 5);
2000 if (ret != 0)
2001 {
2002 trace("error making server socket listen: %d\n", WSAGetLastError());
2003 goto done;
2004 }
2005
2006 trace("Blocking accept next\n");
2007
2008 connector = socket(AF_INET, SOCK_STREAM, 0);
2009 ok(connector != INVALID_SOCKET, "Failed to create connector socket, error %d\n", WSAGetLastError());
2010
2011 ret = connect(connector, (struct sockaddr*)&address, sizeof(address));
2012 ok(ret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
2013
2014 accepted = WSAAccept(server_socket, NULL, NULL, (LPCONDITIONPROC) AlwaysDeferConditionFunc, 0);
2015 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
2016
2017 accepted = accept(server_socket, NULL, 0);
2018 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
2019
2020 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
2021 if (server_ready == INVALID_HANDLE_VALUE)
2022 {
2023 trace("error creating event: %d\n", GetLastError());
2024 goto done;
2025 }
2026
2027 thread_params.s = server_socket;
2028 thread_params.ReadKilled = FALSE;
2029 thread_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) AcceptKillThread,
2030 &thread_params, 0, &id);
2031 if (thread_handle == NULL)
2032 {
2033 trace("error creating thread: %d\n", GetLastError());
2034 goto done;
2035 }
2036
2037 WaitForSingleObject(server_ready, INFINITE);
2038 Sleep(200);
2039 ret = closesocket(server_socket);
2040 if (ret != 0)
2041 {
2042 trace("closesocket failed: %d\n", WSAGetLastError());
2043 goto done;
2044 }
2045
2046 WaitForSingleObject(thread_handle, 1000);
2047 ok(thread_params.ReadKilled || broken(!thread_params.ReadKilled) /* Win98/ME, after accept */,
2048 "closesocket did not wakeup accept\n");
2049
2050 done:
2051 if (accepted != INVALID_SOCKET)
2052 closesocket(accepted);
2053 if (connector != INVALID_SOCKET)
2054 closesocket(connector);
2055 if (thread_handle != NULL)
2056 CloseHandle(thread_handle);
2057 if (server_ready != INVALID_HANDLE_VALUE)
2058 CloseHandle(server_ready);
2059 if (server_socket != INVALID_SOCKET)
2060 closesocket(server_socket);
2061 }
2062
2063 static void test_extendedSocketOptions(void)
2064 {
2065 WSADATA wsa;
2066 SOCKET sock;
2067 struct sockaddr_in sa;
2068 int sa_len = sizeof(struct sockaddr_in);
2069 int optval, optlen = sizeof(int), ret;
2070 BOOL bool_opt_val;
2071 LINGER linger_val;
2072
2073 if(WSAStartup(MAKEWORD(2,0), &wsa)){
2074 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
2075 return;
2076 }
2077
2078 memset(&sa, 0, sa_len);
2079
2080 sa.sin_family = AF_INET;
2081 sa.sin_port = htons(0);
2082 sa.sin_addr.s_addr = htonl(INADDR_ANY);
2083
2084 if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) == INVALID_SOCKET) {
2085 trace("Creating the socket failed: %d\n", WSAGetLastError());
2086 WSACleanup();
2087 return;
2088 }
2089
2090 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
2091 trace("Failed to bind socket: %d\n", WSAGetLastError());
2092 closesocket(sock);
2093 WSACleanup();
2094 return;
2095 }
2096
2097 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
2098
2099 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
2100 ok((optval == 65507) || (optval == 65527),
2101 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
2102
2103 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
2104 SetLastError(0xdeadbeef);
2105 optval = 0xdeadbeef;
2106 optlen = sizeof(int);
2107 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
2108 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
2109 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2110 ret, WSAGetLastError(), optval, optval);
2111
2112 /* more invalid values for level */
2113 SetLastError(0xdeadbeef);
2114 optval = 0xdeadbeef;
2115 optlen = sizeof(int);
2116 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
2117 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
2118 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2119 ret, WSAGetLastError(), optval, optval);
2120
2121 SetLastError(0xdeadbeef);
2122 optval = 0xdeadbeef;
2123 optlen = sizeof(int);
2124 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
2125 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
2126 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2127 ret, WSAGetLastError(), optval, optval);
2128
2129 SetLastError(0xdeadbeef);
2130 optval = 0xdeadbeef;
2131 optlen = sizeof(int);
2132 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
2133 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
2134 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2135 ret, WSAGetLastError(), optval, optval);
2136
2137 SetLastError(0xdeadbeef);
2138 optval = 0xdeadbeef;
2139 optlen = sizeof(int);
2140 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
2141 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
2142 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2143 ret, WSAGetLastError(), optval, optval);
2144
2145 optlen = sizeof(LINGER);
2146 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
2147 todo_wine{
2148 ok(ret == SOCKET_ERROR, "getsockopt should fail for UDP sockets but return value is 0x%08x\n", ret);
2149 }
2150
2151 closesocket(sock);
2152
2153 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
2154 trace("Creating the socket failed: %d\n", WSAGetLastError());
2155 WSACleanup();
2156 return;
2157 }
2158
2159 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
2160 trace("Failed to bind socket: %d\n", WSAGetLastError());
2161 closesocket(sock);
2162 WSACleanup();
2163 return;
2164 }
2165
2166 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
2167 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
2168
2169 optlen = sizeof(BOOL);
2170 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
2171 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
2172 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
2173 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
2174 bool_opt_val, linger_val.l_onoff);
2175
2176 closesocket(sock);
2177 WSACleanup();
2178 }
2179
2180 static void test_getsockname(void)
2181 {
2182 WSADATA wsa;
2183 SOCKET sock;
2184 struct sockaddr_in sa_set, sa_get;
2185 int sa_set_len = sizeof(struct sockaddr_in);
2186 int sa_get_len = sa_set_len;
2187 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
2188 int ret;
2189
2190 if(WSAStartup(MAKEWORD(2,0), &wsa)){
2191 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
2192 return;
2193 }
2194
2195 memset(&sa_set, 0, sa_set_len);
2196
2197 sa_set.sin_family = AF_INET;
2198 sa_set.sin_port = htons(0);
2199 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
2200
2201 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
2202 trace("Creating the socket failed: %d\n", WSAGetLastError());
2203 WSACleanup();
2204 return;
2205 }
2206
2207 memcpy(&sa_get, &sa_set, sizeof(sa_set));
2208 if (getsockname(sock, (struct sockaddr*) &sa_get, &sa_get_len) == 0)
2209 ok(0, "getsockname on unbound socket should fail\n");
2210 else {
2211 ok(WSAGetLastError() == WSAEINVAL, "getsockname on unbound socket "
2212 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL);
2213 ok(memcmp(&sa_get, &sa_set, sizeof(sa_get)) == 0,
2214 "failed getsockname modified sockaddr when it shouldn't\n");
2215 }
2216
2217 if(bind(sock, (struct sockaddr *) &sa_set, sa_set_len) < 0){
2218 trace("Failed to bind socket: %d\n", WSAGetLastError());
2219 closesocket(sock);
2220 WSACleanup();
2221 return;
2222 }
2223
2224 if(getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len) != 0){
2225 trace("Failed to call getsockname: %d\n", WSAGetLastError());
2226 closesocket(sock);
2227 WSACleanup();
2228 return;
2229 }
2230
2231 ret = memcmp(sa_get.sin_zero, null_padding, 8);
2232 ok(ret == 0 || broken(ret != 0), /* NT4 */
2233 "getsockname did not zero the sockaddr_in structure\n");
2234
2235 closesocket(sock);
2236 WSACleanup();
2237 }
2238
2239 static void test_dns(void)
2240 {
2241 struct hostent *h;
2242
2243 h = gethostbyname("");
2244 ok(h != NULL, "gethostbyname(\"\") failed with %d\n", h_errno);
2245 }
2246
2247 /* Our winsock headers don't define gethostname because it conflicts with the
2248 * definition in unistd.h. Define it here to get rid of the warning. */
2249
2250 int WINAPI gethostname(char *name, int namelen);
2251
2252 static void test_gethostbyname_hack(void)
2253 {
2254 struct hostent *he;
2255 char name[256];
2256 static BYTE loopback[] = {127, 0, 0, 1};
2257 static BYTE magic_loopback[] = {127, 12, 34, 56};
2258 int ret;
2259
2260 ret = gethostname(name, 256);
2261 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
2262
2263 he = gethostbyname("localhost");
2264 ok(he != NULL, "gethostbyname(\"localhost\") failed: %d\n", h_errno);
2265 if(he)
2266 {
2267 if(he->h_length != 4)
2268 {
2269 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
2270 return;
2271 }
2272
2273 ok(memcmp(he->h_addr_list[0], loopback, he->h_length) == 0,
2274 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
2275 he->h_addr_list[0][0], he->h_addr_list[0][1], he->h_addr_list[0][2],
2276 he->h_addr_list[0][3]);
2277 }
2278
2279 /* No reason to test further with NULL hostname */
2280 if(name == NULL)
2281 return;
2282
2283 if(strcmp(name, "localhost") == 0)
2284 {
2285 skip("hostname seems to be \"localhost\", skipping test.\n");
2286 return;
2287 }
2288
2289 he = NULL;
2290 he = gethostbyname(name);
2291 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, h_errno);
2292 if(he)
2293 {
2294 if(he->h_length != 4)
2295 {
2296 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
2297 return;
2298 }
2299
2300 if (he->h_addr_list[0][0] == 127)
2301 {
2302 ok(memcmp(he->h_addr_list[0], magic_loopback, he->h_length) == 0,
2303 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
2304 name, he->h_addr_list[0][0], he->h_addr_list[0][1],
2305 he->h_addr_list[0][2], he->h_addr_list[0][3]);
2306 }
2307 }
2308
2309 he = NULL;
2310 he = gethostbyname("nonexistent.winehq.org");
2311 /* Don't check for the return value, as some braindead ISPs will kindly
2312 * resolve nonexistent host names to addresses of the ISP's spam pages. */
2313 }
2314
2315 static void test_inet_addr(void)
2316 {
2317 u_long addr;
2318
2319 addr = inet_addr(NULL);
2320 ok(addr == INADDR_NONE, "inet_addr succeeded unexpectedly\n");
2321 }
2322
2323 static void test_ioctlsocket(void)
2324 {
2325 SOCKET sock;
2326 int ret;
2327 static const LONG cmds[] = {FIONBIO, FIONREAD, SIOCATMARK};
2328 UINT i;
2329 u_long arg = 0;
2330
2331 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
2332 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
2333 if(sock == INVALID_SOCKET)
2334 {
2335 skip("Can't continue without a socket.\n");
2336 return;
2337 }
2338
2339 for(i = 0; i < sizeof(cmds)/sizeof(cmds[0]); i++)
2340 {
2341 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
2342 ret = ioctlsocket(sock, cmds[i], (u_long *)1);
2343 ok(ret == SOCKET_ERROR, "ioctlsocket succeeded unexpectedly\n");
2344 ret = WSAGetLastError();
2345 ok(ret == WSAEFAULT, "expected WSAEFAULT, got %d instead\n", ret);
2346 }
2347
2348 /* A fresh and not connected socket has no urgent data, this test shows
2349 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
2350
2351 ret = ioctlsocket(sock, SIOCATMARK, &arg);
2352 if(ret != SOCKET_ERROR)
2353 todo_wine ok(arg, "expected a non-zero value\n");
2354 }
2355
2356 static int drain_pause=0;
2357 static DWORD WINAPI drain_socket_thread(LPVOID arg)
2358 {
2359 char buffer[1024];
2360 SOCKET sock = *(SOCKET*)arg;
2361 int ret;
2362
2363 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
2364 {
2365 if (ret < 0)
2366 {
2367 if (WSAGetLastError() == WSAEWOULDBLOCK)
2368 {
2369 fd_set readset;
2370 FD_ZERO(&readset);
2371 FD_SET(sock, &readset);
2372 select(0, &readset, NULL, NULL, NULL);
2373 while (drain_pause)
2374 Sleep(100);
2375 }
2376 else
2377 break;
2378 }
2379 }
2380 return 0;
2381 }
2382
2383 static void test_send(void)
2384 {
2385 SOCKET src = INVALID_SOCKET;
2386 SOCKET dst = INVALID_SOCKET;
2387 HANDLE hThread = NULL;
2388 const int buflen = 1024*1024;
2389 char *buffer = NULL;
2390 int ret;
2391 DWORD id;
2392
2393 if (tcp_socketpair(&src, &dst) != 0)
2394 {
2395 ok(0, "creating socket pair failed, skipping test\n");
2396 return;
2397 }
2398
2399 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
2400 if (hThread == NULL)
2401 {
2402 ok(0, "CreateThread failed, error %d\n", GetLastError());
2403 goto end;
2404 }
2405
2406 buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen);
2407 if (buffer == NULL)
2408 {
2409 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
2410 goto end;
2411 }
2412
2413 ret = send(src, buffer, buflen, 0);
2414 if (ret >= 0)
2415 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
2416 else
2417 ok(0, "send failed, error %d\n", WSAGetLastError());
2418
2419 end:
2420 if (src != INVALID_SOCKET)
2421 closesocket(src);
2422 if (dst != INVALID_SOCKET)
2423 closesocket(dst);
2424 if (hThread != NULL)
2425 CloseHandle(hThread);
2426 HeapFree(GetProcessHeap(), 0, buffer);
2427 }
2428
2429 typedef struct async_message
2430 {
2431 SOCKET socket;
2432 LPARAM lparam;
2433 struct async_message *next;
2434 } async_message;
2435
2436 static struct async_message *messages_received;
2437
2438 #define WM_SOCKET (WM_USER+100)
2439 static LRESULT CALLBACK ws2_test_WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
2440 {
2441 struct async_message *message;
2442
2443 switch (msg)
2444 {
2445 case WM_SOCKET:
2446 message = HeapAlloc(GetProcessHeap(), 0, sizeof(*message));
2447 message->socket = (SOCKET) wparam;
2448 message->lparam = lparam;
2449 message->next = NULL;
2450
2451 if (messages_received)
2452 {
2453 struct async_message *last = messages_received;
2454 while (last->next) last = last->next;
2455 last->next = message;
2456 }
2457 else
2458 messages_received = message;
2459 return 0;
2460 }
2461
2462 return DefWindowProc(hwnd, msg, wparam, lparam);
2463 }
2464
2465 static void get_event_details(int event, int *bit, char *name)
2466 {
2467 switch (event)
2468 {
2469 case FD_ACCEPT:
2470 if (bit) *bit = FD_ACCEPT_BIT;
2471 if (name) strcpy(name, "FD_ACCEPT");
2472 break;
2473 case FD_CONNECT:
2474 if (bit) *bit = FD_CONNECT_BIT;
2475 if (name) strcpy(name, "FD_CONNECT");
2476 break;
2477 case FD_READ:
2478 if (bit) *bit = FD_READ_BIT;
2479 if (name) strcpy(name, "FD_READ");
2480 break;
2481 case FD_OOB:
2482 if (bit) *bit = FD_OOB_BIT;
2483 if (name) strcpy(name, "FD_OOB");
2484 break;
2485 case FD_WRITE:
2486 if (bit) *bit = FD_WRITE_BIT;
2487 if (name) strcpy(name, "FD_WRITE");
2488 break;
2489 case FD_CLOSE:
2490 if (bit) *bit = FD_CLOSE_BIT;
2491 if (name) strcpy(name, "FD_CLOSE");
2492 break;
2493 default:
2494 if (bit) *bit = -1;
2495 if (name) sprintf(name, "bad%x", event);
2496 }
2497 }
2498
2499 static char *dbgstr_event_seq(const LPARAM *seq)
2500 {
2501 static char message[1024];
2502 char name[10];
2503
2504 message[0] = '[';
2505 message[1] = 0;
2506 while (*seq)
2507 {
2508 get_event_details(WSAGETSELECTEVENT(*seq), NULL, name);
2509
2510 sprintf(message, "%s%s%s(%d)", message, message[1] == 0 ? "" : " ",
2511 name, WSAGETSELECTERROR(*seq));
2512
2513 seq++;
2514 }
2515 strcat(message, "]");
2516 return message;
2517 }
2518
2519 static char *dbgstr_event_seq_result(SOCKET s, WSANETWORKEVENTS *netEvents)
2520 {
2521 static char message[1024];
2522 struct async_message *curr = messages_received;
2523 int index, error, bit = 0;
2524 char name[10];
2525
2526 message[0] = '[';
2527 message[1] = 0;
2528 while (1)
2529 {
2530 if (netEvents)
2531 {
2532 if (bit >= FD_MAX_EVENTS) break;
2533 if ( !(netEvents->lNetworkEvents & (1 << bit)) )
2534 {
2535 bit++;
2536 continue;
2537 }
2538 get_event_details(1 << bit, &index, name);
2539 error = netEvents->iErrorCode[index];
2540 bit++;
2541 }
2542 else
2543 {
2544 if (!curr) break;
2545 if (curr->socket != s)
2546 {
2547 curr = curr->next;
2548 continue;
2549 }
2550 get_event_details(WSAGETSELECTEVENT(curr->lparam), NULL, name);
2551 error = WSAGETSELECTERROR(curr->lparam);
2552 curr = curr->next;
2553 }
2554
2555 sprintf(message, "%s%s%s(%d)", message, message[1] == 0 ? "" : " ",
2556 name, error);
2557 }
2558 strcat(message, "]");
2559 return message;
2560 }
2561
2562 static void flush_events(SOCKET s, HANDLE hEvent)
2563 {
2564 WSANETWORKEVENTS netEvents;
2565 struct async_message *prev = NULL, *curr = messages_received;
2566 int ret;
2567 DWORD dwRet;
2568
2569 if (hEvent != INVALID_HANDLE_VALUE)
2570 {
2571 dwRet = WaitForSingleObject(hEvent, 100);
2572 if (dwRet == WAIT_OBJECT_0)
2573 {
2574 ret = WSAEnumNetworkEvents(s, hEvent, &netEvents);
2575 if (ret)
2576 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
2577 }
2578 }
2579 else
2580 {
2581 while (curr)
2582 {
2583 if (curr->socket == s)
2584 {
2585 if (prev) prev->next = curr->next;
2586 else messages_received = curr->next;
2587
2588 HeapFree(GetProcessHeap(), 0, curr);
2589
2590 if (prev) curr = prev->next;
2591 else curr = messages_received;
2592 }
2593 else
2594 {
2595 prev = curr;
2596 curr = curr->next;
2597 }
2598 }
2599 }
2600 }
2601
2602 static int match_event_sequence(SOCKET s, WSANETWORKEVENTS *netEvents, const LPARAM *seq)
2603 {
2604 int event, index, error, events;
2605 struct async_message *curr;
2606
2607 if (netEvents)
2608 {
2609 events = netEvents->lNetworkEvents;
2610 while (*seq)
2611 {
2612 event = WSAGETSELECTEVENT(*seq);
2613 error = WSAGETSELECTERROR(*seq);
2614 get_event_details(event, &index, NULL);
2615
2616 if (!(events & event) && index != -1)
2617 return 0;
2618 if (events & event && index != -1)
2619 {
2620 if (netEvents->iErrorCode[index] != error)
2621 return 0;
2622 }
2623 events &= ~event;
2624 seq++;
2625 }
2626 if (events)
2627 return 0;
2628 }
2629 else
2630 {
2631 curr = messages_received;
2632 while (curr)
2633 {
2634 if (curr->socket == s)
2635 {
2636 if (!*seq) return 0;
2637 if (*seq != curr->lparam) return 0;
2638 seq++;
2639 }
2640 curr = curr->next;
2641 }
2642 if (*seq)
2643 return 0;
2644 }
2645 return 1;
2646 }
2647
2648 /* checks for a sequence of events, (order only checked if window is used) */
2649 static void ok_event_sequence(SOCKET s, HANDLE hEvent, const LPARAM *seq, const LPARAM **broken_seqs, int completelyBroken)
2650 {
2651 MSG msg;
2652 WSANETWORKEVENTS events, *netEvents = NULL;
2653 int ret;
2654 DWORD dwRet;
2655
2656 if (hEvent != INVALID_HANDLE_VALUE)
2657 {
2658 netEvents = &events;
2659
2660 dwRet = WaitForSingleObject(hEvent, 200);
2661 if (dwRet == WAIT_OBJECT_0)
2662 {
2663 ret = WSAEnumNetworkEvents(s, hEvent, netEvents);
2664 if (ret)
2665 {
2666 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
2667 return;
2668 }
2669 }
2670 else
2671 memset(netEvents, 0, sizeof(*netEvents));
2672 }
2673 else
2674 {
2675 Sleep(200);
2676 /* Run the message loop a little */
2677 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
2678 {
2679 DispatchMessageA(&msg);
2680 }
2681 }
2682
2683 if (match_event_sequence(s, netEvents, seq))
2684 {
2685 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq));
2686 flush_events(s, hEvent);
2687 return;
2688 }
2689
2690 if (broken_seqs)
2691 {
2692 for (; *broken_seqs; broken_seqs++)
2693 {
2694 if (match_event_sequence(s, netEvents, *broken_seqs))
2695 {
2696 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s, netEvents), dbgstr_event_seq(seq));
2697 flush_events(s, hEvent);
2698 return;
2699 }
2700 }
2701 }
2702
2703 winetest_ok(broken(completelyBroken), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq),
2704 dbgstr_event_seq_result(s, netEvents));
2705 flush_events(s, hEvent);
2706 }
2707
2708 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
2709
2710 static void test_events(int useMessages)
2711 {
2712 SOCKET server = INVALID_SOCKET;
2713 SOCKET src = INVALID_SOCKET, src2 = INVALID_SOCKET;
2714 SOCKET dst = INVALID_SOCKET, dst2 = INVALID_SOCKET;
2715 struct sockaddr_in addr;
2716 HANDLE hThread = NULL;
2717 HANDLE hEvent = INVALID_HANDLE_VALUE, hEvent2 = INVALID_HANDLE_VALUE;
2718 WNDCLASSEX wndclass;
2719 HWND hWnd = NULL;
2720 char *buffer = NULL;
2721 int bufferSize = 1024*1024;
2722 WSABUF bufs;
2723 OVERLAPPED ov, ov2;
2724 DWORD flags = 0;
2725 DWORD bytesReturned;
2726 DWORD id;
2727 int len;
2728 int ret;
2729 DWORD dwRet;
2730 BOOL bret;
2731 static char szClassName[] = "wstestclass";
2732 const LPARAM *broken_seq[3];
2733 static const LPARAM empty_seq[] = { 0 };
2734 static const LPARAM close_seq[] = { WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
2735 static const LPARAM write_seq[] = { WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
2736 static const LPARAM read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0), 0 };
2737 static const LPARAM oob_seq[] = { WSAMAKESELECTREPLY(FD_OOB, 0), 0 };
2738 static const LPARAM connect_seq[] = { WSAMAKESELECTREPLY(FD_CONNECT, 0),
2739 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
2740 static const LPARAM read_read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
2741 WSAMAKESELECTREPLY(FD_READ, 0), 0 };
2742 static const LPARAM read_write_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
2743 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
2744 static const LPARAM read_close_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
2745 WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
2746
2747 memset(&ov, 0, sizeof(ov));
2748 memset(&ov2, 0, sizeof(ov2));
2749
2750 /* don't use socketpair, we want connection event */
2751 src = socket(AF_INET, SOCK_STREAM, 0);
2752 if (src == INVALID_SOCKET)
2753 {
2754 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2755 goto end;
2756 }
2757
2758 src2 = socket(AF_INET, SOCK_STREAM, 0);
2759 if (src2 == INVALID_SOCKET)
2760 {
2761 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2762 goto end;
2763 }
2764
2765 len = sizeof(BOOL);
2766 if (getsockopt(src, SOL_SOCKET, SO_OOBINLINE, (void *)&bret, &len) == SOCKET_ERROR)
2767 {
2768 ok(0, "failed to get oobinline status, %d\n", GetLastError());
2769 goto end;
2770 }
2771 ok(bret == FALSE, "OOB not inline\n");
2772
2773 if (useMessages)
2774 {
2775 trace("Event test using messages\n");
2776
2777 wndclass.cbSize = sizeof(wndclass);
2778 wndclass.style = CS_HREDRAW | CS_VREDRAW;
2779 wndclass.lpfnWndProc = ws2_test_WndProc;
2780 wndclass.cbClsExtra = 0;
2781 wndclass.cbWndExtra = 0;
2782 wndclass.hInstance = GetModuleHandle(NULL);
2783 wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
2784 wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
2785 wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
2786 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
2787 wndclass.lpszClassName = szClassName;
2788 wndclass.lpszMenuName = NULL;
2789 RegisterClassEx(&wndclass);
2790
2791 hWnd = CreateWindow(szClassName, "WS2Test", WS_OVERLAPPEDWINDOW, 0, 0, 500, 500, NULL, NULL, GetModuleHandle(NULL), NULL);
2792 if (!hWnd)
2793 {
2794 ok(0, "failed to create window: %d\n", GetLastError());
2795 return;
2796 }
2797
2798 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
2799 if (ret)
2800 {
2801 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
2802 goto end;
2803 }
2804
2805 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
2806 if (ret)
2807 {
2808 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
2809 goto end;
2810 }
2811 }
2812 else
2813 {
2814 trace("Event test using events\n");
2815
2816 hEvent = WSACreateEvent();
2817 if (hEvent == INVALID_HANDLE_VALUE)
2818 {
2819 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
2820 goto end;
2821 }
2822
2823 hEvent2 = WSACreateEvent();
2824 if (hEvent2 == INVALID_HANDLE_VALUE)
2825 {
2826 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
2827 goto end;
2828 }
2829
2830 ret = WSAEventSelect(src, hEvent, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
2831 if (ret)
2832 {
2833 ok(0, "WSAEventSelect failed, error %d\n", ret);
2834 goto end;
2835 }
2836
2837 ret = WSAEventSelect(src2, hEvent2, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
2838 if (ret)
2839 {
2840 ok(0, "WSAEventSelect failed, error %d\n", ret);
2841 goto end;
2842 }
2843 }
2844
2845 server = socket(AF_INET, SOCK_STREAM, 0);
2846 if (server == INVALID_SOCKET)
2847 {
2848 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2849 goto end;
2850 }
2851
2852 memset(&addr, 0, sizeof(addr));
2853 addr.sin_family = AF_INET;
2854 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2855 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
2856 if (ret != 0)
2857 {
2858 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2859 goto end;
2860 }
2861
2862 len = sizeof(addr);
2863 ret = getsockname(server, (struct sockaddr*)&addr, &len);
2864 if (ret != 0)
2865 {
2866 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2867 goto end;
2868 }
2869
2870 ret = listen(server, 2);
2871 if (ret != 0)
2872 {
2873 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2874 goto end;
2875 }
2876
2877 ret = connect(src, (struct sockaddr*)&addr, sizeof(addr));
2878 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
2879 {
2880 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2881 goto end;
2882 }
2883
2884 ret = connect(src2, (struct sockaddr*)&addr, sizeof(addr));
2885 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
2886 {
2887 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2888 goto end;
2889 }
2890
2891 len = sizeof(addr);
2892 dst = accept(server, (struct sockaddr*)&addr, &len);
2893 if (dst == INVALID_SOCKET)
2894 {
2895 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2896 goto end;
2897 }
2898
2899 len = sizeof(addr);
2900 dst2 = accept(server, (struct sockaddr*)&addr, &len);
2901 if (dst2 == INVALID_SOCKET)
2902 {
2903 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2904 goto end;
2905 }
2906
2907 closesocket(server);
2908 server = INVALID_SOCKET;
2909
2910 /* On Windows it seems when a non-blocking socket sends to a
2911 blocking socket on the same host, the send() is BLOCKING,
2912 so make both sockets non-blocking. src is already non-blocking
2913 from the async select */
2914
2915 if (set_blocking(dst, FALSE))
2916 {
2917 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
2918 goto end;
2919 }
2920
2921 buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufferSize);
2922 if (buffer == NULL)
2923 {
2924 ok(0, "could not allocate memory for test\n");
2925 goto end;
2926 }
2927
2928 ov.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
2929 if (ov.hEvent == NULL)
2930 {
2931 ok(0, "could not create event object, errno = %d\n", GetLastError());
2932 goto end;
2933 }
2934
2935 ov2.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
2936 if (ov2.hEvent == NULL)
2937 {
2938 ok(0, "could not create event object, errno = %d\n", GetLastError());
2939 goto end;
2940 }
2941
2942 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
2943 ok_event_seq(src, hEvent, connect_seq, NULL, 1);
2944 ok_event_seq(src2, hEvent2, connect_seq, NULL, 1);
2945 /* broken on all windows - FD_CONNECT error is garbage */
2946
2947 /* Test simple send/recv */
2948 ret = send(dst, buffer, 100, 0);
2949 ok(ret == 100, "Failed to send buffer %d err %d\n", ret, GetLastError());
2950 ok_event_seq(src, hEvent, read_seq, NULL, 0);
2951
2952 ret = recv(src, buffer, 50, 0);
2953 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
2954 ok_event_seq(src, hEvent, read_seq, NULL, 0);
2955
2956 ret = recv(src, buffer, 50, 0);
2957 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
2958 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
2959
2960 /* fun fact - events are reenabled even on failure, but only for messages */
2961 ret = send(dst, "1", 1, 0);
2962 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
2963 ok_event_seq(src, hEvent, read_seq, NULL, 0);
2964
2965 ret = recv(src, buffer, -1, 0);
2966 ok(ret == SOCKET_ERROR && (GetLastError() == WSAEFAULT || GetLastError() == WSAENOBUFS),
2967 "Failed to recv buffer %d err %d\n", ret, GetLastError());
2968 if (useMessages)
2969 {
2970 broken_seq[0] = empty_seq; /* win9x */
2971 broken_seq[1] = NULL;
2972 todo_wine ok_event_seq(src, hEvent, read_seq, broken_seq, 0);
2973 }
2974 else
2975 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
2976
2977 ret = recv(src, buffer, 1, 0);
2978 ok(ret == 1, "Failed to recv buffer %d err %d\n", ret, GetLastError());
2979 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
2980
2981 /* Interaction with overlapped */
2982 bufs.len = sizeof(char);
2983 bufs.buf = buffer;
2984 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
2985 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
2986 "WSARecv failed - %d error %d\n", ret, GetLastError());
2987
2988 bufs.len = sizeof(char);
2989 bufs.buf = buffer+1;
2990 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov2, NULL);
2991 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
2992 "WSARecv failed - %d error %d\n", ret, GetLastError());
2993
2994 ret = send(dst, "12", 2, 0);
2995 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
2996 broken_seq[0] = read_read_seq; /* win9x */
2997 broken_seq[1] = NULL;
2998 /* we like to erase pmask in server, so we have varying behavior here *
2999 * it is only fixed for now because we refuse to send notifications with
3000 * any kind of asyncs requests running */
3001 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
3002
3003 dwRet = WaitForSingleObject(ov.hEvent, 100);
3004 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
3005 if (dwRet == WAIT_OBJECT_0)
3006 {
3007 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
3008 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
3009 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
3010 ok(buffer[0] == '1', "Got %c instead of 1\n", buffer[0]);
3011 }
3012
3013 dwRet = WaitForSingleObject(ov2.hEvent, 100);
3014 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
3015 if (dwRet == WAIT_OBJECT_0)
3016 {
3017 bret = GetOverlappedResult((HANDLE)src, &ov2, &bytesReturned, FALSE);
3018 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
3019 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
3020 ok(buffer[1] == '2', "Got %c instead of 2\n", buffer[1]);
3021 }
3022
3023 ret = send(dst, "1", 1, 0);
3024 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
3025 ok_event_seq(src, hEvent, read_seq, NULL, 0);
3026
3027 ret = recv(src, buffer, 1, 0);
3028 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3029 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
3030
3031 /* Notifications are delivered as soon as possible, blocked only on
3032 * async requests on the same type */
3033 bufs.len = sizeof(char);
3034 bufs.buf = buffer;
3035 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
3036 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
3037 "WSARecv failed - %d error %d\n", ret, GetLastError());
3038
3039 if (0) {
3040 ret = send(dst, "1", 1, MSG_OOB);
3041 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
3042 ok_event_seq(src, hEvent, oob_seq, NULL, 0);
3043 }
3044
3045 dwRet = WaitForSingleObject(ov.hEvent, 100);
3046 ok(dwRet == WAIT_TIMEOUT, "OOB message activated read?: %d - %d\n", dwRet, GetLastError());
3047
3048 ret = send(dst, "2", 1, 0);
3049 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
3050 broken_seq[0] = read_seq; /* win98 */
3051 broken_seq[1] = NULL;
3052 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
3053
3054 dwRet = WaitForSingleObject(ov.hEvent, 100);
3055 ok(dwRet == WAIT_OBJECT_0 || broken(dwRet == WAIT_TIMEOUT),
3056 "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
3057 if (dwRet == WAIT_OBJECT_0)
3058 {
3059 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
3060 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
3061 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
3062 ok(buffer[0] == '2', "Got %c instead of 2\n", buffer[1]);
3063 }
3064 else if (dwRet == WAIT_TIMEOUT)
3065 {
3066 /* this happens on win98. We get an FD_READ later on the next test */
3067 CancelIo((HANDLE) src);
3068 }
3069
3070 if (0) {
3071 ret = recv(src, buffer, 1, MSG_OOB);
3072 todo_wine ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3073 /* We get OOB notification, but no data on wine */
3074 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
3075 }
3076
3077 /* wine gets a stale notifications because of the async ops, clear them.
3078 * remove when sending messages during pending asyncs is fixed */
3079 ret = send(dst, "2", 1, 0);
3080 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
3081 ok_event_seq(src, hEvent, read_seq, NULL, 0);
3082
3083 ret = recv(src, buffer, 1, 0);
3084 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3085 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
3086
3087 /* Flood the send queue */
3088 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
3089 if (hThread == NULL)
3090 {
3091 ok(0, "CreateThread failed, error %d\n", GetLastError());
3092 goto end;
3093 }
3094
3095 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
3096 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
3097
3098 /* Now if we send a ton of data and the 'server' does not drain it fast
3099 * enough (set drain_pause to be sure), the socket send buffer will only
3100 * take some of it, and we will get a short write. This will trigger
3101 * another FD_WRITE event as soon as data is sent and more space becomes
3102 * available, but not any earlier. */
3103 drain_pause=1;
3104 do
3105 {
3106 ret = send(src, buffer, bufferSize, 0);
3107 } while (ret == bufferSize);
3108 drain_pause=0;
3109 if (ret >= 0 || WSAGetLastError() == WSAEWOULDBLOCK)
3110 {
3111 Sleep(400); /* win9x */
3112 broken_seq[0] = read_write_seq;
3113 broken_seq[1] = NULL;
3114 ok_event_seq(src, hEvent, write_seq, broken_seq, 0);
3115 }
3116 else
3117 {
3118 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
3119 }
3120
3121 /* Test how FD_CLOSE is handled */
3122 ret = send(dst, "12", 2, 0);
3123 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
3124
3125 /* Wait a little and let the send complete */
3126 Sleep(100);
3127 closesocket(dst);
3128 dst = INVALID_SOCKET;
3129 Sleep(100);
3130
3131 /* We can never implement this in wine, best we can hope for is
3132 sending FD_CLOSE after the reads complete */
3133 broken_seq[0] = read_seq; /* win9x */
3134 broken_seq[1] = NULL;
3135 todo_wine ok_event_seq(src, hEvent, read_close_seq, broken_seq, 0);
3136
3137 ret = recv(src, buffer, 1, 0);
3138 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3139 ok_event_seq(src, hEvent, read_seq, NULL, 0);
3140
3141 ret = recv(src, buffer, 1, 0);
3142 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3143 /* want it? it's here, but you can't have it */
3144 broken_seq[0] = close_seq; /* win9x */
3145 broken_seq[1] = NULL;
3146 todo_wine ok_event_seq(src, hEvent, empty_seq, /* wine sends FD_CLOSE here */
3147 broken_seq, 0);
3148
3149 /* Test how FD_CLOSE is handled */
3150 ret = send(dst2, "12", 2, 0);
3151 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
3152
3153 Sleep(200);
3154 shutdown(dst2, SD_SEND);
3155 Sleep(200);
3156
3157 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
3158 regressions, don't mark them as todo_wine, and mark windows as broken */
3159 broken_seq[0] = read_close_seq;
3160 broken_seq[1] = close_seq;
3161 broken_seq[2] = NULL;
3162 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
3163
3164 ret = recv(src2, buffer, 1, 0);
3165 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3166 broken_seq[0] = close_seq; /* win98 */
3167 broken_seq[1] = NULL;
3168 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
3169
3170 ret = recv(src2, buffer, 1, 0);
3171 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3172 broken_seq[0] = empty_seq;
3173 broken_seq[1] = NULL;
3174 ok_event_seq(src2, hEvent2, close_seq, broken_seq, 0);
3175
3176 ret = send(src2, "1", 1, 0);
3177 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
3178 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
3179
3180 ret = send(src2, "1", 1, 0);
3181 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
3182 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
3183
3184 end:
3185 if (src != INVALID_SOCKET)
3186 {
3187 flush_events(src, hEvent);
3188 closesocket(src);
3189 }
3190 if (src2 != INVALID_SOCKET)
3191 {
3192 flush_events(src2, hEvent2);
3193 closesocket(src2);
3194 }
3195 HeapFree(GetProcessHeap(), 0, buffer);
3196 if (server != INVALID_SOCKET)
3197 closesocket(server);
3198 if (dst != INVALID_SOCKET)
3199 closesocket(dst);
3200 if (dst2 != INVALID_SOCKET)
3201 closesocket(dst2);
3202 if (hThread != NULL)
3203 CloseHandle(hThread);
3204 if (hWnd != NULL)
3205 CloseHandle(hWnd);
3206 if (hEvent != NULL)
3207 CloseHandle(hEvent);
3208 if (hEvent2 != NULL)
3209 CloseHandle(hEvent2);
3210 if (ov.hEvent != NULL)
3211 CloseHandle(ov.hEvent);
3212 if (ov2.hEvent != NULL)
3213 CloseHandle(ov2.hEvent);
3214 }
3215
3216 static void test_ipv6only(void)
3217 {
3218 SOCKET v4 = INVALID_SOCKET,
3219 v6 = INVALID_SOCKET;
3220 struct sockaddr_in sin4;
3221 struct sockaddr_in6 sin6;
3222 int ret;
3223
3224 memset(&sin4, 0, sizeof(sin4));
3225 sin4.sin_family = AF_INET;
3226 sin4.sin_port = htons(SERVERPORT);
3227
3228 memset(&sin6, 0, sizeof(sin6));
3229 sin6.sin6_family = AF_INET6;
3230 sin6.sin6_port = htons(SERVERPORT);
3231
3232 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
3233 if (v6 == INVALID_SOCKET) {
3234 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3235 WSAGetLastError(), WSAEAFNOSUPPORT);
3236 goto end;
3237 }
3238 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
3239 if (ret) {
3240 skip("Could not bind IPv6 address (LastError: %d).\n",
3241 WSAGetLastError());
3242 goto end;
3243 }
3244
3245 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3246 if (v4 == INVALID_SOCKET) {
3247 skip("Could not create IPv4 socket (LastError: %d).\n",
3248 WSAGetLastError());
3249 goto end;
3250 }
3251 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
3252 ok(!ret, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
3253 WSAGetLastError(), WSAEADDRINUSE);
3254
3255 end:
3256 if (v4 != INVALID_SOCKET)
3257 closesocket(v4);
3258 if (v6 != INVALID_SOCKET)
3259 closesocket(v6);
3260 }
3261
3262 static void test_WSASendTo(void)
3263 {
3264 SOCKET s;
3265 struct sockaddr_in addr;
3266 char buf[12] = "hello world";
3267 WSABUF data_buf;
3268 DWORD bytesSent;
3269
3270 addr.sin_family = AF_INET;
3271 addr.sin_port = htons(139);
3272 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3273 data_buf.len = sizeof(buf);
3274 data_buf.buf = buf;
3275
3276 if( (s = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
3277 ok(0, "socket() failed error: %d\n", WSAGetLastError());
3278 return;
3279 }
3280
3281 WSASetLastError(12345);
3282 if(WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL)) {
3283 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
3284 return;
3285 }
3286 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
3287 "a successful call to WSASendTo()\n");
3288 }
3289
3290 static void test_WSARecv(void)
3291 {
3292 SOCKET src, dest;
3293 char buf[20];
3294 WSABUF bufs;
3295 WSAOVERLAPPED ov;
3296 DWORD bytesReturned;
3297 DWORD flags;
3298 struct linger ling;
3299 int iret;
3300 DWORD dwret;
3301 BOOL bret;
3302
3303 tcp_socketpair(&src, &dest);
3304 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
3305 {
3306 skip("failed to create sockets\n");
3307 goto end;
3308 }
3309
3310 bufs.len = sizeof(buf);
3311 bufs.buf = buf;
3312 flags = 0;
3313
3314 memset(&ov, 0, sizeof(ov));
3315 ov.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
3316 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
3317 if (!ov.hEvent)
3318 goto end;
3319
3320 ling.l_onoff = 1;
3321 ling.l_linger = 0;
3322 ok(!setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling)), "Failed to set linger %d\n", GetLastError());
3323
3324 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
3325 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
3326
3327 closesocket(src);
3328 src = INVALID_SOCKET;
3329
3330 dwret = WaitForSingleObject(ov.hEvent, 1000);
3331 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %d + errno %d\n", dwret, GetLastError());
3332
3333 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
3334 todo_wine ok(!bret && (GetLastError() == ERROR_NETNAME_DELETED || broken(GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */),
3335 "Did not get disconnect event: %d, error %d\n", bret, GetLastError());
3336 ok(bytesReturned == 0, "Bytes received is %d\n", bytesReturned);
3337
3338 end:
3339 if (dest != INVALID_SOCKET)
3340 closesocket(dest);
3341 if (src != INVALID_SOCKET)
3342 closesocket(src);
3343 if (ov.hEvent)
3344 WSACloseEvent(ov.hEvent);
3345 }
3346
3347 static void test_GetAddrInfoW(void)
3348 {
3349 static const WCHAR port[] = {'8','0',0};
3350 static const WCHAR empty[] = {0};
3351 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
3352
3353 int ret;
3354 ADDRINFOW *result, hint;
3355
3356 if (!pGetAddrInfoW || !pFreeAddrInfoW)
3357 {
3358 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
3359 return;
3360 }
3361
3362 memset(&hint, 0, sizeof(ADDRINFOW));
3363
3364 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
3365 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
3366
3367 result = NULL;
3368 ret = pGetAddrInfoW(empty, NULL, NULL, &result);
3369 todo_wine
3370 {
3371 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3372 ok(result != NULL, "GetAddrInfoW failed\n");
3373 }
3374 pFreeAddrInfoW(result);
3375
3376 ret = pGetAddrInfoW(localhost, NULL, NULL, &result);
3377 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3378 pFreeAddrInfoW(result);
3379
3380 ret = pGetAddrInfoW(localhost, port, NULL, &result);
3381 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3382 pFreeAddrInfoW(result);
3383
3384 ret = pGetAddrInfoW(localhost, port, &hint, &result);
3385 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3386 pFreeAddrInfoW(result);
3387 }
3388
3389 static void test_AcceptEx(void)
3390 {
3391 SOCKET listener = INVALID_SOCKET;
3392 SOCKET acceptor = INVALID_SOCKET;
3393 SOCKET connector = INVALID_SOCKET;
3394 SOCKET connector2 = INVALID_SOCKET;
3395 struct sockaddr_in bindAddress;
3396 int socklen;
3397 GUID acceptExGuid = WSAID_ACCEPTEX;
3398 LPFN_ACCEPTEX pAcceptEx = NULL;
3399 fd_set fds_accept, fds_send;
3400 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
3401 int got, conn1, i;
3402 DWORD bytesReturned;
3403 char buffer[1024];
3404 OVERLAPPED overlapped;
3405 int iret;
3406 BOOL bret;
3407 DWORD dwret;
3408
3409 memset(&overlapped, 0, sizeof(overlapped));
3410
3411 listener = socket(AF_INET, SOCK_STREAM, 0);
3412 if (listener == INVALID_SOCKET) {
3413 skip("could not create listener socket, error %d\n", WSAGetLastError());
3414 goto end;
3415 }
3416
3417 acceptor = socket(AF_INET, SOCK_STREAM, 0);
3418 if (acceptor == INVALID_SOCKET) {
3419 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3420 goto end;
3421 }
3422
3423 connector = socket(AF_INET, SOCK_STREAM, 0);
3424 if (connector == INVALID_SOCKET) {
3425 skip("could not create connector socket, error %d\n", WSAGetLastError());
3426 goto end;
3427 }
3428
3429 memset(&bindAddress, 0, sizeof(bindAddress));
3430 bindAddress.sin_family = AF_INET;
3431 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
3432 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3433 if (iret != 0) {
3434 skip("failed to bind, error %d\n", WSAGetLastError());
3435 goto end;
3436 }
3437
3438 socklen = sizeof(bindAddress);
3439 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
3440 if (iret != 0) {
3441 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
3442 goto end;
3443 }
3444
3445 if (set_blocking(listener, FALSE)) {
3446 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
3447 goto end;
3448 }
3449
3450 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
3451 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
3452 if (iret) {
3453 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
3454 goto end;
3455 }
3456
3457 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3458 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3459 &bytesReturned, &overlapped);
3460 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
3461 "returned %d + errno %d\n", bret, WSAGetLastError());
3462
3463 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3464 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3465 &bytesReturned, &overlapped);
3466 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on invalid accepting socket "
3467 "returned %d + errno %d\n", bret, WSAGetLastError());
3468
3469 bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3470 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3471 &bytesReturned, &overlapped);
3472 ok(bret == FALSE &&
3473 (WSAGetLastError() == WSAEINVAL ||
3474 broken(WSAGetLastError() == WSAEFAULT)), /* NT4 */
3475 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
3476
3477 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
3478 &bytesReturned, &overlapped);
3479 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on too small local address size "
3480 "returned %d + errno %d\n", bret, WSAGetLastError());
3481
3482 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
3483 &bytesReturned, &overlapped);
3484 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on too small remote address size "
3485 "returned %d + errno %d\n", bret, WSAGetLastError());
3486
3487 bret = pAcceptEx(listener, acceptor, buffer, 0,
3488 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3489 &bytesReturned, NULL);
3490 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
3491 "returned %d + errno %d\n", bret, WSAGetLastError());
3492
3493 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3494 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3495 &bytesReturned, &overlapped);
3496 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
3497 "returned %d + errno %d\n", bret, WSAGetLastError());
3498
3499 iret = listen(listener, 5);
3500 if (iret != 0) {
3501 skip("listening failed, errno = %d\n", WSAGetLastError());
3502 goto end;
3503 }
3504
3505 overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
3506 if (overlapped.hEvent == NULL) {
3507 skip("could not create event object, errno = %d\n", GetLastError());
3508 goto end;
3509 }
3510
3511 bret = pAcceptEx(listener, acceptor, buffer, 0,
3512 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3513 &bytesReturned, &overlapped);
3514 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3515
3516 bret = pAcceptEx(listener, acceptor, buffer, 0,
3517 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3518 &bytesReturned, &overlapped);
3519 ok((bret == FALSE && WSAGetLastError() == WSAEINVAL) || broken(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) /* NT4 */,
3520 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
3521 if (bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) {
3522 /* We need to cancel this call, otherwise things fail */
3523 bret = CancelIo((HANDLE) listener);
3524 ok(bret, "Failed to cancel failed test. Bailing...\n");
3525 if (!bret) return;
3526
3527 bret = pAcceptEx(listener, acceptor, buffer, 0,
3528 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3529 &bytesReturned, &overlapped);
3530 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3531 }
3532
3533 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3534 ok((iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL) || broken(!iret) /* NT4 */,
3535 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
3536 if (!iret || (iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)) {
3537 /* We need to cancel this call, otherwise things fail */
3538 closesocket(acceptor);
3539 acceptor = socket(AF_INET, SOCK_STREAM, 0);
3540 if (acceptor == INVALID_SOCKET) {
3541 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3542 goto end;
3543 }
3544
3545 bret = CancelIo((HANDLE) listener);
3546 ok(bret, "Failed to cancel failed test. Bailing...\n");
3547 if (!bret) return;
3548
3549 bret = pAcceptEx(listener, acceptor, buffer, 0,
3550 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3551 &bytesReturned, &overlapped);
3552 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3553 }
3554
3555 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3556 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
3557
3558 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
3559 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
3560
3561 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
3562 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
3563 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
3564
3565 closesocket(connector);
3566 connector = INVALID_SOCKET;
3567 closesocket(acceptor);
3568 acceptor = INVALID_SOCKET;
3569
3570 /* Test short reads */
3571
3572 acceptor = socket(AF_INET, SOCK_STREAM, 0);
3573 if (acceptor == INVALID_SOCKET) {
3574 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3575 goto end;
3576 }
3577 connector = socket(AF_INET, SOCK_STREAM, 0);
3578 if (connector == INVALID_SOCKET) {
3579 skip("could not create connector socket, error %d\n", WSAGetLastError());
3580 goto end;
3581 }
3582 bret = pAcceptEx(listener, acceptor, buffer, 2,
3583 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3584 &bytesReturned, &overlapped);
3585 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3586
3587 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3588 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
3589
3590 dwret = WaitForSingleObject(overlapped.hEvent, 0);
3591 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %d + errno %d\n", dwret, GetLastError());
3592
3593 iret = send(connector, buffer, 1, 0);
3594 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
3595
3596 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
3597 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
3598
3599 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
3600 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
3601 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %d\n", bytesReturned);
3602
3603 closesocket(connector);
3604 connector = INVALID_SOCKET;
3605 closesocket(acceptor);
3606 acceptor = INVALID_SOCKET;
3607
3608 /* Test CF_DEFER & AcceptEx interaction */
3609
3610 acceptor = socket(AF_INET, SOCK_STREAM, 0);
3611 if (acceptor == INVALID_SOCKET) {
3612 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3613 goto end;
3614 }
3615 connector = socket(AF_INET, SOCK_STREAM, 0);
3616 if (connector == INVALID_SOCKET) {
3617 skip("could not create connector socket, error %d\n", WSAGetLastError());
3618 goto end;
3619 }
3620 connector2 = socket(AF_INET, SOCK_STREAM, 0);
3621 if (connector == INVALID_SOCKET) {
3622 skip("could not create connector socket, error %d\n", WSAGetLastError());
3623 goto end;
3624 }
3625
3626 if (set_blocking(connector, FALSE)) {
3627 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
3628 goto end;
3629 }
3630
3631 if (set_blocking(connector2, FALSE)) {
3632 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
3633 goto end;
3634 }
3635
3636 /* Connect socket #1 */
3637 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3638 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
3639
3640 FD_ZERO ( &fds_accept );
3641 FD_ZERO ( &fds_send );
3642
3643 FD_SET ( listener, &fds_accept );
3644 FD_SET ( connector, &fds_send );
3645
3646 buffer[0] = '0';
3647 got = 0;
3648 conn1 = 0;
3649
3650 for (i = 0; i < 4000; ++i)
3651 {
3652 fd_set fds_openaccept = fds_accept, fds_opensend = fds_send;
3653
3654 wsa_ok ( ( select ( 0, &fds_openaccept, &fds_opensend, NULL, &timeout ) ), SOCKET_ERROR !=,
3655 "acceptex test(%d): could not select on socket, errno %d\n" );
3656
3657 /* check for incoming requests */
3658 if ( FD_ISSET ( listener, &fds_openaccept ) ) {
3659 got++;
3660 if (got == 1) {
3661 SOCKET tmp = WSAAccept(listener, NULL, NULL, (LPCONDITIONPROC) AlwaysDeferConditionFunc, 0);
3662 ok(tmp == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
3663 bret = pAcceptEx(listener, acceptor, buffer, 0,
3664 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3665 &bytesReturned, &overlapped);
3666 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3667 }
3668 else if (got == 2) {
3669 /* this should be socket #2 */
3670 SOCKET tmp = accept(listener, NULL, NULL);
3671 ok(tmp != INVALID_SOCKET, "accept failed %d\n", WSAGetLastError());
3672 closesocket(tmp);
3673 }
3674 else {
3675 ok(FALSE, "Got more than 2 connections?\n");
3676 }
3677 }
3678 if ( conn1 && FD_ISSET ( connector2, &fds_opensend ) ) {
3679 /* Send data on second socket, and stop */
3680 send(connector2, "2", 1, 0);
3681 FD_CLR ( connector2, &fds_send );
3682
3683 break;
3684 }
3685 if ( FD_ISSET ( connector, &fds_opensend ) ) {
3686 /* Once #1 is connected, allow #2 to connect */
3687 conn1 = 1;
3688
3689 send(connector, "1", 1, 0);
3690 FD_CLR ( connector, &fds_send );
3691
3692 iret = connect(connector2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3693 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
3694 FD_SET ( connector2, &fds_send );
3695 }
3696 }
3697
3698 ok (got == 2 || broken(got == 1) /* NT4 */,
3699 "Did not get both connections, got %d\n", got);
3700
3701 dwret = WaitForSingleObject(overlapped.hEvent, 0);
3702 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
3703
3704 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
3705 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
3706 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
3707
3708 set_blocking(acceptor, TRUE);
3709 iret = recv( acceptor, buffer, 2, 0);
3710 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
3711
3712 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
3713
3714 closesocket(connector);
3715 connector = INVALID_SOCKET;
3716 closesocket(acceptor);
3717 acceptor = INVALID_SOCKET;
3718
3719 /* clean up in case of failures */
3720 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
3721 closesocket(acceptor);
3722
3723 /* Disconnect during receive? */
3724
3725 acceptor = socket(AF_INET, SOCK_STREAM, 0);
3726 if (acceptor == INVALID_SOCKET) {
3727 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3728 goto end;
3729 }
3730 connector = socket(AF_INET, SOCK_STREAM, 0);
3731 if (connector == INVALID_SOCKET) {
3732 skip("could not create connector socket, error %d\n", WSAGetLastError());
3733 goto end;
3734 }
3735 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3736 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3737 &bytesReturned, &overlapped);
3738 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3739
3740 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3741 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
3742
3743 closesocket(connector);
3744 connector = INVALID_SOCKET;
3745
3746 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
3747 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
3748
3749 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
3750 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
3751 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
3752
3753 closesocket(acceptor);
3754 acceptor = INVALID_SOCKET;
3755
3756 /* Test closing with pending requests */
3757
3758 acceptor = socket(AF_INET, SOCK_STREAM, 0);
3759 if (acceptor == INVALID_SOCKET) {
3760 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3761 goto end;
3762 }
3763 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3764 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3765 &bytesReturned, &overlapped);
3766 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3767
3768 closesocket(acceptor);
3769 acceptor = INVALID_SOCKET;
3770
3771 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
3772 ok(dwret == WAIT_OBJECT_0 || broken(dwret == WAIT_TIMEOUT) /* NT4/2000 */,
3773 "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
3774
3775 if (dwret != WAIT_TIMEOUT) {
3776 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
3777 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
3778 }
3779 else {
3780 bret = CancelIo((HANDLE) listener);
3781 ok(bret, "Failed to cancel failed test. Bailing...\n");
3782 if (!bret) return;
3783 }
3784
3785 acceptor = socket(AF_INET, SOCK_STREAM, 0);
3786 if (acceptor == INVALID_SOCKET) {
3787 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3788 goto end;
3789 }
3790 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3791 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3792 &bytesReturned, &overlapped);
3793 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3794
3795 CancelIo((HANDLE) acceptor);
3796
3797 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
3798 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %d + errno %d\n", dwret, GetLastError());
3799
3800 closesocket(acceptor);
3801 acceptor = INVALID_SOCKET;
3802
3803 acceptor = socket(AF_INET, SOCK_STREAM, 0);
3804 if (acceptor == INVALID_SOCKET) {
3805 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3806 goto end;
3807 }
3808 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3809 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3810 &bytesReturned, &overlapped);
3811 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3812
3813 closesocket(listener);
3814 listener = INVALID_SOCKET;
3815
3816 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
3817 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
3818
3819 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
3820 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
3821
3822 end:
3823 if (overlapped.hEvent)
3824 WSACloseEvent(overlapped.hEvent);
3825 if (listener != INVALID_SOCKET)
3826 closesocket(listener);
3827 if (acceptor != INVALID_SOCKET)
3828 closesocket(acceptor);
3829 if (connector != INVALID_SOCKET)
3830 closesocket(connector);
3831 if (connector2 != INVALID_SOCKET)
3832 closesocket(connector2);
3833 }
3834
3835 static void test_getpeername(void)
3836 {
3837 SOCKET sock;
3838 struct sockaddr_in sa, sa_out;
3839 int sa_len;
3840 const char buf[] = "hello world";
3841 int ret;
3842
3843 /* Test the parameter validation order. */
3844 ret = getpeername(INVALID_SOCKET, NULL, NULL);
3845 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
3846 ok(WSAGetLastError() == WSAENOTSOCK,
3847 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
3848
3849 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
3850 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
3851 if (sock == INVALID_SOCKET)
3852 {
3853 skip("Socket creation failed with %d\n", WSAGetLastError());
3854 return;
3855 }
3856
3857 ret = getpeername(sock, NULL, NULL);
3858 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
3859 ok(WSAGetLastError() == WSAENOTCONN ||
3860 broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
3861 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
3862
3863 memset(&sa, 0, sizeof(sa));
3864 sa.sin_family = AF_INET;
3865 sa.sin_port = htons(139);
3866 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
3867
3868 /* sendto does not change a socket's connection state. */
3869 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
3870 ok(ret != SOCKET_ERROR,
3871 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
3872
3873 ret = getpeername(sock, NULL, NULL);
3874 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
3875 ok(WSAGetLastError() == WSAENOTCONN ||
3876 broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
3877 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
3878
3879 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
3880 ok(ret == 0,
3881 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
3882
3883 ret = getpeername(sock, NULL, NULL);
3884 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
3885 ok(WSAGetLastError() == WSAEFAULT,
3886 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
3887
3888 /* Test crashes on Wine. */
3889 if (0)
3890 {
3891 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
3892 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
3893 ok(WSAGetLastError() == WSAEFAULT,
3894 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
3895 }
3896
3897 sa_len = 0;
3898 ret = getpeername(sock, (struct sockaddr*)&sa_out, &sa_len);
3899 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
3900 ok(WSAGetLastError() == WSAEFAULT,
3901 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
3902
3903 sa_len = sizeof(sa_out);
3904 ret = getpeername(sock, (struct sockaddr*)&sa_out, &sa_len);
3905 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
3906 ok(!memcmp(&sa, &sa_out, sizeof(sa)),
3907 "Expected the returned structure to be identical to the connect structure\n");
3908
3909 closesocket(sock);
3910 }
3911
3912 /**************** Main program ***************/
3913
3914 START_TEST( sock )
3915 {
3916 int i;
3917
3918 /* Leave these tests at the beginning. They depend on WSAStartup not having been
3919 * called, which is done by Init() below. */
3920 test_WithoutWSAStartup();
3921 test_WithWSAStartup();
3922
3923 Init();
3924
3925 test_set_getsockopt();
3926 test_so_reuseaddr();
3927 test_extendedSocketOptions();
3928
3929 for (i = 0; i < NUM_TESTS; i++)
3930 {
3931 trace ( " **** STARTING TEST %d ****\n", i );
3932 do_test ( &tests[i] );
3933 trace ( " **** TEST %d COMPLETE ****\n", i );
3934 }
3935
3936 test_UDP();
3937
3938 test_getservbyname();
3939 test_WSASocket();
3940
3941 test_WSAAddressToStringA();
3942 test_WSAAddressToStringW();
3943
3944 test_WSAStringToAddressA();
3945 test_WSAStringToAddressW();
3946
3947 test_select();
3948 test_accept();
3949 test_getpeername();
3950 test_getsockname();
3951 test_inet_addr();
3952 test_ioctlsocket();
3953 test_dns();
3954 test_gethostbyname_hack();
3955
3956 test_WSASendTo();
3957 test_WSARecv();
3958
3959 test_events(0);
3960 test_events(1);
3961
3962 test_ipv6only();
3963 test_GetAddrInfoW();
3964
3965 test_AcceptEx();
3966
3967 /* this is a io heavy test, do it at the end so the kernel doesn't start dropping packets */
3968 test_send();
3969
3970 Exit();
3971 }
A free Windows-compatible Operating System