2 * Unit test suite for winsock functions
4 * Copyright 2002 Martin Wilck
5 * Copyright 2005 Thomas Kho
6 * Copyright 2008 Jeff Zaroyko
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.
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.
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
30 #include "wine/test.h"
34 #define MAX_CLIENTS 4 /* Max number of clients */
35 #define NUM_TESTS 4 /* Number of tests performed */
36 #define FIRST_CHAR 'A' /* First character in transferred pattern */
37 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
38 #define BIND_TRIES 6 /* Number of bind() attempts */
39 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
40 after server initialization, if something hangs */
42 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
44 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
45 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
47 #define SERVERIP "127.0.0.1" /* IP to bind to */
48 #define SERVERPORT 9374 /* Port number to bind to */
50 #define wsa_ok(op, cond, msg) \
54 if ( !(cond tmp) ) err = WSAGetLastError(); \
55 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
59 /**************** Structs and typedefs ***************/
61 typedef struct thread_info
67 /* Information in the server about open client connections */
68 typedef struct sock_info
71 struct sockaddr_in addr
;
72 struct sockaddr_in peer
;
78 /* Test parameters for both server & client */
79 typedef struct test_params
83 const char *inet_addr
;
90 /* server-specific test parameters */
91 typedef struct server_params
98 /* client-specific test parameters */
99 typedef struct client_params
101 test_params
*general
;
106 /* This type combines all information for setting up a test scenario */
107 typedef struct test_setup
111 server_params srv_params
;
113 client_params clt_params
;
116 /* Thread local storage for server */
117 typedef struct server_memory
120 struct sockaddr_in addr
;
121 sock_info sock
[MAX_CLIENTS
];
124 /* Thread local storage for client */
125 typedef struct client_memory
128 struct sockaddr_in addr
;
133 /* SelectReadThread thread parameters */
134 typedef struct select_thread_params
138 } select_thread_params
;
140 /**************** Static variables ***************/
142 static DWORD tls
; /* Thread local storage index */
143 static HANDLE thread
[1+MAX_CLIENTS
];
144 static DWORD thread_id
[1+MAX_CLIENTS
];
145 static HANDLE server_ready
;
146 static HANDLE client_ready
[MAX_CLIENTS
];
147 static int client_id
;
149 /**************** General utility functions ***************/
151 static int tcp_socketpair(SOCKET
*src
, SOCKET
*dst
)
153 SOCKET server
= INVALID_SOCKET
;
154 struct sockaddr_in addr
;
158 *src
= INVALID_SOCKET
;
159 *dst
= INVALID_SOCKET
;
161 *src
= socket(AF_INET
, SOCK_STREAM
, 0);
162 if (*src
== INVALID_SOCKET
)
165 server
= socket(AF_INET
, SOCK_STREAM
, 0);
166 if (server
== INVALID_SOCKET
)
169 memset(&addr
, 0, sizeof(addr
));
170 addr
.sin_family
= AF_INET
;
171 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
172 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
177 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
181 ret
= listen(server
, 1);
185 ret
= connect(*src
, (struct sockaddr
*)&addr
, sizeof(addr
));
190 *dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
193 if (server
!= INVALID_SOCKET
)
195 if (*src
!= INVALID_SOCKET
&& *dst
!= INVALID_SOCKET
)
202 static void set_so_opentype ( BOOL overlapped
)
204 int optval
= !overlapped
, newval
, len
= sizeof (int);
206 ok ( setsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
207 (LPVOID
) &optval
, sizeof (optval
) ) == 0,
208 "setting SO_OPENTYPE failed\n" );
209 ok ( getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
210 (LPVOID
) &newval
, &len
) == 0,
211 "getting SO_OPENTYPE failed\n" );
212 ok ( optval
== newval
, "failed to set SO_OPENTYPE\n" );
215 static int set_blocking ( SOCKET s
, BOOL blocking
)
217 u_long val
= !blocking
;
218 return ioctlsocket ( s
, FIONBIO
, &val
);
221 static void fill_buffer ( char *buf
, int chunk_size
, int n_chunks
)
224 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
225 memset ( p
, c
, chunk_size
);
228 static int test_buffer ( char *buf
, int chunk_size
, int n_chunks
)
232 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
234 for ( i
= 0; i
< chunk_size
; i
++ )
235 if ( p
[i
] != c
) return i
;
241 * This routine is called when a client / server does not expect any more data,
242 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
244 static void read_zero_bytes ( SOCKET s
)
248 while ( ( tmp
= recv ( s
, buf
, 256, 0 ) ) > 0 )
250 ok ( n
<= 0, "garbage data received: %d bytes\n", n
);
253 static int do_synchronous_send ( SOCKET s
, char *buf
, int buflen
, int sendlen
)
255 char* last
= buf
+ buflen
, *p
;
257 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
258 n
= send ( s
, p
, min ( sendlen
, last
- p
), 0 );
259 wsa_ok ( n
, 0 <=, "do_synchronous_send (%x): error %d\n" );
263 static int do_synchronous_recv ( SOCKET s
, char *buf
, int buflen
, int recvlen
)
265 char* last
= buf
+ buflen
, *p
;
267 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
268 n
= recv ( s
, p
, min ( recvlen
, last
- p
), 0 );
269 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
273 static int do_synchronous_recvfrom ( SOCKET s
, char *buf
, int buflen
,int flags
,struct sockaddr
*from
, int *fromlen
, int recvlen
)
275 char* last
= buf
+ buflen
, *p
;
277 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
278 n
= recvfrom ( s
, p
, min ( recvlen
, last
- p
), 0, from
, fromlen
);
279 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
284 * Call this routine right after thread startup.
285 * SO_OPENTYPE must by 0, regardless what the server did.
287 static void check_so_opentype (void)
291 getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
, (LPVOID
) &tmp
, &len
);
292 ok ( tmp
== 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp
);
295 /**************** Server utility functions ***************/
298 * Even if we have closed our server socket cleanly,
299 * the OS may mark the address "in use" for some time -
300 * this happens with native Linux apps, too.
302 static void do_bind ( SOCKET s
, struct sockaddr
* addr
, int addrlen
)
304 int err
, wsaerr
= 0, n_try
= BIND_TRIES
;
306 while ( ( err
= bind ( s
, addr
, addrlen
) ) != 0 &&
307 ( wsaerr
= WSAGetLastError () ) == WSAEADDRINUSE
&&
310 trace ( "address in use, waiting ...\n" );
311 Sleep ( 1000 * BIND_SLEEP
);
313 ok ( err
== 0, "failed to bind: %d\n", wsaerr
);
316 static void server_start ( server_params
*par
)
319 test_params
*gen
= par
->general
;
320 server_memory
*mem
= LocalAlloc ( LPTR
, sizeof ( server_memory
) );
322 TlsSetValue ( tls
, mem
);
323 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
324 NULL
, 0, par
->sock_flags
);
325 ok ( mem
->s
!= INVALID_SOCKET
, "Server: WSASocket failed\n" );
327 mem
->addr
.sin_family
= AF_INET
;
328 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
329 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
331 for (i
= 0; i
< MAX_CLIENTS
; i
++)
333 mem
->sock
[i
].s
= INVALID_SOCKET
;
334 mem
->sock
[i
].buf
= LocalAlloc ( LPTR
, gen
->n_chunks
* gen
->chunk_size
);
335 mem
->sock
[i
].n_recvd
= 0;
336 mem
->sock
[i
].n_sent
= 0;
339 if ( gen
->sock_type
== SOCK_STREAM
)
340 do_bind ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof (mem
->addr
) );
343 static void server_stop (void)
346 server_memory
*mem
= TlsGetValue ( tls
);
348 for (i
= 0; i
< MAX_CLIENTS
; i
++ )
350 LocalFree ( mem
->sock
[i
].buf
);
351 if ( mem
->sock
[i
].s
!= INVALID_SOCKET
)
352 closesocket ( mem
->sock
[i
].s
);
354 ok ( closesocket ( mem
->s
) == 0, "closesocket failed\n" );
356 ExitThread ( GetCurrentThreadId () );
359 /**************** Client utilitiy functions ***************/
361 static void client_start ( client_params
*par
)
363 test_params
*gen
= par
->general
;
364 client_memory
*mem
= LocalAlloc (LPTR
, sizeof (client_memory
));
366 TlsSetValue ( tls
, mem
);
368 WaitForSingleObject ( server_ready
, INFINITE
);
370 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
371 NULL
, 0, par
->sock_flags
);
373 mem
->addr
.sin_family
= AF_INET
;
374 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
375 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
377 ok ( mem
->s
!= INVALID_SOCKET
, "Client: WSASocket failed\n" );
379 mem
->send_buf
= LocalAlloc ( LPTR
, 2 * gen
->n_chunks
* gen
->chunk_size
);
380 mem
->recv_buf
= mem
->send_buf
+ gen
->n_chunks
* gen
->chunk_size
;
381 fill_buffer ( mem
->send_buf
, gen
->chunk_size
, gen
->n_chunks
);
383 SetEvent ( client_ready
[client_id
] );
384 /* Wait for the other clients to come up */
385 WaitForMultipleObjects ( min ( gen
->n_clients
, MAX_CLIENTS
), client_ready
, TRUE
, INFINITE
);
388 static void client_stop (void)
390 client_memory
*mem
= TlsGetValue ( tls
);
391 wsa_ok ( closesocket ( mem
->s
), 0 ==, "closesocket error (%x): %d\n" );
392 LocalFree ( mem
->send_buf
);
397 /**************** Servers ***************/
400 * simple_server: A very basic server doing synchronous IO.
402 static VOID WINAPI
simple_server ( server_params
*par
)
404 test_params
*gen
= par
->general
;
406 int pos
, n_recvd
, n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
407 id
= GetCurrentThreadId();
409 trace ( "simple_server (%x) starting\n", id
);
411 set_so_opentype ( FALSE
); /* non-overlapped */
412 server_start ( par
);
413 mem
= TlsGetValue ( tls
);
415 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
416 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "simple_server (%x): listen failed: %d\n");
418 trace ( "simple_server (%x) ready\n", id
);
419 SetEvent ( server_ready
); /* notify clients */
421 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
423 trace ( "simple_server (%x): waiting for client\n", id
);
425 /* accept a single connection */
426 tmp
= sizeof ( mem
->sock
[0].peer
);
427 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
428 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "simple_server (%x): accept failed: %d\n" );
430 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
431 "simple_server (%x): strange peer address\n", id
);
433 /* Receive data & check it */
434 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
435 ok ( n_recvd
== n_expected
,
436 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
437 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
438 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
441 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
442 ok ( n_sent
== n_expected
,
443 "simple_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
446 read_zero_bytes ( mem
->sock
[0].s
);
447 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "simple_server (%x): closesocket error: %d\n" );
448 mem
->sock
[0].s
= INVALID_SOCKET
;
451 trace ( "simple_server (%x) exiting\n", id
);
456 * select_server: A non-blocking server.
458 static VOID WINAPI
select_server ( server_params
*par
)
460 test_params
*gen
= par
->general
;
462 int n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
463 id
= GetCurrentThreadId(), n_connections
= 0, n_sent
, n_recvd
,
464 n_set
, delta
, n_ready
;
465 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
466 fd_set fds_recv
, fds_send
, fds_openrecv
, fds_opensend
;
468 trace ( "select_server (%x) starting\n", id
);
470 set_so_opentype ( FALSE
); /* non-overlapped */
471 server_start ( par
);
472 mem
= TlsGetValue ( tls
);
474 wsa_ok ( set_blocking ( mem
->s
, FALSE
), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
475 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "select_server (%x): listen failed: %d\n");
477 trace ( "select_server (%x) ready\n", id
);
478 SetEvent ( server_ready
); /* notify clients */
480 FD_ZERO ( &fds_openrecv
);
481 FD_ZERO ( &fds_recv
);
482 FD_ZERO ( &fds_send
);
483 FD_ZERO ( &fds_opensend
);
485 FD_SET ( mem
->s
, &fds_openrecv
);
489 fds_recv
= fds_openrecv
;
490 fds_send
= fds_opensend
;
494 wsa_ok ( ( n_ready
= select ( 0, &fds_recv
, &fds_send
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
495 "select_server (%x): select() failed: %d\n" );
497 /* check for incoming requests */
498 if ( FD_ISSET ( mem
->s
, &fds_recv
) ) {
501 trace ( "select_server (%x): accepting client connection\n", id
);
503 /* accept a single connection */
504 tmp
= sizeof ( mem
->sock
[n_connections
].peer
);
505 mem
->sock
[n_connections
].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[n_connections
].peer
, &tmp
);
506 wsa_ok ( mem
->sock
[n_connections
].s
, INVALID_SOCKET
!=, "select_server (%x): accept() failed: %d\n" );
508 ok ( mem
->sock
[n_connections
].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
509 "select_server (%x): strange peer address\n", id
);
511 /* add to list of open connections */
512 FD_SET ( mem
->sock
[n_connections
].s
, &fds_openrecv
);
513 FD_SET ( mem
->sock
[n_connections
].s
, &fds_opensend
);
518 /* handle open requests */
520 for ( i
= 0; i
< n_connections
; i
++ )
522 if ( FD_ISSET( mem
->sock
[i
].s
, &fds_recv
) ) {
525 if ( mem
->sock
[i
].n_recvd
< n_expected
) {
526 /* Receive data & check it */
527 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 );
528 ok ( n_recvd
!= SOCKET_ERROR
, "select_server (%x): error in recv(): %d\n", id
, WSAGetLastError() );
529 mem
->sock
[i
].n_recvd
+= n_recvd
;
531 if ( mem
->sock
[i
].n_recvd
== n_expected
) {
532 int pos
= test_buffer ( mem
->sock
[i
].buf
, gen
->chunk_size
, gen
->n_chunks
);
533 ok ( pos
== -1, "select_server (%x): test pattern error: %d\n", id
, pos
);
534 FD_CLR ( mem
->sock
[i
].s
, &fds_openrecv
);
537 ok ( mem
->sock
[i
].n_recvd
<= n_expected
, "select_server (%x): received too many bytes: %d\n", id
, mem
->sock
[i
].n_recvd
);
541 /* only echo back what we've received */
542 delta
= mem
->sock
[i
].n_recvd
- mem
->sock
[i
].n_sent
;
544 if ( FD_ISSET ( mem
->sock
[i
].s
, &fds_send
) ) {
547 if ( ( delta
> 0 ) && ( mem
->sock
[i
].n_sent
< n_expected
) ) {
549 n_sent
= send ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_sent
, min ( delta
, par
->buflen
), 0 );
550 ok ( n_sent
!= SOCKET_ERROR
, "select_server (%x): error in send(): %d\n", id
, WSAGetLastError() );
551 mem
->sock
[i
].n_sent
+= n_sent
;
553 if ( mem
->sock
[i
].n_sent
== n_expected
) {
554 FD_CLR ( mem
->sock
[i
].s
, &fds_opensend
);
557 ok ( mem
->sock
[i
].n_sent
<= n_expected
, "select_server (%x): sent too many bytes: %d\n", id
, mem
->sock
[i
].n_sent
);
562 /* check that select returned the correct number of ready sockets */
563 ok ( ( n_set
== n_ready
), "select_server (%x): select() returns wrong number of ready sockets\n", id
);
565 /* check if all clients are done */
566 if ( ( fds_opensend
.fd_count
== 0 )
567 && ( fds_openrecv
.fd_count
== 1 ) /* initial socket that accepts clients */
568 && ( n_connections
== min ( gen
->n_clients
, MAX_CLIENTS
) ) ) {
573 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
576 read_zero_bytes ( mem
->sock
[i
].s
);
577 wsa_ok ( closesocket ( mem
->sock
[i
].s
), 0 ==, "select_server (%x): closesocket error: %d\n" );
578 mem
->sock
[i
].s
= INVALID_SOCKET
;
581 trace ( "select_server (%x) exiting\n", id
);
585 /**************** Clients ***************/
588 * simple_client: A very basic client doing synchronous IO.
590 static VOID WINAPI
simple_client ( client_params
*par
)
592 test_params
*gen
= par
->general
;
594 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
596 id
= GetCurrentThreadId();
597 trace ( "simple_client (%x): starting\n", id
);
598 /* wait here because we want to call set_so_opentype before creating a socket */
599 WaitForSingleObject ( server_ready
, INFINITE
);
600 trace ( "simple_client (%x): server ready\n", id
);
602 check_so_opentype ();
603 set_so_opentype ( FALSE
); /* non-overlapped */
604 client_start ( par
);
605 mem
= TlsGetValue ( tls
);
608 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
609 0 ==, "simple_client (%x): connect error: %d\n" );
610 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
611 "simple_client (%x): failed to set blocking mode\n", id
);
612 trace ( "simple_client (%x) connected\n", id
);
614 /* send data to server */
615 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
);
616 ok ( n_sent
== n_expected
,
617 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
619 /* shutdown send direction */
620 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
622 /* Receive data echoed back & check it */
623 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, par
->buflen
);
624 ok ( n_recvd
== n_expected
,
625 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
628 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
629 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
632 read_zero_bytes ( mem
->s
);
633 trace ( "simple_client (%x) exiting\n", id
);
638 * simple_mixed_client: mixing send and recvfrom
640 static VOID WINAPI
simple_mixed_client ( client_params
*par
)
642 test_params
*gen
= par
->general
;
644 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
645 int fromLen
= sizeof(mem
->addr
);
646 struct sockaddr test
;
648 id
= GetCurrentThreadId();
649 trace ( "simple_client (%x): starting\n", id
);
650 /* wait here because we want to call set_so_opentype before creating a socket */
651 WaitForSingleObject ( server_ready
, INFINITE
);
652 trace ( "simple_client (%x): server ready\n", id
);
654 check_so_opentype ();
655 set_so_opentype ( FALSE
); /* non-overlapped */
656 client_start ( par
);
657 mem
= TlsGetValue ( tls
);
660 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
661 0 ==, "simple_client (%x): connect error: %d\n" );
662 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
663 "simple_client (%x): failed to set blocking mode\n", id
);
664 trace ( "simple_client (%x) connected\n", id
);
666 /* send data to server */
667 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
);
668 ok ( n_sent
== n_expected
,
669 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
671 /* shutdown send direction */
672 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
674 /* this shouldn't change, since lpFrom, is not updated on
675 connection oriented sockets - exposed by bug 11640
677 ((struct sockaddr_in
*)&test
)->sin_addr
.s_addr
= inet_addr("0.0.0.0");
679 /* Receive data echoed back & check it */
680 n_recvd
= do_synchronous_recvfrom ( mem
->s
,
684 (struct sockaddr
*)&test
,
687 ok ( n_recvd
== n_expected
,
688 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
690 /* check that lpFrom was not updated */
693 inet_ntoa(((struct sockaddr_in
*)&test
)->sin_addr
),
694 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
697 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
698 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
701 read_zero_bytes ( mem
->s
);
702 trace ( "simple_client (%x) exiting\n", id
);
707 * event_client: An event-driven client
709 static void WINAPI
event_client ( client_params
*par
)
711 test_params
*gen
= par
->general
;
713 int id
= GetCurrentThreadId(), n_expected
= gen
->n_chunks
* gen
->chunk_size
,
716 WSANETWORKEVENTS wsa_events
;
717 char *send_last
, *recv_last
, *send_p
, *recv_p
;
718 long mask
= FD_READ
| FD_WRITE
| FD_CLOSE
;
720 trace ( "event_client (%x): starting\n", id
);
721 client_start ( par
);
722 trace ( "event_client (%x): server ready\n", id
);
724 mem
= TlsGetValue ( tls
);
726 /* Prepare event notification for connect, makes socket nonblocking */
727 event
= WSACreateEvent ();
728 WSAEventSelect ( mem
->s
, event
, FD_CONNECT
);
729 tmp
= connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) );
731 err
= WSAGetLastError ();
732 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): connect error: %d\n", id
, err
);
733 tmp
= WaitForSingleObject ( event
, INFINITE
);
734 ok ( tmp
== WAIT_OBJECT_0
, "event_client (%x): wait for connect event failed: %d\n", id
, tmp
);
735 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
736 wsa_ok ( err
, 0 ==, "event_client (%x): WSAEnumNetworkEvents error: %d\n" );
737 err
= wsa_events
.iErrorCode
[ FD_CONNECT_BIT
];
738 ok ( err
== 0, "event_client (%x): connect error: %d\n", id
, err
);
742 trace ( "event_client (%x) connected\n", id
);
744 WSAEventSelect ( mem
->s
, event
, mask
);
746 recv_p
= mem
->recv_buf
;
747 recv_last
= mem
->recv_buf
+ n_expected
;
748 send_p
= mem
->send_buf
;
749 send_last
= mem
->send_buf
+ n_expected
;
753 err
= WaitForSingleObject ( event
, INFINITE
);
754 ok ( err
== WAIT_OBJECT_0
, "event_client (%x): wait failed\n", id
);
756 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
757 wsa_ok ( err
, 0 ==, "event_client (%x): WSAEnumNetworkEvents error: %d\n" );
759 if ( wsa_events
.lNetworkEvents
& FD_WRITE
)
761 err
= wsa_events
.iErrorCode
[ FD_WRITE_BIT
];
762 ok ( err
== 0, "event_client (%x): FD_WRITE error code: %d\n", id
, err
);
767 n
= send ( mem
->s
, send_p
, min ( send_last
- send_p
, par
->buflen
), 0 );
770 err
= WSAGetLastError ();
771 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): send error: %d\n", id
, err
);
776 while ( n
>= 0 && send_p
< send_last
);
778 if ( send_p
== send_last
)
780 trace ( "event_client (%x): all data sent - shutdown\n", id
);
781 shutdown ( mem
->s
, SD_SEND
);
783 WSAEventSelect ( mem
->s
, event
, mask
);
786 if ( wsa_events
.lNetworkEvents
& FD_READ
)
788 err
= wsa_events
.iErrorCode
[ FD_READ_BIT
];
789 ok ( err
== 0, "event_client (%x): FD_READ error code: %d\n", id
, err
);
790 if ( err
!= 0 ) break;
792 /* First read must succeed */
793 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
794 wsa_ok ( n
, 0 <=, "event_client (%x): recv error: %d\n" );
798 if ( recv_p
== recv_last
)
801 trace ( "event_client (%x): all data received\n", id
);
802 WSAEventSelect ( mem
->s
, event
, mask
);
805 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
806 if ( n
< 0 && ( err
= WSAGetLastError()) != WSAEWOULDBLOCK
)
807 ok ( 0, "event_client (%x): read error: %d\n", id
, err
);
811 if ( wsa_events
.lNetworkEvents
& FD_CLOSE
)
813 trace ( "event_client (%x): close event\n", id
);
814 err
= wsa_events
.iErrorCode
[ FD_CLOSE_BIT
];
815 ok ( err
== 0, "event_client (%x): FD_CLOSE error code: %d\n", id
, err
);
820 n
= send_p
- mem
->send_buf
;
821 ok ( send_p
== send_last
,
822 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n
, n_expected
);
823 n
= recv_p
- mem
->recv_buf
;
824 ok ( recv_p
== recv_last
,
825 "simple_client (%x): received less data than expected: %d of %d\n", id
, n
, n_expected
);
826 n
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
827 ok ( n
== -1, "event_client (%x): test pattern error: %d\n", id
, n
);
830 WSACloseEvent ( event
);
831 trace ( "event_client (%x) exiting\n", id
);
835 /**************** Main program utility functions ***************/
837 static void Init (void)
839 WORD ver
= MAKEWORD (2, 2);
842 ok ( WSAStartup ( ver
, &data
) == 0, "WSAStartup failed\n" );
846 static void Exit (void)
851 err
= WSAGetLastError();
852 ok ( ret
== 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret
, err
);
854 err
= WSAGetLastError();
855 ok ( (ret
== SOCKET_ERROR
&& err
== WSANOTINITIALISED
) ||
856 broken(ret
== 0), /* WinME */
857 "WSACleanup returned %d GetLastError is %d\n", ret
, err
);
860 static void StartServer (LPTHREAD_START_ROUTINE routine
,
861 test_params
*general
, server_params
*par
)
863 par
->general
= general
;
864 thread
[0] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[0] );
865 ok ( thread
[0] != NULL
, "Failed to create server thread\n" );
868 static void StartClients (LPTHREAD_START_ROUTINE routine
,
869 test_params
*general
, client_params
*par
)
872 par
->general
= general
;
873 for ( i
= 1; i
<= min ( general
->n_clients
, MAX_CLIENTS
); i
++ )
876 thread
[i
] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[i
] );
877 ok ( thread
[i
] != NULL
, "Failed to create client thread\n" );
878 /* Make sure the client is up and running */
879 WaitForSingleObject ( client_ready
[client_id
], INFINITE
);
883 static void do_test( test_setup
*test
)
885 DWORD i
, n
= min (test
->general
.n_clients
, MAX_CLIENTS
);
888 server_ready
= CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
889 for (i
= 0; i
<= n
; i
++)
890 client_ready
[i
] = CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
892 StartServer ( test
->srv
, &test
->general
, &test
->srv_params
);
893 StartClients ( test
->clt
, &test
->general
, &test
->clt_params
);
894 WaitForSingleObject ( server_ready
, INFINITE
);
896 wait
= WaitForMultipleObjects ( 1 + n
, thread
, TRUE
, 1000 * TEST_TIMEOUT
);
897 ok ( wait
<= WAIT_OBJECT_0
+ n
,
898 "some threads have not completed: %x\n", wait
);
900 if ( ! ( wait
<= WAIT_OBJECT_0
+ n
) )
902 for (i
= 0; i
<= n
; i
++)
904 trace ("terminating thread %08x\n", thread_id
[i
]);
905 if ( WaitForSingleObject ( thread
[i
], 0 ) != WAIT_OBJECT_0
)
906 TerminateThread ( thread
[i
], 0 );
909 CloseHandle ( server_ready
);
910 for (i
= 0; i
<= n
; i
++)
911 CloseHandle ( client_ready
[i
] );
914 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
915 /* optname = SO_LINGER */
916 LINGER linger_testvals
[] = {
923 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
924 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
925 bug in the linux kernel (fixed in 2.6.8) */
926 #define SOCKTIMEOUT2 997000 /* 997 seconds */
928 static void test_set_getsockopt(void)
936 s
= socket(AF_INET
, SOCK_STREAM
, 0);
937 ok(s
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
938 if( s
== INVALID_SOCKET
) return;
940 timeout
= SOCKTIMEOUT1
;
941 size
= sizeof(timeout
);
942 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
944 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
945 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
946 ok( timeout
== SOCKTIMEOUT1
, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
948 timeout
= SOCKTIMEOUT2
; /* 54 seconds. See remark above */
949 size
= sizeof(timeout
);
950 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, size
);
952 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, &size
);
953 ok( !err
, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
954 ok( timeout
== SOCKTIMEOUT2
, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout
);
956 for( i
= 0; i
< sizeof(linger_testvals
)/sizeof(LINGER
);i
++) {
957 size
= sizeof(lingval
);
958 lingval
= linger_testvals
[i
];
959 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, size
);
961 err
= getsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, &size
);
962 ok( !err
, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
963 ok( !lingval
.l_onoff
== !linger_testvals
[i
].l_onoff
&&
964 (lingval
.l_linger
== linger_testvals
[i
].l_linger
||
965 (!lingval
.l_linger
&& !linger_testvals
[i
].l_onoff
))
966 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i
,
967 lingval
.l_onoff
, lingval
.l_linger
,
968 linger_testvals
[i
].l_onoff
, linger_testvals
[i
].l_linger
);
970 /* Test for erroneously passing a value instead of a pointer as optval */
972 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTROUTE
, (char *)1, size
);
973 ok(err
== SOCKET_ERROR
, "setsockopt with optval being a value passed "
974 "instead of failing.\n");
975 lasterr
= WSAGetLastError();
976 ok(lasterr
== WSAEFAULT
, "setsockopt with optval being a value "
977 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
982 static void test_so_reuseaddr(void)
984 struct sockaddr_in saddr
;
986 unsigned int rc
,reuse
;
989 saddr
.sin_family
= AF_INET
;
990 saddr
.sin_port
= htons(9375);
991 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
993 s1
=socket(AF_INET
, SOCK_STREAM
, 0);
994 ok(s1
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
995 rc
= bind(s1
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
996 ok(rc
!=SOCKET_ERROR
, "bind(s1) failed error: %d\n", WSAGetLastError());
998 s2
=socket(AF_INET
, SOCK_STREAM
, 0);
999 ok(s2
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1003 rc
=getsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, &size
);
1004 ok(rc
==0 && reuse
==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc
,reuse
);
1006 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1007 ok(rc
==SOCKET_ERROR
, "bind() succeeded\n");
1010 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
1011 ok(rc
==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1013 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1014 * a port immediately after closing another socket on that port, so
1015 * basically following the BSD socket semantics here. */
1017 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1018 ok(rc
==0, "bind() failed error: %d\n", WSAGetLastError());
1023 /************* Array containing the tests to run **********/
1025 #define STD_STREAM_SOCKET \
1031 static test_setup tests
[NUM_TESTS
] =
1033 /* Test 0: synchronous client and server */
1054 /* Test 1: event-driven client, synchronous server */
1071 WSA_FLAG_OVERLAPPED
,
1075 /* Test 2: synchronous client, non-blocking server via select() */
1096 /* Test 3: synchronous mixed client and server */
1110 simple_mixed_client
,
1119 static void test_UDP(void)
1121 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
1122 possible that this test fails due to dropped packets. */
1124 /* peer 0 receives data from all other peers */
1125 struct sock_info peer
[NUM_UDP_PEERS
];
1127 int ss
, i
, n_recv
, n_sent
;
1129 memset (buf
,0,sizeof(buf
));
1130 for ( i
= NUM_UDP_PEERS
- 1; i
>= 0; i
-- ) {
1131 ok ( ( peer
[i
].s
= socket ( AF_INET
, SOCK_DGRAM
, 0 ) ) != INVALID_SOCKET
, "UDP: socket failed\n" );
1133 peer
[i
].addr
.sin_family
= AF_INET
;
1134 peer
[i
].addr
.sin_addr
.s_addr
= inet_addr ( SERVERIP
);
1137 peer
[i
].addr
.sin_port
= htons ( SERVERPORT
);
1139 peer
[i
].addr
.sin_port
= htons ( 0 );
1142 do_bind ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, sizeof( peer
[i
].addr
) );
1144 /* test getsockname() to get peer's port */
1145 ss
= sizeof ( peer
[i
].addr
);
1146 ok ( getsockname ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, &ss
) != SOCKET_ERROR
, "UDP: could not getsockname()\n" );
1147 ok ( peer
[i
].addr
.sin_port
!= htons ( 0 ), "UDP: bind() did not associate port\n" );
1150 /* test getsockname() */
1151 ok ( peer
[0].addr
.sin_port
== htons ( SERVERPORT
), "UDP: getsockname returned incorrect peer port\n" );
1153 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
1154 /* send client's ip */
1155 memcpy( buf
, &peer
[i
].addr
.sin_port
, sizeof(peer
[i
].addr
.sin_port
) );
1156 n_sent
= sendto ( peer
[i
].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*) &peer
[0].addr
, sizeof(peer
[0].addr
) );
1157 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
1160 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
1161 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0,(struct sockaddr
*) &peer
[0].peer
, &ss
);
1162 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
1163 ok ( memcmp ( &peer
[0].peer
.sin_port
, buf
, sizeof(peer
[0].addr
.sin_port
) ) == 0, "UDP: port numbers do not match\n" );
1167 static void WINAPI
do_getservbyname( HANDLE
*starttest
)
1173 } serv
[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
1176 struct servent
*pserv
[2];
1178 ok ( WaitForSingleObject ( *starttest
, TEST_TIMEOUT
* 1000 ) != WAIT_TIMEOUT
, "test_getservbyname: timeout waiting for start signal\n");
1180 /* ensure that necessary buffer resizes are completed */
1181 for ( j
= 0; j
< 2; j
++) {
1182 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
1185 for ( i
= 0; i
< NUM_QUERIES
/ 2; i
++ ) {
1186 for ( j
= 0; j
< 2; j
++ ) {
1187 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
1188 ok ( pserv
[j
] != NULL
, "getservbyname could not retrieve information for %s: %d\n", serv
[j
].name
, WSAGetLastError() );
1189 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
) );
1190 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
);
1191 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
);
1194 ok ( pserv
[0] == pserv
[1], "getservbyname: winsock resized servent buffer when not necessary\n" );
1198 static void test_getservbyname(void)
1201 HANDLE starttest
, thread
[NUM_THREADS
];
1202 DWORD thread_id
[NUM_THREADS
];
1204 starttest
= CreateEvent ( NULL
, 1, 0, "test_getservbyname_starttest" );
1206 /* create threads */
1207 for ( i
= 0; i
< NUM_THREADS
; i
++ ) {
1208 thread
[i
] = CreateThread ( NULL
, 0, (LPTHREAD_START_ROUTINE
) &do_getservbyname
, &starttest
, 0, &thread_id
[i
] );
1211 /* signal threads to start */
1212 SetEvent ( starttest
);
1214 for ( i
= 0; i
< NUM_THREADS
; i
++) {
1215 WaitForSingleObject ( thread
[i
], TEST_TIMEOUT
* 1000 );
1219 static void test_WSASocket(void)
1221 SOCKET sock
= INVALID_SOCKET
;
1222 WSAPROTOCOL_INFOA
*pi
;
1223 int providers
[] = {6, 0};
1227 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
1228 * to avoid a crash on win98.
1231 ret
= WSAEnumProtocolsA(providers
, NULL
, &pi_size
);
1232 ok(ret
== SOCKET_ERROR
, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
1234 err
= WSAGetLastError();
1235 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
1238 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
1239 ok(pi
!= NULL
, "Failed to allocate memory\n");
1241 skip("Can't continue without memory.\n");
1245 ret
= WSAEnumProtocolsA(providers
, pi
, &pi_size
);
1246 ok(ret
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
1250 skip("No protocols enumerated.\n");
1251 HeapFree(GetProcessHeap(), 0, pi
);
1255 sock
= WSASocketA(FROM_PROTOCOL_INFO
, FROM_PROTOCOL_INFO
,
1256 FROM_PROTOCOL_INFO
, &pi
[0], 0, 0);
1257 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1261 HeapFree(GetProcessHeap(), 0, pi
);
1264 static void test_WSAAddressToStringA(void)
1269 SOCKADDR_IN sockaddr
;
1270 CHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1272 CHAR expect1
[] = "0.0.0.0";
1273 CHAR expect2
[] = "255.255.255.255";
1274 CHAR expect3
[] = "0.0.0.0:65535";
1275 CHAR expect4
[] = "255.255.255.255:65535";
1279 sockaddr
.sin_family
= AF_INET
;
1280 sockaddr
.sin_port
= 0;
1281 sockaddr
.sin_addr
.s_addr
= 0;
1283 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1284 GLE
= WSAGetLastError();
1285 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
1286 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1289 len
= sizeof(address
);
1291 sockaddr
.sin_family
= AF_INET
;
1292 sockaddr
.sin_port
= 0;
1293 sockaddr
.sin_addr
.s_addr
= 0;
1295 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1296 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1298 ok( !strcmp( address
, expect1
), "Expected: %s, got: %s\n", expect1
, address
);
1300 len
= sizeof(address
);
1302 sockaddr
.sin_family
= AF_INET
;
1303 sockaddr
.sin_port
= 0;
1304 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
1306 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1307 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1309 ok( !strcmp( address
, expect2
), "Expected: %s, got: %s\n", expect2
, address
);
1311 len
= sizeof(address
);
1313 sockaddr
.sin_family
= AF_INET
;
1314 sockaddr
.sin_port
= 0xffff;
1315 sockaddr
.sin_addr
.s_addr
= 0;
1317 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1318 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1320 ok( !strcmp( address
, expect3
), "Expected: %s, got: %s\n", expect3
, address
);
1322 len
= sizeof(address
);
1324 sockaddr
.sin_family
= AF_INET
;
1325 sockaddr
.sin_port
= 0xffff;
1326 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
1328 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1329 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1331 ok( !strcmp( address
, expect4
), "Expected: %s, got: %s\n", expect4
, address
);
1334 static void test_WSAAddressToStringW(void)
1339 SOCKADDR_IN sockaddr
;
1340 WCHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1342 WCHAR expect1
[] = { '0','.','0','.','0','.','0', 0 };
1343 WCHAR expect2
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1344 WCHAR expect3
[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
1345 WCHAR expect4
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1346 '6', '5', '5', '3', '5', 0 };
1350 sockaddr
.sin_family
= AF_INET
;
1351 sockaddr
.sin_port
= 0;
1352 sockaddr
.sin_addr
.s_addr
= 0;
1354 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1355 GLE
= WSAGetLastError();
1356 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
1357 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1360 len
= sizeof(address
);
1362 sockaddr
.sin_family
= AF_INET
;
1363 sockaddr
.sin_port
= 0;
1364 sockaddr
.sin_addr
.s_addr
= 0;
1366 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1367 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1369 ok( !lstrcmpW( address
, expect1
), "Expected different address string\n" );
1371 len
= sizeof(address
);
1373 sockaddr
.sin_family
= AF_INET
;
1374 sockaddr
.sin_port
= 0;
1375 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
1377 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1378 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1380 ok( !lstrcmpW( address
, expect2
), "Expected different address string\n" );
1382 len
= sizeof(address
);
1384 sockaddr
.sin_family
= AF_INET
;
1385 sockaddr
.sin_port
= 0xffff;
1386 sockaddr
.sin_addr
.s_addr
= 0;
1388 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1389 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1391 ok( !lstrcmpW( address
, expect3
), "Expected different address string\n" );
1393 len
= sizeof(address
);
1395 sockaddr
.sin_family
= AF_INET
;
1396 sockaddr
.sin_port
= 0xffff;
1397 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
1399 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1400 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1402 ok( !lstrcmpW( address
, expect4
), "Expected different address string\n" );
1405 static void test_WSAStringToAddressA(void)
1408 SOCKADDR_IN sockaddr
;
1409 SOCKADDR_IN6 sockaddr6
;
1412 CHAR address1
[] = "0.0.0.0";
1413 CHAR address2
[] = "127.127.127.127";
1414 CHAR address3
[] = "255.255.255.255";
1415 CHAR address4
[] = "127.127.127.127:65535";
1416 CHAR address5
[] = "255.255.255.255:65535";
1417 CHAR address6
[] = "::1";
1418 CHAR address7
[] = "[::1]";
1419 CHAR address8
[] = "[::1]:65535";
1422 sockaddr
.sin_family
= AF_INET
;
1424 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1425 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
1426 WSAGetLastError() );
1428 len
= sizeof(sockaddr
);
1429 sockaddr
.sin_port
= 0;
1430 sockaddr
.sin_addr
.s_addr
= 0;
1432 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1433 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
1434 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1436 len
= sizeof(sockaddr
);
1437 sockaddr
.sin_port
= 0;
1438 sockaddr
.sin_addr
.s_addr
= 0;
1440 ret
= WSAStringToAddressA( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1441 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
1442 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1444 len
= sizeof(sockaddr
);
1445 sockaddr
.sin_port
= 0;
1446 sockaddr
.sin_addr
.s_addr
= 0;
1448 ret
= WSAStringToAddressA( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1449 GLE
= WSAGetLastError();
1450 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
1451 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
1452 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
1454 len
= sizeof(sockaddr
);
1455 sockaddr
.sin_port
= 0;
1456 sockaddr
.sin_addr
.s_addr
= 0;
1458 ret
= WSAStringToAddressA( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1459 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
1460 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1462 len
= sizeof(sockaddr
);
1463 sockaddr
.sin_port
= 0;
1464 sockaddr
.sin_addr
.s_addr
= 0;
1466 ret
= WSAStringToAddressA( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1467 GLE
= WSAGetLastError();
1468 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
1469 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
1470 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
1472 len
= sizeof(sockaddr6
);
1473 memset(&sockaddr6
, 0, len
);
1474 sockaddr6
.sin6_family
= AF_INET6
;
1476 ret
= WSAStringToAddressA( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
1478 GLE
= WSAGetLastError();
1479 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
1480 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
1482 len
= sizeof(sockaddr6
);
1483 memset(&sockaddr6
, 0, len
);
1484 sockaddr6
.sin6_family
= AF_INET6
;
1486 ret
= WSAStringToAddressA( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
1488 GLE
= WSAGetLastError();
1489 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
1490 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
1492 len
= sizeof(sockaddr6
);
1493 memset(&sockaddr6
, 0, len
);
1494 sockaddr6
.sin6_family
= AF_INET6
;
1496 ret
= WSAStringToAddressA( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
1498 GLE
= WSAGetLastError();
1499 ok( (ret
== 0 && sockaddr6
.sin6_port
== 0xffff) ||
1500 (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
1501 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
1505 static void test_WSAStringToAddressW(void)
1508 SOCKADDR_IN sockaddr
;
1509 SOCKADDR_IN6 sockaddr6
;
1512 WCHAR address1
[] = { '0','.','0','.','0','.','0', 0 };
1513 WCHAR address2
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
1514 WCHAR address3
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1515 WCHAR address4
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
1516 ':', '6', '5', '5', '3', '5', 0 };
1517 WCHAR address5
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1518 '6', '5', '5', '3', '5', 0 };
1519 WCHAR address6
[] = {':',':','1','\0'};
1520 WCHAR address7
[] = {'[',':',':','1',']','\0'};
1521 WCHAR address8
[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
1524 sockaddr
.sin_family
= AF_INET
;
1526 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1527 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressW() failed unexpectedly: %d\n",
1528 WSAGetLastError() );
1530 len
= sizeof(sockaddr
);
1531 sockaddr
.sin_port
= 0;
1532 sockaddr
.sin_addr
.s_addr
= 0;
1534 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1535 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
1536 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1538 len
= sizeof(sockaddr
);
1539 sockaddr
.sin_port
= 0;
1540 sockaddr
.sin_addr
.s_addr
= 0;
1542 ret
= WSAStringToAddressW( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1543 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
1544 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1546 len
= sizeof(sockaddr
);
1547 sockaddr
.sin_port
= 0;
1548 sockaddr
.sin_addr
.s_addr
= 0;
1550 ret
= WSAStringToAddressW( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1551 GLE
= WSAGetLastError();
1552 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
1553 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
1554 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
1556 len
= sizeof(sockaddr
);
1557 sockaddr
.sin_port
= 0;
1558 sockaddr
.sin_addr
.s_addr
= 0;
1560 ret
= WSAStringToAddressW( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1561 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
1562 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1564 len
= sizeof(sockaddr
);
1565 sockaddr
.sin_port
= 0;
1566 sockaddr
.sin_addr
.s_addr
= 0;
1568 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1569 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
1570 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
1571 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
1573 len
= sizeof(sockaddr6
);
1574 memset(&sockaddr6
, 0, len
);
1575 sockaddr6
.sin6_family
= AF_INET6
;
1577 ret
= WSAStringToAddressW( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
1579 GLE
= WSAGetLastError();
1580 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
1581 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
1583 len
= sizeof(sockaddr6
);
1584 memset(&sockaddr6
, 0, len
);
1585 sockaddr6
.sin6_family
= AF_INET6
;
1587 ret
= WSAStringToAddressW( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
1589 GLE
= WSAGetLastError();
1590 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
1591 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
1593 len
= sizeof(sockaddr6
);
1594 memset(&sockaddr6
, 0, len
);
1595 sockaddr6
.sin6_family
= AF_INET6
;
1597 ret
= WSAStringToAddressW( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
1599 GLE
= WSAGetLastError();
1600 ok( (ret
== 0 && sockaddr6
.sin6_port
== 0xffff) ||
1601 (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
1602 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
1606 static VOID WINAPI
SelectReadThread(select_thread_params
*par
)
1610 struct sockaddr_in addr
;
1611 struct timeval select_timeout
;
1614 FD_SET(par
->s
, &readfds
);
1615 select_timeout
.tv_sec
=5;
1616 select_timeout
.tv_usec
=0;
1617 addr
.sin_family
= AF_INET
;
1618 addr
.sin_addr
.s_addr
= inet_addr(SERVERIP
);
1619 addr
.sin_port
= htons(SERVERPORT
);
1621 do_bind(par
->s
, (struct sockaddr
*)&addr
, sizeof(addr
));
1622 wsa_ok(listen(par
->s
, SOMAXCONN
), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
1624 SetEvent(server_ready
);
1625 ret
= select(par
->s
+1, &readfds
, NULL
, NULL
, &select_timeout
);
1626 par
->ReadKilled
= (ret
== 1);
1629 static void test_select(void)
1631 SOCKET fdRead
, fdWrite
;
1632 fd_set readfds
, writefds
, exceptfds
;
1635 struct timeval select_timeout
;
1636 select_thread_params thread_params
;
1637 HANDLE thread_handle
;
1640 fdRead
= socket(AF_INET
, SOCK_STREAM
, 0);
1641 ok( (fdRead
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
1642 fdWrite
= socket(AF_INET
, SOCK_STREAM
, 0);
1643 ok( (fdWrite
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
1647 FD_ZERO(&exceptfds
);
1648 FD_SET(fdRead
, &readfds
);
1649 FD_SET(fdWrite
, &writefds
);
1650 FD_SET(fdRead
, &exceptfds
);
1651 FD_SET(fdWrite
, &exceptfds
);
1652 select_timeout
.tv_sec
=0;
1653 select_timeout
.tv_usec
=500;
1656 if (fdWrite
> maxfd
)
1660 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
1661 ok ( (ret
== 0), "select should not return any socket handles\n");
1662 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
1663 ok ( !FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
1666 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
1667 ok ( !FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
1670 ok ((listen(fdWrite
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
1672 ret
= closesocket(fdWrite
);
1673 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
1675 thread_params
.s
= fdRead
;
1676 thread_params
.ReadKilled
= FALSE
;
1677 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
1678 thread_handle
= CreateThread (NULL
, 0, (LPTHREAD_START_ROUTINE
) &SelectReadThread
, &thread_params
, 0, &id
);
1679 ok ( (thread_handle
!= NULL
), "CreateThread failed unexpectedly: %d\n", GetLastError());
1681 WaitForSingleObject (server_ready
, INFINITE
);
1683 ret
= closesocket(fdRead
);
1684 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
1686 WaitForSingleObject (thread_handle
, 1000);
1687 ok ( (thread_params
.ReadKilled
) ||
1688 broken(thread_params
.ReadKilled
== 0), /*Win98*/
1689 "closesocket did not wakeup select\n");
1693 static DWORD WINAPI
AcceptKillThread(select_thread_params
*par
)
1695 struct sockaddr_in address
;
1696 int len
= sizeof(address
);
1697 SOCKET client_socket
;
1699 SetEvent(server_ready
);
1700 client_socket
= accept(par
->s
, (struct sockaddr
*) &address
, &len
);
1701 if (client_socket
!= INVALID_SOCKET
)
1702 closesocket(client_socket
);
1703 par
->ReadKilled
= (client_socket
== INVALID_SOCKET
);
1707 static void test_accept(void)
1710 SOCKET server_socket
= INVALID_SOCKET
;
1711 struct sockaddr_in address
;
1712 select_thread_params thread_params
;
1713 HANDLE thread_handle
= NULL
;
1716 server_socket
= socket(AF_INET
, SOCK_STREAM
, 0);
1717 if (server_socket
== INVALID_SOCKET
)
1719 trace("error creating server socket: %d\n", WSAGetLastError());
1723 memset(&address
, 0, sizeof(address
));
1724 address
.sin_family
= AF_INET
;
1725 ret
= bind(server_socket
, (struct sockaddr
*) &address
, sizeof(address
));
1728 trace("error binding server socket: %d\n", WSAGetLastError());
1732 ret
= listen(server_socket
, 1);
1735 trace("error making server socket listen: %d\n", WSAGetLastError());
1739 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
1740 if (server_ready
== INVALID_HANDLE_VALUE
)
1742 trace("error creating event: %d\n", GetLastError());
1746 thread_params
.s
= server_socket
;
1747 thread_params
.ReadKilled
= FALSE
;
1748 thread_handle
= CreateThread(NULL
, 0, (LPTHREAD_START_ROUTINE
) AcceptKillThread
,
1749 &thread_params
, 0, &id
);
1750 if (thread_handle
== NULL
)
1752 trace("error creating thread: %d\n", GetLastError());
1756 WaitForSingleObject(server_ready
, INFINITE
);
1758 ret
= closesocket(server_socket
);
1761 trace("closesocket failed: %d\n", WSAGetLastError());
1765 WaitForSingleObject(thread_handle
, 1000);
1766 ok(thread_params
.ReadKilled
, "closesocket did not wakeup accept\n");
1769 if (thread_handle
!= NULL
)
1770 CloseHandle(thread_handle
);
1771 if (server_ready
!= INVALID_HANDLE_VALUE
)
1772 CloseHandle(server_ready
);
1773 if (server_socket
!= INVALID_SOCKET
)
1774 closesocket(server_socket
);
1777 static void test_extendedSocketOptions(void)
1781 struct sockaddr_in sa
;
1782 int sa_len
= sizeof(struct sockaddr_in
);
1783 int optval
, optlen
= sizeof(int), ret
;
1787 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
1788 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
1792 memset(&sa
, 0, sa_len
);
1794 sa
.sin_family
= AF_INET
;
1795 sa
.sin_port
= htons(0);
1796 sa
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
1798 if((sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
1799 trace("Creating the socket failed: %d\n", WSAGetLastError());
1804 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
1805 trace("Failed to bind socket: %d\n", WSAGetLastError());
1811 ret
= getsockopt(sock
, SOL_SOCKET
, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
1813 ok(ret
== 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret
);
1814 ok((optval
== 65507) || (optval
== 65527),
1815 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval
);
1817 optlen
= sizeof(LINGER
);
1818 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
1820 ok(ret
== SOCKET_ERROR
, "getsockopt should fail for UDP sockets but return value is 0x%08x\n", ret
);
1825 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
1826 trace("Creating the socket failed: %d\n", WSAGetLastError());
1831 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
1832 trace("Failed to bind socket: %d\n", WSAGetLastError());
1838 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
1839 ok(ret
== 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret
);
1841 optlen
= sizeof(BOOL
);
1842 ret
= getsockopt(sock
, SOL_SOCKET
, SO_DONTLINGER
, (char *)&bool_opt_val
, &optlen
);
1843 ok(ret
== 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret
);
1844 ok((linger_val
.l_onoff
&& !bool_opt_val
) || (!linger_val
.l_onoff
&& bool_opt_val
),
1845 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
1846 bool_opt_val
, linger_val
.l_onoff
);
1852 static void test_getsockname(void)
1856 struct sockaddr_in sa_set
, sa_get
;
1857 int sa_set_len
= sizeof(struct sockaddr_in
);
1858 int sa_get_len
= sa_set_len
;
1859 static const unsigned char null_padding
[] = {0,0,0,0,0,0,0,0};
1862 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
1863 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
1867 memset(&sa_set
, 0, sa_set_len
);
1869 sa_set
.sin_family
= AF_INET
;
1870 sa_set
.sin_port
= htons(0);
1871 sa_set
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
1873 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
1874 trace("Creating the socket failed: %d\n", WSAGetLastError());
1879 memcpy(&sa_get
, &sa_set
, sizeof(sa_set
));
1880 if (getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) == 0)
1881 ok(0, "getsockname on unbound socket should fail\n");
1883 ok(WSAGetLastError() == WSAEINVAL
, "getsockname on unbound socket "
1884 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL
);
1885 ok(memcmp(&sa_get
, &sa_set
, sizeof(sa_get
)) == 0,
1886 "failed getsockname modified sockaddr when it shouldn't\n");
1889 if(bind(sock
, (struct sockaddr
*) &sa_set
, sa_set_len
) < 0){
1890 trace("Failed to bind socket: %d\n", WSAGetLastError());
1896 if(getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) != 0){
1897 trace("Failed to call getsockname: %d\n", WSAGetLastError());
1903 ret
= memcmp(sa_get
.sin_zero
, null_padding
, 8);
1904 ok(ret
== 0 || broken(ret
!= 0), /* NT4 */
1905 "getsockname did not zero the sockaddr_in structure\n");
1911 static void test_dns(void)
1915 h
= gethostbyname("");
1916 ok(h
!= NULL
, "gethostbyname(\"\") failed with %d\n", h_errno
);
1919 /* Our winsock headers don't define gethostname because it conflicts with the
1920 * definition in unistd.h. Define it here to get rid of the warning. */
1922 int WINAPI
gethostname(char *name
, int namelen
);
1924 static void test_gethostbyname_hack(void)
1928 static BYTE loopback
[] = {127, 0, 0, 1};
1929 static BYTE magic_loopback
[] = {127, 12, 34, 56};
1932 ret
= gethostname(name
, 256);
1933 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
1935 he
= gethostbyname("localhost");
1936 ok(he
!= NULL
, "gethostbyname(\"localhost\") failed: %d\n", h_errno
);
1939 if(he
->h_length
!= 4)
1941 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
1945 ok(memcmp(he
->h_addr_list
[0], loopback
, he
->h_length
) == 0,
1946 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
1947 he
->h_addr_list
[0][0], he
->h_addr_list
[0][1], he
->h_addr_list
[0][2],
1948 he
->h_addr_list
[0][3]);
1951 /* No reason to test further with NULL hostname */
1955 if(strcmp(name
, "localhost") == 0)
1957 skip("hostname seems to be \"localhost\", skipping test.\n");
1962 he
= gethostbyname(name
);
1963 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, h_errno
);
1966 if(he
->h_length
!= 4)
1968 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
1972 if (he
->h_addr_list
[0][0] == 127)
1974 ok(memcmp(he
->h_addr_list
[0], magic_loopback
, he
->h_length
) == 0,
1975 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
1976 name
, he
->h_addr_list
[0][0], he
->h_addr_list
[0][1],
1977 he
->h_addr_list
[0][2], he
->h_addr_list
[0][3]);
1982 he
= gethostbyname("nonexistent.winehq.org");
1983 /* Don't check for the return value, as some braindead ISPs will kindly
1984 * resolve nonexistent host names to addresses of the ISP's spam pages. */
1987 static void test_inet_addr(void)
1991 addr
= inet_addr(NULL
);
1992 ok(addr
== INADDR_NONE
, "inet_addr succeeded unexpectedly\n");
1995 static void test_ioctlsocket(void)
1999 long cmds
[] = {FIONBIO
, FIONREAD
, SIOCATMARK
};
2002 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
2003 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
2004 if(sock
== INVALID_SOCKET
)
2006 skip("Can't continue without a socket.\n");
2010 for(i
= 0; i
< sizeof(cmds
)/sizeof(long); i
++)
2012 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
2013 ret
= ioctlsocket(sock
, cmds
[i
], (u_long
*)1);
2014 ok(ret
== SOCKET_ERROR
, "ioctlsocket succeeded unexpectedly\n");
2015 ret
= WSAGetLastError();
2016 ok(ret
== WSAEFAULT
, "expected WSAEFAULT, got %d instead\n", ret
);
2020 static int drain_pause
=0;
2021 static DWORD WINAPI
drain_socket_thread(LPVOID arg
)
2024 SOCKET sock
= *(SOCKET
*)arg
;
2027 while ((ret
= recv(sock
, buffer
, sizeof(buffer
), 0)) != 0)
2031 if (WSAGetLastError() == WSAEWOULDBLOCK
)
2035 FD_SET(sock
, &readset
);
2036 select(0, &readset
, NULL
, NULL
, NULL
);
2047 static void test_send(void)
2049 SOCKET src
= INVALID_SOCKET
;
2050 SOCKET dst
= INVALID_SOCKET
;
2051 HANDLE hThread
= NULL
;
2052 const int buflen
= 1024*1024;
2053 char *buffer
= NULL
;
2057 if (tcp_socketpair(&src
, &dst
) != 0)
2059 ok(0, "creating socket pair failed, skipping test\n");
2063 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
2064 if (hThread
== NULL
)
2066 ok(0, "CreateThread failed, error %d\n", GetLastError());
2070 buffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, buflen
);
2073 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
2077 ret
= send(src
, buffer
, buflen
, 0);
2079 ok(ret
== buflen
, "send should have sent %d bytes, but it only sent %d\n", buflen
, ret
);
2081 ok(0, "send failed, error %d\n", WSAGetLastError());
2084 if (src
!= INVALID_SOCKET
)
2086 if (dst
!= INVALID_SOCKET
)
2088 if (hThread
!= NULL
)
2089 CloseHandle(hThread
);
2090 HeapFree(GetProcessHeap(), 0, buffer
);
2093 static void test_write_events(void)
2095 SOCKET src
= INVALID_SOCKET
;
2096 SOCKET dst
= INVALID_SOCKET
;
2097 HANDLE hThread
= NULL
;
2098 HANDLE hEvent
= INVALID_HANDLE_VALUE
;
2099 char *buffer
= NULL
;
2100 int bufferSize
= 1024*1024;
2104 WSANETWORKEVENTS netEvents
;
2107 if (tcp_socketpair(&src
, &dst
) != 0)
2109 ok(0, "creating socket pair failed, skipping test\n");
2113 /* On Windows it seems when a non-blocking socket sends to a
2114 blocking socket on the same host, the send() is BLOCKING,
2115 so make both sockets non-blocking */
2116 ret
= ioctlsocket(src
, FIONBIO
, &one
);
2119 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
2122 ret
= ioctlsocket(dst
, FIONBIO
, &one
);
2125 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
2129 buffer
= HeapAlloc(GetProcessHeap(), 0, bufferSize
);
2132 ok(0, "could not allocate memory for test\n");
2136 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
2137 if (hThread
== NULL
)
2139 ok(0, "CreateThread failed, error %d\n", GetLastError());
2143 hEvent
= CreateEventA(NULL
, FALSE
, TRUE
, NULL
);
2144 if (hEvent
== INVALID_HANDLE_VALUE
)
2146 ok(0, "CreateEventA failed, error %d\n", GetLastError());
2150 ret
= WSAEventSelect(src
, hEvent
, FD_WRITE
| FD_CLOSE
);
2153 ok(0, "WSAEventSelect failed, error %d\n", ret
);
2157 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
2158 dwRet
= WaitForSingleObject(hEvent
, 5000);
2159 if (dwRet
!= WAIT_OBJECT_0
)
2161 ok(0, "Initial WaitForSingleObject failed, error %d\n", dwRet
);
2164 ret
= WSAEnumNetworkEvents(src
, NULL
, &netEvents
);
2167 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
2170 if (netEvents
.lNetworkEvents
& FD_WRITE
)
2172 ret
= send(src
, "a", 1, 0);
2173 ok(ret
== 1, "sending 1 byte failed, error %d\n", WSAGetLastError());
2179 ok(0, "FD_WRITE not among initial events\n");
2183 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
2184 dwRet
= WaitForSingleObject(hEvent
, 2000);
2185 if (dwRet
== WAIT_OBJECT_0
)
2187 ok(0, "WaitForSingleObject should have timed out, but succeeded!\n");
2191 /* Now if we send a ton of data and the 'server' does not drain it fast
2192 * enough (set drain_pause to be sure), the socket send buffer will only
2193 * take some of it, and we will get a short write. This will trigger
2194 * another FD_WRITE event as soon as data is sent and more space becomes
2195 * available, but not any earlier. */
2199 ret
= send(src
, buffer
, bufferSize
, 0);
2200 } while (ret
== bufferSize
);
2202 if (ret
>= 0 || WSAGetLastError() == WSAEWOULDBLOCK
)
2204 dwRet
= WaitForSingleObject(hEvent
, 5000);
2205 ok(dwRet
== WAIT_OBJECT_0
, "Waiting failed with %d\n", dwRet
);
2206 if (dwRet
== WAIT_OBJECT_0
)
2208 ret
= WSAEnumNetworkEvents(src
, NULL
, &netEvents
);
2209 ok(ret
== 0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
2212 ok(netEvents
.lNetworkEvents
& FD_WRITE
,
2213 "FD_WRITE event not set as expected, events are 0x%x\n", netEvents
.lNetworkEvents
);
2220 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
2225 HeapFree(GetProcessHeap(), 0, buffer
);
2226 if (src
!= INVALID_SOCKET
)
2228 if (dst
!= INVALID_SOCKET
)
2230 if (hThread
!= NULL
)
2231 CloseHandle(hThread
);
2232 CloseHandle(hEvent
);
2235 static void test_ipv6only(void)
2237 SOCKET v4
= INVALID_SOCKET
,
2238 v6
= INVALID_SOCKET
;
2239 struct sockaddr_in sin4
;
2240 struct sockaddr_in6 sin6
;
2243 memset(&sin4
, 0, sizeof(sin4
));
2244 sin4
.sin_family
= AF_INET
;
2245 sin4
.sin_port
= htons(SERVERPORT
);
2247 memset(&sin6
, 0, sizeof(sin6
));
2248 sin6
.sin6_family
= AF_INET6
;
2249 sin6
.sin6_port
= htons(SERVERPORT
);
2251 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
2252 if (v6
== INVALID_SOCKET
) {
2253 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2254 WSAGetLastError(), WSAEAFNOSUPPORT
);
2257 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
2259 skip("Could not bind IPv6 address (LastError: %d).\n",
2264 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
2265 if (v4
== INVALID_SOCKET
) {
2266 skip("Could not create IPv4 socket (LastError: %d).\n",
2270 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
2271 ok(!ret
, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
2272 WSAGetLastError(), WSAEADDRINUSE
);
2275 if (v4
!= INVALID_SOCKET
)
2277 if (v6
!= INVALID_SOCKET
)
2281 static void test_WSASendTo(void)
2284 struct sockaddr_in addr
;
2285 char buf
[12] = "hello world";
2289 addr
.sin_family
= AF_INET
;
2290 addr
.sin_port
= htons(139);
2291 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2292 data_buf
.len
= sizeof(buf
);
2295 if( (s
= socket(AF_INET
, SOCK_DGRAM
, 0)) == INVALID_SOCKET
) {
2296 ok(0, "socket() failed error: %d\n", WSAGetLastError());
2300 WSASetLastError(12345);
2301 if(WSASendTo(s
, &data_buf
, 1, &bytesSent
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
)) {
2302 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
2305 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
2306 "a successful call to WSASendTo()\n");
2309 /**************** Main program ***************/
2316 test_set_getsockopt();
2317 test_so_reuseaddr();
2318 test_extendedSocketOptions();
2320 for (i
= 0; i
< NUM_TESTS
; i
++)
2322 trace ( " **** STARTING TEST %d ****\n", i
);
2323 do_test ( &tests
[i
] );
2324 trace ( " **** TEST %d COMPLETE ****\n", i
);
2329 test_getservbyname();
2332 test_WSAAddressToStringA();
2333 test_WSAAddressToStringW();
2335 test_WSAStringToAddressA();
2336 test_WSAStringToAddressW();
2344 test_gethostbyname_hack();
2347 test_write_events();