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
24 #define WIN32_NO_STATUS
29 #include "wine/test.h"
31 #define MAX_CLIENTS 4 /* Max number of clients */
32 #define NUM_TESTS 4 /* Number of tests performed */
33 #define FIRST_CHAR 'A' /* First character in transferred pattern */
34 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
35 #define BIND_TRIES 6 /* Number of bind() attempts */
36 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
37 after server initialization, if something hangs */
39 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
41 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
42 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
44 #define SERVERIP "127.0.0.1" /* IP to bind to */
45 #define SERVERPORT 9374 /* Port number to bind to */
47 #define wsa_ok(op, cond, msg) \
51 if ( !(cond tmp) ) err = WSAGetLastError(); \
52 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
55 /* Function pointers */
56 static void (WINAPI
*pFreeAddrInfoW
)(PADDRINFOW
) = 0;
57 static int (WINAPI
*pGetAddrInfoW
)(LPCWSTR
,LPCWSTR
,const ADDRINFOW
*,PADDRINFOW
*) = 0;
58 static PCSTR (WINAPI
*pInetNtop
)(INT
,LPVOID
,LPSTR
,ULONG
) = 0;
60 /**************** Structs and typedefs ***************/
62 typedef struct thread_info
68 /* Information in the server about open client connections */
69 typedef struct sock_info
72 struct sockaddr_in addr
;
73 struct sockaddr_in peer
;
79 /* Test parameters for both server & client */
80 typedef struct test_params
84 const char *inet_addr
;
91 /* server-specific test parameters */
92 typedef struct server_params
99 /* client-specific test parameters */
100 typedef struct client_params
102 test_params
*general
;
107 /* This type combines all information for setting up a test scenario */
108 typedef struct test_setup
112 server_params srv_params
;
114 client_params clt_params
;
117 /* Thread local storage for server */
118 typedef struct server_memory
121 struct sockaddr_in addr
;
122 sock_info sock
[MAX_CLIENTS
];
125 /* Thread local storage for client */
126 typedef struct client_memory
129 struct sockaddr_in addr
;
134 /* SelectReadThread thread parameters */
135 typedef struct select_thread_params
139 } select_thread_params
;
141 /**************** Static variables ***************/
143 static DWORD tls
; /* Thread local storage index */
144 static HANDLE thread
[1+MAX_CLIENTS
];
145 static DWORD thread_id
[1+MAX_CLIENTS
];
146 static HANDLE server_ready
;
147 static HANDLE client_ready
[MAX_CLIENTS
];
148 static int client_id
;
150 /**************** General utility functions ***************/
152 static int tcp_socketpair(SOCKET
*src
, SOCKET
*dst
)
154 SOCKET server
= INVALID_SOCKET
;
155 struct sockaddr_in addr
;
159 *src
= INVALID_SOCKET
;
160 *dst
= INVALID_SOCKET
;
162 *src
= socket(AF_INET
, SOCK_STREAM
, 0);
163 if (*src
== INVALID_SOCKET
)
166 server
= socket(AF_INET
, SOCK_STREAM
, 0);
167 if (server
== INVALID_SOCKET
)
170 memset(&addr
, 0, sizeof(addr
));
171 addr
.sin_family
= AF_INET
;
172 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
173 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
178 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
182 ret
= listen(server
, 1);
186 ret
= connect(*src
, (struct sockaddr
*)&addr
, sizeof(addr
));
191 *dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
194 if (server
!= INVALID_SOCKET
)
196 if (*src
!= INVALID_SOCKET
&& *dst
!= INVALID_SOCKET
)
203 static void set_so_opentype ( BOOL overlapped
)
205 int optval
= !overlapped
, newval
, len
= sizeof (int);
207 ok ( setsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
208 (LPVOID
) &optval
, sizeof (optval
) ) == 0,
209 "setting SO_OPENTYPE failed\n" );
210 ok ( getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
211 (LPVOID
) &newval
, &len
) == 0,
212 "getting SO_OPENTYPE failed\n" );
213 ok ( optval
== newval
, "failed to set SO_OPENTYPE\n" );
216 static int set_blocking ( SOCKET s
, BOOL blocking
)
218 u_long val
= !blocking
;
219 return ioctlsocket ( s
, FIONBIO
, &val
);
222 static void fill_buffer ( char *buf
, int chunk_size
, int n_chunks
)
225 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
226 memset ( p
, c
, chunk_size
);
229 static int test_buffer ( char *buf
, int chunk_size
, int n_chunks
)
233 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
235 for ( i
= 0; i
< chunk_size
; i
++ )
236 if ( p
[i
] != c
) return i
;
242 * This routine is called when a client / server does not expect any more data,
243 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
245 static void read_zero_bytes ( SOCKET s
)
249 while ( ( tmp
= recv ( s
, buf
, 256, 0 ) ) > 0 )
251 ok ( n
<= 0, "garbage data received: %d bytes\n", n
);
254 static int do_synchronous_send ( SOCKET s
, char *buf
, int buflen
, int sendlen
)
256 char* last
= buf
+ buflen
, *p
;
258 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
259 n
= send ( s
, p
, min ( sendlen
, last
- p
), 0 );
260 wsa_ok ( n
, 0 <=, "do_synchronous_send (%x): error %d\n" );
264 static int do_synchronous_recv ( SOCKET s
, char *buf
, int buflen
, int recvlen
)
266 char* last
= buf
+ buflen
, *p
;
268 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
269 n
= recv ( s
, p
, min ( recvlen
, last
- p
), 0 );
270 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
274 static int do_synchronous_recvfrom ( SOCKET s
, char *buf
, int buflen
,int flags
,struct sockaddr
*from
, int *fromlen
, int recvlen
)
276 char* last
= buf
+ buflen
, *p
;
278 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
279 n
= recvfrom ( s
, p
, min ( recvlen
, last
- p
), 0, from
, fromlen
);
280 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
285 * Call this routine right after thread startup.
286 * SO_OPENTYPE must by 0, regardless what the server did.
288 static void check_so_opentype (void)
292 getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
, (LPVOID
) &tmp
, &len
);
293 ok ( tmp
== 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp
);
296 /**************** Server utility functions ***************/
299 * Even if we have closed our server socket cleanly,
300 * the OS may mark the address "in use" for some time -
301 * this happens with native Linux apps, too.
303 static void do_bind ( SOCKET s
, struct sockaddr
* addr
, int addrlen
)
305 int err
, wsaerr
= 0, n_try
= BIND_TRIES
;
307 while ( ( err
= bind ( s
, addr
, addrlen
) ) != 0 &&
308 ( wsaerr
= WSAGetLastError () ) == WSAEADDRINUSE
&&
311 trace ( "address in use, waiting ...\n" );
312 Sleep ( 1000 * BIND_SLEEP
);
314 ok ( err
== 0, "failed to bind: %d\n", wsaerr
);
317 static void server_start ( server_params
*par
)
320 test_params
*gen
= par
->general
;
321 server_memory
*mem
= LocalAlloc ( LPTR
, sizeof ( server_memory
) );
323 TlsSetValue ( tls
, mem
);
324 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
325 NULL
, 0, par
->sock_flags
);
326 ok ( mem
->s
!= INVALID_SOCKET
, "Server: WSASocket failed\n" );
328 mem
->addr
.sin_family
= AF_INET
;
329 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
330 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
332 for (i
= 0; i
< MAX_CLIENTS
; i
++)
334 mem
->sock
[i
].s
= INVALID_SOCKET
;
335 mem
->sock
[i
].buf
= LocalAlloc ( LPTR
, gen
->n_chunks
* gen
->chunk_size
);
336 mem
->sock
[i
].n_recvd
= 0;
337 mem
->sock
[i
].n_sent
= 0;
340 if ( gen
->sock_type
== SOCK_STREAM
)
341 do_bind ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof (mem
->addr
) );
344 static void server_stop (void)
347 server_memory
*mem
= TlsGetValue ( tls
);
349 for (i
= 0; i
< MAX_CLIENTS
; i
++ )
351 LocalFree ( mem
->sock
[i
].buf
);
352 if ( mem
->sock
[i
].s
!= INVALID_SOCKET
)
353 closesocket ( mem
->sock
[i
].s
);
355 ok ( closesocket ( mem
->s
) == 0, "closesocket failed\n" );
357 ExitThread ( GetCurrentThreadId () );
360 /**************** Client utilitiy functions ***************/
362 static void client_start ( client_params
*par
)
364 test_params
*gen
= par
->general
;
365 client_memory
*mem
= LocalAlloc (LPTR
, sizeof (client_memory
));
367 TlsSetValue ( tls
, mem
);
369 WaitForSingleObject ( server_ready
, INFINITE
);
371 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
372 NULL
, 0, par
->sock_flags
);
374 mem
->addr
.sin_family
= AF_INET
;
375 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
376 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
378 ok ( mem
->s
!= INVALID_SOCKET
, "Client: WSASocket failed\n" );
380 mem
->send_buf
= LocalAlloc ( LPTR
, 2 * gen
->n_chunks
* gen
->chunk_size
);
381 mem
->recv_buf
= mem
->send_buf
+ gen
->n_chunks
* gen
->chunk_size
;
382 fill_buffer ( mem
->send_buf
, gen
->chunk_size
, gen
->n_chunks
);
384 SetEvent ( client_ready
[client_id
] );
385 /* Wait for the other clients to come up */
386 WaitForMultipleObjects ( min ( gen
->n_clients
, MAX_CLIENTS
), client_ready
, TRUE
, INFINITE
);
389 static void client_stop (void)
391 client_memory
*mem
= TlsGetValue ( tls
);
392 wsa_ok ( closesocket ( mem
->s
), 0 ==, "closesocket error (%x): %d\n" );
393 LocalFree ( mem
->send_buf
);
398 /**************** Servers ***************/
401 * simple_server: A very basic server doing synchronous IO.
403 static VOID WINAPI
simple_server ( server_params
*par
)
405 test_params
*gen
= par
->general
;
407 int pos
, n_recvd
, n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
408 id
= GetCurrentThreadId();
410 trace ( "simple_server (%x) starting\n", id
);
412 set_so_opentype ( FALSE
); /* non-overlapped */
413 server_start ( par
);
414 mem
= TlsGetValue ( tls
);
416 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
417 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "simple_server (%x): listen failed: %d\n");
419 trace ( "simple_server (%x) ready\n", id
);
420 SetEvent ( server_ready
); /* notify clients */
422 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
424 trace ( "simple_server (%x): waiting for client\n", id
);
426 /* accept a single connection */
427 tmp
= sizeof ( mem
->sock
[0].peer
);
428 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
429 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "simple_server (%x): accept failed: %d\n" );
431 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
432 "simple_server (%x): strange peer address\n", id
);
434 /* Receive data & check it */
435 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
436 ok ( n_recvd
== n_expected
,
437 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
438 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
439 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
442 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
443 ok ( n_sent
== n_expected
,
444 "simple_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
447 read_zero_bytes ( mem
->sock
[0].s
);
448 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "simple_server (%x): closesocket error: %d\n" );
449 mem
->sock
[0].s
= INVALID_SOCKET
;
452 trace ( "simple_server (%x) exiting\n", id
);
457 * select_server: A non-blocking server.
459 static VOID WINAPI
select_server ( server_params
*par
)
461 test_params
*gen
= par
->general
;
463 int n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
464 id
= GetCurrentThreadId(), n_connections
= 0, n_sent
, n_recvd
,
465 n_set
, delta
, n_ready
;
466 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
467 fd_set fds_recv
, fds_send
, fds_openrecv
, fds_opensend
;
469 trace ( "select_server (%x) starting\n", id
);
471 set_so_opentype ( FALSE
); /* non-overlapped */
472 server_start ( par
);
473 mem
= TlsGetValue ( tls
);
475 wsa_ok ( set_blocking ( mem
->s
, FALSE
), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
476 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "select_server (%x): listen failed: %d\n");
478 trace ( "select_server (%x) ready\n", id
);
479 SetEvent ( server_ready
); /* notify clients */
481 FD_ZERO ( &fds_openrecv
);
482 FD_ZERO ( &fds_recv
);
483 FD_ZERO ( &fds_send
);
484 FD_ZERO ( &fds_opensend
);
486 FD_SET ( mem
->s
, &fds_openrecv
);
490 fds_recv
= fds_openrecv
;
491 fds_send
= fds_opensend
;
495 wsa_ok ( ( n_ready
= select ( 0, &fds_recv
, &fds_send
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
496 "select_server (%x): select() failed: %d\n" );
498 /* check for incoming requests */
499 if ( FD_ISSET ( mem
->s
, &fds_recv
) ) {
502 trace ( "select_server (%x): accepting client connection\n", id
);
504 /* accept a single connection */
505 tmp
= sizeof ( mem
->sock
[n_connections
].peer
);
506 mem
->sock
[n_connections
].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[n_connections
].peer
, &tmp
);
507 wsa_ok ( mem
->sock
[n_connections
].s
, INVALID_SOCKET
!=, "select_server (%x): accept() failed: %d\n" );
509 ok ( mem
->sock
[n_connections
].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
510 "select_server (%x): strange peer address\n", id
);
512 /* add to list of open connections */
513 FD_SET ( mem
->sock
[n_connections
].s
, &fds_openrecv
);
514 FD_SET ( mem
->sock
[n_connections
].s
, &fds_opensend
);
519 /* handle open requests */
521 for ( i
= 0; i
< n_connections
; i
++ )
523 if ( FD_ISSET( mem
->sock
[i
].s
, &fds_recv
) ) {
526 if ( mem
->sock
[i
].n_recvd
< n_expected
) {
527 /* Receive data & check it */
528 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 );
529 ok ( n_recvd
!= SOCKET_ERROR
, "select_server (%x): error in recv(): %d\n", id
, WSAGetLastError() );
530 mem
->sock
[i
].n_recvd
+= n_recvd
;
532 if ( mem
->sock
[i
].n_recvd
== n_expected
) {
533 int pos
= test_buffer ( mem
->sock
[i
].buf
, gen
->chunk_size
, gen
->n_chunks
);
534 ok ( pos
== -1, "select_server (%x): test pattern error: %d\n", id
, pos
);
535 FD_CLR ( mem
->sock
[i
].s
, &fds_openrecv
);
538 ok ( mem
->sock
[i
].n_recvd
<= n_expected
, "select_server (%x): received too many bytes: %d\n", id
, mem
->sock
[i
].n_recvd
);
542 /* only echo back what we've received */
543 delta
= mem
->sock
[i
].n_recvd
- mem
->sock
[i
].n_sent
;
545 if ( FD_ISSET ( mem
->sock
[i
].s
, &fds_send
) ) {
548 if ( ( delta
> 0 ) && ( mem
->sock
[i
].n_sent
< n_expected
) ) {
550 n_sent
= send ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_sent
, min ( delta
, par
->buflen
), 0 );
551 ok ( n_sent
!= SOCKET_ERROR
, "select_server (%x): error in send(): %d\n", id
, WSAGetLastError() );
552 mem
->sock
[i
].n_sent
+= n_sent
;
554 if ( mem
->sock
[i
].n_sent
== n_expected
) {
555 FD_CLR ( mem
->sock
[i
].s
, &fds_opensend
);
558 ok ( mem
->sock
[i
].n_sent
<= n_expected
, "select_server (%x): sent too many bytes: %d\n", id
, mem
->sock
[i
].n_sent
);
563 /* check that select returned the correct number of ready sockets */
564 ok ( ( n_set
== n_ready
), "select_server (%x): select() returns wrong number of ready sockets\n", id
);
566 /* check if all clients are done */
567 if ( ( fds_opensend
.fd_count
== 0 )
568 && ( fds_openrecv
.fd_count
== 1 ) /* initial socket that accepts clients */
569 && ( n_connections
== min ( gen
->n_clients
, MAX_CLIENTS
) ) ) {
574 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
577 read_zero_bytes ( mem
->sock
[i
].s
);
578 wsa_ok ( closesocket ( mem
->sock
[i
].s
), 0 ==, "select_server (%x): closesocket error: %d\n" );
579 mem
->sock
[i
].s
= INVALID_SOCKET
;
582 trace ( "select_server (%x) exiting\n", id
);
586 /**************** Clients ***************/
589 * simple_client: A very basic client doing synchronous IO.
591 static VOID WINAPI
simple_client ( client_params
*par
)
593 test_params
*gen
= par
->general
;
595 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
597 id
= GetCurrentThreadId();
598 trace ( "simple_client (%x): starting\n", id
);
599 /* wait here because we want to call set_so_opentype before creating a socket */
600 WaitForSingleObject ( server_ready
, INFINITE
);
601 trace ( "simple_client (%x): server ready\n", id
);
603 check_so_opentype ();
604 set_so_opentype ( FALSE
); /* non-overlapped */
605 client_start ( par
);
606 mem
= TlsGetValue ( tls
);
609 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
610 0 ==, "simple_client (%x): connect error: %d\n" );
611 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
612 "simple_client (%x): failed to set blocking mode\n", id
);
613 trace ( "simple_client (%x) connected\n", id
);
615 /* send data to server */
616 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
);
617 ok ( n_sent
== n_expected
,
618 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
620 /* shutdown send direction */
621 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
623 /* Receive data echoed back & check it */
624 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, par
->buflen
);
625 ok ( n_recvd
== n_expected
,
626 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
629 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
630 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
633 read_zero_bytes ( mem
->s
);
634 trace ( "simple_client (%x) exiting\n", id
);
639 * simple_mixed_client: mixing send and recvfrom
641 static VOID WINAPI
simple_mixed_client ( client_params
*par
)
643 test_params
*gen
= par
->general
;
645 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
646 int fromLen
= sizeof(mem
->addr
);
647 struct sockaddr test
;
649 id
= GetCurrentThreadId();
650 trace ( "simple_client (%x): starting\n", id
);
651 /* wait here because we want to call set_so_opentype before creating a socket */
652 WaitForSingleObject ( server_ready
, INFINITE
);
653 trace ( "simple_client (%x): server ready\n", id
);
655 check_so_opentype ();
656 set_so_opentype ( FALSE
); /* non-overlapped */
657 client_start ( par
);
658 mem
= TlsGetValue ( tls
);
661 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
662 0 ==, "simple_client (%x): connect error: %d\n" );
663 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
664 "simple_client (%x): failed to set blocking mode\n", id
);
665 trace ( "simple_client (%x) connected\n", id
);
667 /* send data to server */
668 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
);
669 ok ( n_sent
== n_expected
,
670 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
672 /* shutdown send direction */
673 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
675 /* this shouldn't change, since lpFrom, is not updated on
676 connection oriented sockets - exposed by bug 11640
678 ((struct sockaddr_in
*)&test
)->sin_addr
.s_addr
= inet_addr("0.0.0.0");
680 /* Receive data echoed back & check it */
681 n_recvd
= do_synchronous_recvfrom ( mem
->s
,
685 (struct sockaddr
*)&test
,
688 ok ( n_recvd
== n_expected
,
689 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
691 /* check that lpFrom was not updated */
694 inet_ntoa(((struct sockaddr_in
*)&test
)->sin_addr
),
695 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
698 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
699 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
702 read_zero_bytes ( mem
->s
);
703 trace ( "simple_client (%x) exiting\n", id
);
708 * event_client: An event-driven client
710 static void WINAPI
event_client ( client_params
*par
)
712 test_params
*gen
= par
->general
;
714 int id
= GetCurrentThreadId(), n_expected
= gen
->n_chunks
* gen
->chunk_size
,
717 WSANETWORKEVENTS wsa_events
;
718 char *send_last
, *recv_last
, *send_p
, *recv_p
;
719 LONG mask
= FD_READ
| FD_WRITE
| FD_CLOSE
;
721 trace ( "event_client (%x): starting\n", id
);
722 client_start ( par
);
723 trace ( "event_client (%x): server ready\n", id
);
725 mem
= TlsGetValue ( tls
);
727 /* Prepare event notification for connect, makes socket nonblocking */
728 event
= WSACreateEvent ();
729 WSAEventSelect ( mem
->s
, event
, FD_CONNECT
);
730 tmp
= connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) );
732 err
= WSAGetLastError ();
733 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): connect error: %d\n", id
, err
);
734 tmp
= WaitForSingleObject ( event
, INFINITE
);
735 ok ( tmp
== WAIT_OBJECT_0
, "event_client (%x): wait for connect event failed: %d\n", id
, tmp
);
736 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
737 wsa_ok ( err
, 0 ==, "event_client (%x): WSAEnumNetworkEvents error: %d\n" );
738 err
= wsa_events
.iErrorCode
[ FD_CONNECT_BIT
];
739 ok ( err
== 0, "event_client (%x): connect error: %d\n", id
, err
);
743 trace ( "event_client (%x) connected\n", id
);
745 WSAEventSelect ( mem
->s
, event
, mask
);
747 recv_p
= mem
->recv_buf
;
748 recv_last
= mem
->recv_buf
+ n_expected
;
749 send_p
= mem
->send_buf
;
750 send_last
= mem
->send_buf
+ n_expected
;
754 err
= WaitForSingleObject ( event
, INFINITE
);
755 ok ( err
== WAIT_OBJECT_0
, "event_client (%x): wait failed\n", id
);
757 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
758 wsa_ok ( err
, 0 ==, "event_client (%x): WSAEnumNetworkEvents error: %d\n" );
760 if ( wsa_events
.lNetworkEvents
& FD_WRITE
)
762 err
= wsa_events
.iErrorCode
[ FD_WRITE_BIT
];
763 ok ( err
== 0, "event_client (%x): FD_WRITE error code: %d\n", id
, err
);
768 n
= send ( mem
->s
, send_p
, min ( send_last
- send_p
, par
->buflen
), 0 );
771 err
= WSAGetLastError ();
772 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): send error: %d\n", id
, err
);
777 while ( n
>= 0 && send_p
< send_last
);
779 if ( send_p
== send_last
)
781 trace ( "event_client (%x): all data sent - shutdown\n", id
);
782 shutdown ( mem
->s
, SD_SEND
);
784 WSAEventSelect ( mem
->s
, event
, mask
);
787 if ( wsa_events
.lNetworkEvents
& FD_READ
)
789 err
= wsa_events
.iErrorCode
[ FD_READ_BIT
];
790 ok ( err
== 0, "event_client (%x): FD_READ error code: %d\n", id
, err
);
791 if ( err
!= 0 ) break;
793 /* First read must succeed */
794 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
795 wsa_ok ( n
, 0 <=, "event_client (%x): recv error: %d\n" );
799 if ( recv_p
== recv_last
)
802 trace ( "event_client (%x): all data received\n", id
);
803 WSAEventSelect ( mem
->s
, event
, mask
);
806 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
807 if ( n
< 0 && ( err
= WSAGetLastError()) != WSAEWOULDBLOCK
)
808 ok ( 0, "event_client (%x): read error: %d\n", id
, err
);
812 if ( wsa_events
.lNetworkEvents
& FD_CLOSE
)
814 trace ( "event_client (%x): close event\n", id
);
815 err
= wsa_events
.iErrorCode
[ FD_CLOSE_BIT
];
816 ok ( err
== 0, "event_client (%x): FD_CLOSE error code: %d\n", id
, err
);
821 n
= send_p
- mem
->send_buf
;
822 ok ( send_p
== send_last
,
823 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n
, n_expected
);
824 n
= recv_p
- mem
->recv_buf
;
825 ok ( recv_p
== recv_last
,
826 "simple_client (%x): received less data than expected: %d of %d\n", id
, n
, n_expected
);
827 n
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
828 ok ( n
== -1, "event_client (%x): test pattern error: %d\n", id
, n
);
831 WSACloseEvent ( event
);
832 trace ( "event_client (%x) exiting\n", id
);
836 /* Tests for WSAStartup */
838 /* This should fail. WSAStartup should be called before any network function is used. */
839 static void test_WithoutWSAStartup(void)
843 WSASetLastError(0xdeadbeef);
844 ptr
= gethostbyname("localhost");
846 todo_wine
ok(ptr
== NULL
, "gethostbyname() succeeded unexpectedly: %d\n", WSAGetLastError());
847 todo_wine
ok(WSAGetLastError() == WSANOTINITIALISED
, "gethostbyname() failed with unexpected error: %d\n",
851 static void test_WithWSAStartup(void)
854 WORD version
= MAKEWORD( 2, 2 );
858 res
= WSAStartup( version
, &data
);
859 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
861 ptr
= gethostbyname("localhost");
862 ok(ptr
!= NULL
, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
867 /**************** Main program utility functions ***************/
869 static void Init (void)
871 WORD ver
= MAKEWORD (2, 2);
873 HMODULE hws2_32
= GetModuleHandle("ws2_32.dll");
875 pFreeAddrInfoW
= (void *)GetProcAddress(hws2_32
, "FreeAddrInfoW");
876 pGetAddrInfoW
= (void *)GetProcAddress(hws2_32
, "GetAddrInfoW");
877 pInetNtop
= (void *)GetProcAddress(hws2_32
, "inet_ntop");
879 ok ( WSAStartup ( ver
, &data
) == 0, "WSAStartup failed\n" );
883 static void Exit (void)
888 err
= WSAGetLastError();
889 ok ( ret
== 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret
, err
);
891 err
= WSAGetLastError();
892 ok ( (ret
== SOCKET_ERROR
&& err
== WSANOTINITIALISED
) ||
893 broken(ret
== 0), /* WinME */
894 "WSACleanup returned %d GetLastError is %d\n", ret
, err
);
897 static void StartServer (LPTHREAD_START_ROUTINE routine
,
898 test_params
*general
, server_params
*par
)
900 par
->general
= general
;
901 thread
[0] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[0] );
902 ok ( thread
[0] != NULL
, "Failed to create server thread\n" );
905 static void StartClients (LPTHREAD_START_ROUTINE routine
,
906 test_params
*general
, client_params
*par
)
909 par
->general
= general
;
910 for ( i
= 1; i
<= min ( general
->n_clients
, MAX_CLIENTS
); i
++ )
913 thread
[i
] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[i
] );
914 ok ( thread
[i
] != NULL
, "Failed to create client thread\n" );
915 /* Make sure the client is up and running */
916 WaitForSingleObject ( client_ready
[client_id
], INFINITE
);
920 static void do_test( test_setup
*test
)
922 DWORD i
, n
= min (test
->general
.n_clients
, MAX_CLIENTS
);
925 server_ready
= CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
926 for (i
= 0; i
<= n
; i
++)
927 client_ready
[i
] = CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
929 StartServer ( test
->srv
, &test
->general
, &test
->srv_params
);
930 StartClients ( test
->clt
, &test
->general
, &test
->clt_params
);
931 WaitForSingleObject ( server_ready
, INFINITE
);
933 wait
= WaitForMultipleObjects ( 1 + n
, thread
, TRUE
, 1000 * TEST_TIMEOUT
);
934 ok ( wait
<= WAIT_OBJECT_0
+ n
,
935 "some threads have not completed: %x\n", wait
);
937 if ( ! ( wait
<= WAIT_OBJECT_0
+ n
) )
939 for (i
= 0; i
<= n
; i
++)
941 if ( WaitForSingleObject ( thread
[i
], 0 ) != WAIT_OBJECT_0
)
943 trace ("terminating thread %08x\n", thread_id
[i
]);
944 TerminateThread ( thread
[i
], 0 );
948 CloseHandle ( server_ready
);
949 for (i
= 0; i
<= n
; i
++)
950 CloseHandle ( client_ready
[i
] );
953 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
954 /* optname = SO_LINGER */
955 static const LINGER linger_testvals
[] = {
962 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
963 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
964 bug in the linux kernel (fixed in 2.6.8) */
965 #define SOCKTIMEOUT2 997000 /* 997 seconds */
967 static void test_set_getsockopt(void)
975 s
= socket(AF_INET
, SOCK_STREAM
, 0);
976 ok(s
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
977 if( s
== INVALID_SOCKET
) return;
979 timeout
= SOCKTIMEOUT1
;
980 size
= sizeof(timeout
);
981 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
983 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
984 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
985 ok( timeout
== SOCKTIMEOUT1
, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
988 size
= sizeof(timeout
);
989 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
991 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
992 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
993 ok( timeout
== 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
996 timeout
= SOCKTIMEOUT2
; /* 997 seconds. See remark above */
997 size
= sizeof(timeout
);
998 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, size
);
1000 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, &size
);
1001 ok( !err
, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1002 ok( timeout
== SOCKTIMEOUT2
, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout
);
1004 for( i
= 0; i
< sizeof(linger_testvals
)/sizeof(LINGER
);i
++) {
1005 size
= sizeof(lingval
);
1006 lingval
= linger_testvals
[i
];
1007 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, size
);
1009 err
= getsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, &size
);
1010 ok( !err
, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1011 ok( !lingval
.l_onoff
== !linger_testvals
[i
].l_onoff
&&
1012 (lingval
.l_linger
== linger_testvals
[i
].l_linger
||
1013 (!lingval
.l_linger
&& !linger_testvals
[i
].l_onoff
))
1014 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i
,
1015 lingval
.l_onoff
, lingval
.l_linger
,
1016 linger_testvals
[i
].l_onoff
, linger_testvals
[i
].l_linger
);
1018 /* Test for erroneously passing a value instead of a pointer as optval */
1019 size
= sizeof(char);
1020 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTROUTE
, (char *)1, size
);
1021 ok(err
== SOCKET_ERROR
, "setsockopt with optval being a value passed "
1022 "instead of failing.\n");
1023 lasterr
= WSAGetLastError();
1024 ok(lasterr
== WSAEFAULT
, "setsockopt with optval being a value "
1025 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1026 lasterr
, WSAEFAULT
);
1028 /* SO_RCVTIMEO with invalid values for level */
1029 size
= sizeof(timeout
);
1030 timeout
= SOCKTIMEOUT1
;
1031 SetLastError(0xdeadbeef);
1032 err
= setsockopt(s
, 0xffffffff, SO_RCVTIMEO
, (char *) &timeout
, size
);
1033 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1034 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL\n",
1035 err
, WSAGetLastError());
1037 timeout
= SOCKTIMEOUT1
;
1038 SetLastError(0xdeadbeef);
1039 err
= setsockopt(s
, 0x00008000, SO_RCVTIMEO
, (char *) &timeout
, size
);
1040 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1041 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL\n",
1042 err
, WSAGetLastError());
1047 static void test_so_reuseaddr(void)
1049 struct sockaddr_in saddr
;
1051 unsigned int rc
,reuse
;
1054 saddr
.sin_family
= AF_INET
;
1055 saddr
.sin_port
= htons(9375);
1056 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1058 s1
=socket(AF_INET
, SOCK_STREAM
, 0);
1059 ok(s1
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1060 rc
= bind(s1
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1061 ok(rc
!=SOCKET_ERROR
, "bind(s1) failed error: %d\n", WSAGetLastError());
1063 s2
=socket(AF_INET
, SOCK_STREAM
, 0);
1064 ok(s2
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1068 rc
=getsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, &size
);
1069 ok(rc
==0 && reuse
==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc
,reuse
);
1071 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1072 ok(rc
==SOCKET_ERROR
, "bind() succeeded\n");
1075 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
1076 ok(rc
==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1078 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1079 * a port immediately after closing another socket on that port, so
1080 * basically following the BSD socket semantics here. */
1082 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1083 ok(rc
==0, "bind() failed error: %d\n", WSAGetLastError());
1088 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1090 static void test_ip_pktinfo(void)
1092 ULONG addresses
[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY
)};
1093 char recvbuf
[10], pktbuf
[512], msg
[] = "HELLO";
1094 struct sockaddr_in s1addr
, s2addr
, s3addr
;
1095 GUID WSARecvMsg_GUID
= WSAID_WSARECVMSG
;
1096 LPFN_WSARECVMSG pWSARecvMsg
= NULL
;
1097 unsigned int rc
, foundhdr
, yes
= 1;
1098 DWORD dwBytes
, dwSize
, dwFlags
;
1107 memset(&ov
, 0, sizeof(ov
));
1108 ov
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
1109 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
1111 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
1115 memset(&hdr
, 0x00, sizeof(hdr
));
1116 s1addr
.sin_family
= AF_INET
;
1117 s1addr
.sin_port
= htons(0);
1118 /* Note: s1addr.sin_addr is set below */
1119 iovec
[0].buf
= recvbuf
;
1120 iovec
[0].len
= sizeof(recvbuf
);
1121 hdr
.name
= (struct sockaddr
*)&s3addr
;
1122 hdr
.namelen
= sizeof(s3addr
);
1123 hdr
.lpBuffers
= &iovec
[0];
1124 hdr
.dwBufferCount
= 1;
1125 hdr
.Control
.buf
= pktbuf
;
1126 /* Note: hdr.Control.len is set below */
1129 for (i
=0;i
<sizeof(addresses
)/sizeof(UINT32
);i
++)
1131 s1addr
.sin_addr
.s_addr
= addresses
[i
];
1133 /* Build "server" side socket */
1134 s1
=socket(AF_INET
, SOCK_DGRAM
, 0);
1135 if (s1
== INVALID_SOCKET
)
1137 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1141 /* Obtain the WSARecvMsg function */
1142 WSAIoctl(s1
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
1143 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &dwBytes
, NULL
, NULL
);
1146 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
1151 /* Setup the server side socket */
1152 rc
=bind(s1
, (struct sockaddr
*)&s1addr
, sizeof(s1addr
));
1153 ok(rc
!= SOCKET_ERROR
, "bind() failed error: %d\n", WSAGetLastError());
1154 rc
=setsockopt(s1
, IPPROTO_IP
, IP_PKTINFO
, (const char*)&yes
, sizeof(yes
));
1155 ok(rc
== 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1157 /* Build "client" side socket */
1158 addrlen
= sizeof(s2addr
);
1159 if (getsockname(s1
, (struct sockaddr
*) &s2addr
, &addrlen
) != 0)
1161 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
1165 s2addr
.sin_addr
.s_addr
= addresses
[0]; /* Always target the local adapter address */
1166 s2
=socket(AF_INET
, SOCK_DGRAM
, 0);
1167 if (s2
== INVALID_SOCKET
)
1169 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1174 /* Test an empty message header */
1175 rc
=pWSARecvMsg(s1
, NULL
, NULL
, NULL
, NULL
);
1176 err
=WSAGetLastError();
1177 ok(rc
== SOCKET_ERROR
&& err
== WSAEFAULT
, "WSARecvMsg() failed error: %d (ret = %d)\n", err
, rc
);
1180 * Send a packet from the client to the server and test for specifying
1181 * a short control header.
1183 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1184 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1185 hdr
.Control
.len
= 1;
1186 rc
=pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
1187 err
=WSAGetLastError();
1188 ok(rc
== SOCKET_ERROR
&& err
== WSAEMSGSIZE
&& (hdr
.dwFlags
& MSG_CTRUNC
),
1189 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err
, rc
, hdr
.dwFlags
);
1190 hdr
.dwFlags
= 0; /* Reset flags */
1192 /* Perform another short control header test, this time with an overlapped receive */
1193 hdr
.Control
.len
= 1;
1194 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1195 err
=WSAGetLastError();
1196 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1197 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1198 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1199 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
1201 skip("Server side did not receive packet, some tests skipped.\n");
1207 WSAGetOverlappedResult(s1
, &ov
, NULL
, FALSE
, &dwFlags
);
1209 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags
);
1210 ok(hdr
.dwFlags
== MSG_CTRUNC
,
1211 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr
.dwFlags
);
1212 hdr
.dwFlags
= 0; /* Reset flags */
1215 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1216 * on the server end and check that the returned packet matches what was sent.
1218 hdr
.Control
.len
= sizeof(pktbuf
);
1219 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1220 err
=WSAGetLastError();
1221 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1222 ok(hdr
.Control
.len
== sizeof(pktbuf
),
1223 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr
.Control
.len
);
1224 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1225 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1226 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
1228 skip("Server side did not receive packet, some tests skipped.\n");
1234 WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, NULL
);
1235 ok(dwSize
== sizeof(msg
),
1236 "WSARecvMsg() buffer length does not match transmitted data!\n");
1237 ok(strncmp(iovec
[0].buf
, msg
, sizeof(msg
)) == 0,
1238 "WSARecvMsg() buffer does not match transmitted data!\n");
1239 ok(hdr
.Control
.len
== IP_PKTINFO_LEN
,
1240 "WSARecvMsg() control length mismatch (%d).\n", hdr
.Control
.len
);
1242 /* Test for the expected IP_PKTINFO return information. */
1244 for (cmsg
= WSA_CMSG_FIRSTHDR(&hdr
); cmsg
!= NULL
; cmsg
= WSA_CMSG_NXTHDR(&hdr
, cmsg
))
1246 if (cmsg
->cmsg_level
== IPPROTO_IP
&& cmsg
->cmsg_type
== IP_PKTINFO
)
1248 struct in_pktinfo
*pi
= (struct in_pktinfo
*)WSA_CMSG_DATA(cmsg
);
1250 ok(pi
->ipi_addr
.s_addr
== s2addr
.sin_addr
.s_addr
, "destination ip mismatch!\n");
1254 ok(foundhdr
, "IP_PKTINFO header information was not returned!\n");
1261 CloseHandle(ov
.hEvent
);
1264 /************* Array containing the tests to run **********/
1266 #define STD_STREAM_SOCKET \
1272 static test_setup tests
[NUM_TESTS
] =
1274 /* Test 0: synchronous client and server */
1295 /* Test 1: event-driven client, synchronous server */
1312 WSA_FLAG_OVERLAPPED
,
1316 /* Test 2: synchronous client, non-blocking server via select() */
1337 /* Test 3: synchronous mixed client and server */
1351 simple_mixed_client
,
1360 static void test_UDP(void)
1362 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
1363 possible that this test fails due to dropped packets. */
1365 /* peer 0 receives data from all other peers */
1366 struct sock_info peer
[NUM_UDP_PEERS
];
1368 int ss
, i
, n_recv
, n_sent
;
1370 memset (buf
,0,sizeof(buf
));
1371 for ( i
= NUM_UDP_PEERS
- 1; i
>= 0; i
-- ) {
1372 ok ( ( peer
[i
].s
= socket ( AF_INET
, SOCK_DGRAM
, 0 ) ) != INVALID_SOCKET
, "UDP: socket failed\n" );
1374 peer
[i
].addr
.sin_family
= AF_INET
;
1375 peer
[i
].addr
.sin_addr
.s_addr
= inet_addr ( SERVERIP
);
1378 peer
[i
].addr
.sin_port
= htons ( SERVERPORT
);
1380 peer
[i
].addr
.sin_port
= htons ( 0 );
1383 do_bind ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, sizeof( peer
[i
].addr
) );
1385 /* test getsockname() to get peer's port */
1386 ss
= sizeof ( peer
[i
].addr
);
1387 ok ( getsockname ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, &ss
) != SOCKET_ERROR
, "UDP: could not getsockname()\n" );
1388 ok ( peer
[i
].addr
.sin_port
!= htons ( 0 ), "UDP: bind() did not associate port\n" );
1391 /* test getsockname() */
1392 ok ( peer
[0].addr
.sin_port
== htons ( SERVERPORT
), "UDP: getsockname returned incorrect peer port\n" );
1394 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
1395 /* send client's ip */
1396 memcpy( buf
, &peer
[i
].addr
.sin_port
, sizeof(peer
[i
].addr
.sin_port
) );
1397 n_sent
= sendto ( peer
[i
].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*) &peer
[0].addr
, sizeof(peer
[0].addr
) );
1398 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
1401 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
1402 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0,(struct sockaddr
*) &peer
[0].peer
, &ss
);
1403 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
1404 ok ( memcmp ( &peer
[0].peer
.sin_port
, buf
, sizeof(peer
[0].addr
.sin_port
) ) == 0, "UDP: port numbers do not match\n" );
1408 static void WINAPI
do_getservbyname( HANDLE
*starttest
)
1414 } serv
[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
1417 struct servent
*pserv
[2];
1419 ok ( WaitForSingleObject ( *starttest
, TEST_TIMEOUT
* 1000 ) != WAIT_TIMEOUT
, "test_getservbyname: timeout waiting for start signal\n");
1421 /* ensure that necessary buffer resizes are completed */
1422 for ( j
= 0; j
< 2; j
++) {
1423 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
1426 for ( i
= 0; i
< NUM_QUERIES
/ 2; i
++ ) {
1427 for ( j
= 0; j
< 2; j
++ ) {
1428 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
1429 ok ( pserv
[j
] != NULL
, "getservbyname could not retrieve information for %s: %d\n", serv
[j
].name
, WSAGetLastError() );
1430 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
) );
1431 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
);
1432 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
);
1435 ok ( pserv
[0] == pserv
[1], "getservbyname: winsock resized servent buffer when not necessary\n" );
1439 static void test_getservbyname(void)
1442 HANDLE starttest
, thread
[NUM_THREADS
];
1443 DWORD thread_id
[NUM_THREADS
];
1445 starttest
= CreateEvent ( NULL
, 1, 0, "test_getservbyname_starttest" );
1447 /* create threads */
1448 for ( i
= 0; i
< NUM_THREADS
; i
++ ) {
1449 thread
[i
] = CreateThread ( NULL
, 0, (LPTHREAD_START_ROUTINE
) &do_getservbyname
, &starttest
, 0, &thread_id
[i
] );
1452 /* signal threads to start */
1453 SetEvent ( starttest
);
1455 for ( i
= 0; i
< NUM_THREADS
; i
++) {
1456 WaitForSingleObject ( thread
[i
], TEST_TIMEOUT
* 1000 );
1460 static void test_WSASocket(void)
1462 SOCKET sock
= INVALID_SOCKET
;
1463 WSAPROTOCOL_INFOA
*pi
;
1464 int providers
[] = {6, 0};
1468 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
1469 * to avoid a crash on win98.
1472 ret
= WSAEnumProtocolsA(providers
, NULL
, &pi_size
);
1473 ok(ret
== SOCKET_ERROR
, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
1475 err
= WSAGetLastError();
1476 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
1479 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
1480 ok(pi
!= NULL
, "Failed to allocate memory\n");
1482 skip("Can't continue without memory.\n");
1486 ret
= WSAEnumProtocolsA(providers
, pi
, &pi_size
);
1487 ok(ret
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
1491 skip("No protocols enumerated.\n");
1492 HeapFree(GetProcessHeap(), 0, pi
);
1496 sock
= WSASocketA(FROM_PROTOCOL_INFO
, FROM_PROTOCOL_INFO
,
1497 FROM_PROTOCOL_INFO
, &pi
[0], 0, 0);
1498 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1502 HeapFree(GetProcessHeap(), 0, pi
);
1505 static void test_WSAAddressToStringA(void)
1507 SOCKET v6
= INVALID_SOCKET
;
1511 SOCKADDR_IN sockaddr
;
1512 CHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1514 CHAR expect1
[] = "0.0.0.0";
1515 CHAR expect2
[] = "255.255.255.255";
1516 CHAR expect3
[] = "0.0.0.0:65535";
1517 CHAR expect4
[] = "255.255.255.255:65535";
1519 SOCKADDR_IN6 sockaddr6
;
1520 CHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
1522 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1523 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1524 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
1526 CHAR expect6_1
[] = "::1";
1527 CHAR expect6_2
[] = "20ab::1";
1528 CHAR expect6_3
[] = "[20ab::2001]:33274";
1529 CHAR expect6_3_nt
[] = "20ab::2001@33274";
1530 CHAR expect6_3_w2k
[] = "20ab::2001";
1531 CHAR expect6_3_2
[] = "[20ab::2001%4660]:33274";
1532 CHAR expect6_3_2_nt
[] = "4660/20ab::2001@33274";
1533 CHAR expect6_3_2_w2k
[] = "20ab::2001%4660";
1534 CHAR expect6_3_3
[] = "20ab::2001%4660";
1535 CHAR expect6_3_3_nt
[] = "4660/20ab::2001";
1539 sockaddr
.sin_family
= AF_INET
;
1540 sockaddr
.sin_port
= 0;
1541 sockaddr
.sin_addr
.s_addr
= 0;
1543 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1544 GLE
= WSAGetLastError();
1545 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
1546 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1549 len
= sizeof(address
);
1551 sockaddr
.sin_family
= AF_INET
;
1552 sockaddr
.sin_port
= 0;
1553 sockaddr
.sin_addr
.s_addr
= 0;
1555 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1556 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1558 ok( !strcmp( address
, expect1
), "Expected: %s, got: %s\n", expect1
, address
);
1559 ok( len
== sizeof( expect1
), "Got size %d\n", len
);
1561 len
= sizeof(address
);
1563 sockaddr
.sin_family
= AF_INET
;
1564 sockaddr
.sin_port
= 0;
1565 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
1567 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1568 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1570 ok( !strcmp( address
, expect2
), "Expected: %s, got: %s\n", expect2
, address
);
1572 len
= sizeof(address
);
1574 sockaddr
.sin_family
= AF_INET
;
1575 sockaddr
.sin_port
= 0xffff;
1576 sockaddr
.sin_addr
.s_addr
= 0;
1578 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1579 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1581 ok( !strcmp( address
, expect3
), "Expected: %s, got: %s\n", expect3
, address
);
1583 len
= sizeof(address
);
1585 sockaddr
.sin_family
= AF_INET
;
1586 sockaddr
.sin_port
= 0xffff;
1587 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
1589 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1590 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1592 ok( !strcmp( address
, expect4
), "Expected: %s, got: %s\n", expect4
, address
);
1593 ok( len
== sizeof( expect4
), "Got size %d\n", len
);
1595 /*check to see it IPv6 is available */
1596 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
1597 if (v6
== INVALID_SOCKET
) {
1598 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
1599 WSAGetLastError(), WSAEAFNOSUPPORT
);
1602 /* Test a short IPv6 address */
1603 len
= sizeof(address6
);
1605 sockaddr6
.sin6_family
= AF_INET6
;
1606 sockaddr6
.sin6_port
= 0x0000;
1607 sockaddr6
.sin6_scope_id
= 0;
1608 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
1610 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1611 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1612 ok( !strcmp( address6
, expect6_1
), "Expected: %s, got: %s\n", expect6_1
, address6
);
1613 ok( len
== sizeof(expect6_1
), "Got size %d\n", len
);
1615 /* Test a longer IPv6 address */
1616 len
= sizeof(address6
);
1618 sockaddr6
.sin6_family
= AF_INET6
;
1619 sockaddr6
.sin6_port
= 0x0000;
1620 sockaddr6
.sin6_scope_id
= 0;
1621 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
1623 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1624 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1625 ok( !strcmp( address6
, expect6_2
), "Expected: %s, got: %s\n", expect6_2
, address6
);
1626 ok( len
== sizeof(expect6_2
), "Got size %d\n", len
);
1628 /* Test IPv6 address and port number */
1629 len
= sizeof(address6
);
1631 sockaddr6
.sin6_family
= AF_INET6
;
1632 sockaddr6
.sin6_port
= 0xfa81;
1633 sockaddr6
.sin6_scope_id
= 0;
1634 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
1636 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1637 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1638 ok( !strcmp( address6
, expect6_3
) ||
1639 broken( !strcmp( address6
, expect6_3_nt
) ) || /* NT4 */
1640 broken( !strcmp( address6
, expect6_3_w2k
) ), /* Win2000 */
1641 "Expected: %s, got: %s\n", expect6_3
, address6
);
1642 ok( len
== sizeof(expect6_3
) ||
1643 broken( len
== sizeof(expect6_3_nt
) ) || /* NT4 */
1644 broken( len
== sizeof(expect6_3_w2k
) ), /* Win2000 */
1645 "Got size %d\n", len
);
1647 /* Test IPv6 address, port number and scope_id */
1648 len
= sizeof(address6
);
1650 sockaddr6
.sin6_family
= AF_INET6
;
1651 sockaddr6
.sin6_port
= 0xfa81;
1652 sockaddr6
.sin6_scope_id
= 0x1234;
1653 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
1655 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1656 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1657 ok( !strcmp( address6
, expect6_3_2
) ||
1658 broken( !strcmp( address6
, expect6_3_2_nt
) ) || /* NT4 */
1659 broken( !strcmp( address6
, expect6_3_2_w2k
) ), /* Win2000 */
1660 "Expected: %s, got: %s\n", expect6_3_2
, address6
);
1661 ok( len
== sizeof(expect6_3_2
) ||
1662 broken( len
== sizeof(expect6_3_2_nt
) ) || /* NT4 */
1663 broken( len
== sizeof(expect6_3_2_w2k
) ), /* Win2000 */
1664 "Got size %d\n", len
);
1666 /* Test IPv6 address and scope_id */
1667 len
= sizeof(address6
);
1669 sockaddr6
.sin6_family
= AF_INET6
;
1670 sockaddr6
.sin6_port
= 0x0000;
1671 sockaddr6
.sin6_scope_id
= 0x1234;
1672 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
1674 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1675 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1676 ok( !strcmp( address6
, expect6_3_3
) ||
1677 broken( !strcmp( address6
, expect6_3_3_nt
) ), /* NT4 */
1678 "Expected: %s, got: %s\n", expect6_3_3
, address6
);
1679 ok( len
== sizeof(expect6_3_3
) ||
1680 broken( len
== sizeof(expect6_3_3_nt
) ), /* NT4 */
1681 "Got size %d\n", len
);
1684 if (v6
!= INVALID_SOCKET
)
1688 static void test_WSAAddressToStringW(void)
1690 SOCKET v6
= INVALID_SOCKET
;
1694 SOCKADDR_IN sockaddr
;
1695 WCHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1697 WCHAR expect1
[] = { '0','.','0','.','0','.','0', 0 };
1698 WCHAR expect2
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1699 WCHAR expect3
[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
1700 WCHAR expect4
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1701 '6', '5', '5', '3', '5', 0 };
1703 SOCKADDR_IN6 sockaddr6
;
1704 WCHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
1706 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1707 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1708 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
1710 WCHAR expect6_1
[] = {':',':','1',0};
1711 WCHAR expect6_2
[] = {'2','0','a','b',':',':','1',0};
1712 WCHAR expect6_3
[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
1713 WCHAR expect6_3_nt
[] = {'2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
1714 WCHAR expect6_3_w2k
[] = {'2','0','a','b',':',':','2','0','0','1',0};
1715 WCHAR expect6_3_2
[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
1716 WCHAR expect6_3_2_nt
[] = {'4','6','6','0','/','2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
1717 WCHAR expect6_3_2_w2k
[] = {'2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',0};
1718 WCHAR expect6_3_3
[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
1719 WCHAR expect6_3_3_nt
[] = {'6','5','5','3','4','/','2','0','a','b',':',':','2','0','0','1',0};
1723 sockaddr
.sin_family
= AF_INET
;
1724 sockaddr
.sin_port
= 0;
1725 sockaddr
.sin_addr
.s_addr
= 0;
1727 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1728 GLE
= WSAGetLastError();
1729 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
1730 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1733 len
= sizeof(address
);
1735 sockaddr
.sin_family
= AF_INET
;
1736 sockaddr
.sin_port
= 0;
1737 sockaddr
.sin_addr
.s_addr
= 0;
1739 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1740 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1742 ok( !lstrcmpW( address
, expect1
), "Expected different address string\n" );
1743 ok( len
== sizeof( expect1
)/sizeof( WCHAR
), "Got size %d\n", len
);
1745 len
= sizeof(address
);
1747 sockaddr
.sin_family
= AF_INET
;
1748 sockaddr
.sin_port
= 0;
1749 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
1751 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1752 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1754 ok( !lstrcmpW( address
, expect2
), "Expected different address string\n" );
1756 len
= sizeof(address
);
1758 sockaddr
.sin_family
= AF_INET
;
1759 sockaddr
.sin_port
= 0xffff;
1760 sockaddr
.sin_addr
.s_addr
= 0;
1762 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1763 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1765 ok( !lstrcmpW( address
, expect3
), "Expected different address string\n" );
1767 len
= sizeof(address
);
1769 sockaddr
.sin_family
= AF_INET
;
1770 sockaddr
.sin_port
= 0xffff;
1771 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
1773 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1774 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1776 ok( !lstrcmpW( address
, expect4
), "Expected different address string\n" );
1777 ok( len
== sizeof( expect4
)/sizeof( WCHAR
), "Got %d\n", len
);
1779 /*check to see it IPv6 is available */
1780 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
1781 if (v6
== INVALID_SOCKET
) {
1782 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
1783 WSAGetLastError(), WSAEAFNOSUPPORT
);
1787 /* Test a short IPv6 address */
1788 len
= sizeof(address6
)/sizeof(WCHAR
);
1790 sockaddr6
.sin6_family
= AF_INET6
;
1791 sockaddr6
.sin6_port
= 0x0000;
1792 sockaddr6
.sin6_scope_id
= 0;
1793 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
1795 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1796 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1797 ok( !lstrcmpW( address6
, expect6_1
), "Wrong string returned\n" );
1798 ok( len
== sizeof(expect6_1
)/sizeof(WCHAR
), "Got %d\n", len
);
1800 /* Test a longer IPv6 address */
1801 len
= sizeof(address6
)/sizeof(WCHAR
);
1803 sockaddr6
.sin6_family
= AF_INET6
;
1804 sockaddr6
.sin6_port
= 0x0000;
1805 sockaddr6
.sin6_scope_id
= 0;
1806 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
1808 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1809 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1811 ok( !lstrcmpW( address6
, expect6_2
), "Wrong string returned\n" );
1812 ok( len
== sizeof(expect6_2
)/sizeof(WCHAR
), "Got %d\n", len
);
1814 /* Test IPv6 address and port number */
1815 len
= sizeof(address6
)/sizeof(WCHAR
);
1817 sockaddr6
.sin6_family
= AF_INET6
;
1818 sockaddr6
.sin6_port
= 0xfa81;
1819 sockaddr6
.sin6_scope_id
= 0;
1820 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
1822 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1823 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1824 ok( !lstrcmpW( address6
, expect6_3
) ||
1825 broken( !lstrcmpW( address6
, expect6_3_nt
) ) || /* NT4 */
1826 broken( !lstrcmpW( address6
, expect6_3_w2k
) ), /* Win2000 */
1827 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3
),
1828 wine_dbgstr_w(address6
) );
1829 ok( len
== sizeof(expect6_3
)/sizeof(WCHAR
) ||
1830 broken(len
== sizeof(expect6_3_nt
)/sizeof(WCHAR
) ) || /* NT4 */
1831 broken(len
== sizeof(expect6_3_w2k
)/sizeof(WCHAR
) ), /* Win2000 */
1834 /* Test IPv6 address, port number and scope_id */
1835 len
= sizeof(address6
)/sizeof(WCHAR
);
1837 sockaddr6
.sin6_family
= AF_INET6
;
1838 sockaddr6
.sin6_port
= 0xfa81;
1839 sockaddr6
.sin6_scope_id
= 0x1234;
1840 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
1842 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1843 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1844 ok( !lstrcmpW( address6
, expect6_3_2
) ||
1845 broken( !lstrcmpW( address6
, expect6_3_2_nt
) ) || /* NT4 */
1846 broken( !lstrcmpW( address6
, expect6_3_2_w2k
) ), /* Win2000 */
1847 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2
),
1848 wine_dbgstr_w(address6
) );
1849 ok( len
== sizeof(expect6_3_2
)/sizeof(WCHAR
) ||
1850 broken( len
== sizeof(expect6_3_2_nt
)/sizeof(WCHAR
) ) || /* NT4 */
1851 broken( len
== sizeof(expect6_3_2_w2k
)/sizeof(WCHAR
) ), /* Win2000 */
1854 /* Test IPv6 address and scope_id */
1855 len
= sizeof(address6
)/sizeof(WCHAR
);
1857 sockaddr6
.sin6_family
= AF_INET6
;
1858 sockaddr6
.sin6_port
= 0x0000;
1859 sockaddr6
.sin6_scope_id
= 0xfffe;
1860 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
1862 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1863 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1864 ok( !lstrcmpW( address6
, expect6_3_3
) ||
1865 broken( !lstrcmpW( address6
, expect6_3_3_nt
) ), /* NT4 */
1866 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3
),
1867 wine_dbgstr_w(address6
) );
1868 ok( len
== sizeof(expect6_3_3
)/sizeof(WCHAR
) ||
1869 broken( len
== sizeof(expect6_3_3_nt
)/sizeof(WCHAR
) ), /* NT4 */
1873 if (v6
!= INVALID_SOCKET
)
1877 static void test_WSAStringToAddressA(void)
1880 SOCKADDR_IN sockaddr
;
1881 SOCKADDR_IN6 sockaddr6
;
1884 CHAR address1
[] = "0.0.0.0";
1885 CHAR address2
[] = "127.127.127.127";
1886 CHAR address3
[] = "255.255.255.255";
1887 CHAR address4
[] = "127.127.127.127:65535";
1888 CHAR address5
[] = "255.255.255.255:65535";
1889 CHAR address6
[] = "::1";
1890 CHAR address7
[] = "[::1]";
1891 CHAR address8
[] = "[::1]:65535";
1894 sockaddr
.sin_family
= AF_INET
;
1896 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1897 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
1898 WSAGetLastError() );
1900 len
= sizeof(sockaddr
);
1901 sockaddr
.sin_port
= 0;
1902 sockaddr
.sin_addr
.s_addr
= 0;
1904 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1905 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
1906 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1908 len
= sizeof(sockaddr
);
1909 sockaddr
.sin_port
= 0;
1910 sockaddr
.sin_addr
.s_addr
= 0;
1912 ret
= WSAStringToAddressA( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1913 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
1914 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1916 len
= sizeof(sockaddr
);
1917 sockaddr
.sin_port
= 0;
1918 sockaddr
.sin_addr
.s_addr
= 0;
1920 ret
= WSAStringToAddressA( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1921 GLE
= WSAGetLastError();
1922 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
1923 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
1924 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
1926 len
= sizeof(sockaddr
);
1927 sockaddr
.sin_port
= 0;
1928 sockaddr
.sin_addr
.s_addr
= 0;
1930 ret
= WSAStringToAddressA( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1931 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
1932 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1934 len
= sizeof(sockaddr
);
1935 sockaddr
.sin_port
= 0;
1936 sockaddr
.sin_addr
.s_addr
= 0;
1938 ret
= WSAStringToAddressA( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
1939 GLE
= WSAGetLastError();
1940 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
1941 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
1942 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
1944 len
= sizeof(sockaddr6
);
1945 memset(&sockaddr6
, 0, len
);
1946 sockaddr6
.sin6_family
= AF_INET6
;
1948 ret
= WSAStringToAddressA( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
1950 GLE
= WSAGetLastError();
1951 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
1952 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
1954 len
= sizeof(sockaddr6
);
1955 memset(&sockaddr6
, 0, len
);
1956 sockaddr6
.sin6_family
= AF_INET6
;
1958 ret
= WSAStringToAddressA( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
1960 GLE
= WSAGetLastError();
1961 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
1962 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
1964 len
= sizeof(sockaddr6
);
1965 memset(&sockaddr6
, 0, len
);
1966 sockaddr6
.sin6_family
= AF_INET6
;
1968 ret
= WSAStringToAddressA( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
1970 GLE
= WSAGetLastError();
1971 ok( (ret
== 0 && sockaddr6
.sin6_port
== 0xffff) ||
1972 (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
1973 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
1977 static void test_WSAStringToAddressW(void)
1980 SOCKADDR_IN sockaddr
, *sin
;
1981 SOCKADDR_IN6 sockaddr6
;
1982 SOCKADDR_STORAGE sockaddr_storage
;
1985 WCHAR address1
[] = { '0','.','0','.','0','.','0', 0 };
1986 WCHAR address2
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
1987 WCHAR address3
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1988 WCHAR address4
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
1989 ':', '6', '5', '5', '3', '5', 0 };
1990 WCHAR address5
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1991 '6', '5', '5', '3', '5', 0 };
1992 WCHAR address6
[] = {':',':','1','\0'};
1993 WCHAR address7
[] = {'[',':',':','1',']','\0'};
1994 WCHAR address8
[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
1997 sockaddr
.sin_family
= AF_INET
;
1999 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2000 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressW() failed unexpectedly: %d\n",
2001 WSAGetLastError() );
2003 len
= sizeof(sockaddr
);
2004 sockaddr
.sin_port
= 0;
2005 sockaddr
.sin_addr
.s_addr
= 0;
2007 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2008 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
2009 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2011 len
= sizeof(sockaddr
);
2012 sockaddr
.sin_port
= 0;
2013 sockaddr
.sin_addr
.s_addr
= 0;
2015 ret
= WSAStringToAddressW( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2016 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
2017 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2019 len
= sizeof(sockaddr
);
2020 sockaddr
.sin_port
= 0;
2021 sockaddr
.sin_addr
.s_addr
= 0;
2023 ret
= WSAStringToAddressW( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2024 GLE
= WSAGetLastError();
2025 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
2026 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2027 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
2029 len
= sizeof(sockaddr
);
2030 sockaddr
.sin_port
= 0;
2031 sockaddr
.sin_addr
.s_addr
= 0;
2033 ret
= WSAStringToAddressW( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2034 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
2035 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2037 len
= sizeof(sockaddr
);
2038 sockaddr
.sin_port
= 0;
2039 sockaddr
.sin_addr
.s_addr
= 0;
2041 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2042 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
2043 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2044 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
2046 /* Test with a larger buffer than necessary */
2047 len
= sizeof(sockaddr_storage
);
2048 sin
= (SOCKADDR_IN
*)&sockaddr_storage
;
2050 sin
->sin_addr
.s_addr
= 0;
2052 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)sin
, &len
);
2053 ok( (ret
== 0 && sin
->sin_addr
.s_addr
== 0xffffffff && sin
->sin_port
== 0xffff) ||
2054 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2055 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
2056 ok( len
== sizeof(SOCKADDR_IN
) ||
2057 broken(len
== sizeof(SOCKADDR_STORAGE
)) /* NT4/2k */,
2058 "unexpected length %d\n", len
);
2060 len
= sizeof(sockaddr6
);
2061 memset(&sockaddr6
, 0, len
);
2062 sockaddr6
.sin6_family
= AF_INET6
;
2064 ret
= WSAStringToAddressW( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2066 GLE
= WSAGetLastError();
2067 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2068 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
2070 len
= sizeof(sockaddr6
);
2071 memset(&sockaddr6
, 0, len
);
2072 sockaddr6
.sin6_family
= AF_INET6
;
2074 ret
= WSAStringToAddressW( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2076 GLE
= WSAGetLastError();
2077 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2078 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
2080 len
= sizeof(sockaddr6
);
2081 memset(&sockaddr6
, 0, len
);
2082 sockaddr6
.sin6_family
= AF_INET6
;
2084 ret
= WSAStringToAddressW( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2086 GLE
= WSAGetLastError();
2087 ok( (ret
== 0 && sockaddr6
.sin6_port
== 0xffff) ||
2088 (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2089 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
2093 static VOID WINAPI
SelectReadThread(select_thread_params
*par
)
2097 struct sockaddr_in addr
;
2098 struct timeval select_timeout
;
2101 FD_SET(par
->s
, &readfds
);
2102 select_timeout
.tv_sec
=5;
2103 select_timeout
.tv_usec
=0;
2104 addr
.sin_family
= AF_INET
;
2105 addr
.sin_addr
.s_addr
= inet_addr(SERVERIP
);
2106 addr
.sin_port
= htons(SERVERPORT
);
2108 do_bind(par
->s
, (struct sockaddr
*)&addr
, sizeof(addr
));
2109 wsa_ok(listen(par
->s
, SOMAXCONN
), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
2111 SetEvent(server_ready
);
2112 ret
= select(par
->s
+1, &readfds
, NULL
, NULL
, &select_timeout
);
2113 par
->ReadKilled
= (ret
== 1);
2116 static void test_select(void)
2118 SOCKET fdRead
, fdWrite
;
2119 fd_set readfds
, writefds
, exceptfds
;
2122 struct timeval select_timeout
;
2123 select_thread_params thread_params
;
2124 HANDLE thread_handle
;
2127 fdRead
= socket(AF_INET
, SOCK_STREAM
, 0);
2128 ok( (fdRead
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2129 fdWrite
= socket(AF_INET
, SOCK_STREAM
, 0);
2130 ok( (fdWrite
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2134 FD_ZERO(&exceptfds
);
2135 FD_SET(fdRead
, &readfds
);
2136 FD_SET(fdWrite
, &writefds
);
2137 FD_SET(fdRead
, &exceptfds
);
2138 FD_SET(fdWrite
, &exceptfds
);
2139 select_timeout
.tv_sec
=0;
2140 select_timeout
.tv_usec
=500;
2143 if (fdWrite
> maxfd
)
2147 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2148 ok ( (ret
== 0), "select should not return any socket handles\n");
2149 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
2150 ok ( !FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
2153 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
2154 ok ( !FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
2157 ok ((listen(fdWrite
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
2159 ret
= closesocket(fdWrite
);
2160 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
2162 thread_params
.s
= fdRead
;
2163 thread_params
.ReadKilled
= FALSE
;
2164 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
2165 thread_handle
= CreateThread (NULL
, 0, (LPTHREAD_START_ROUTINE
) &SelectReadThread
, &thread_params
, 0, &id
);
2166 ok ( (thread_handle
!= NULL
), "CreateThread failed unexpectedly: %d\n", GetLastError());
2168 WaitForSingleObject (server_ready
, INFINITE
);
2170 ret
= closesocket(fdRead
);
2171 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
2173 WaitForSingleObject (thread_handle
, 1000);
2174 ok ( (thread_params
.ReadKilled
) ||
2175 broken(thread_params
.ReadKilled
== 0), /*Win98*/
2176 "closesocket did not wakeup select\n");
2178 /* Test selecting invalid handles */
2181 FD_ZERO(&exceptfds
);
2184 ret
= select(maxfd
+1, 0, 0, 0, &select_timeout
);
2185 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2186 ok ( GetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", ret
);
2189 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2190 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2191 ok ( GetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", ret
);
2193 FD_SET(INVALID_SOCKET
, &readfds
);
2195 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2196 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2197 ok ( GetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", ret
);
2198 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
2201 FD_SET(INVALID_SOCKET
, &writefds
);
2203 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2204 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2205 ok ( GetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", ret
);
2206 ok ( !FD_ISSET(fdRead
, &writefds
), "FD should not be set\n");
2209 FD_SET(INVALID_SOCKET
, &exceptfds
);
2211 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2212 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2213 ok ( GetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", ret
);
2214 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
2217 static DWORD WINAPI
AcceptKillThread(select_thread_params
*par
)
2219 struct sockaddr_in address
;
2220 int len
= sizeof(address
);
2221 SOCKET client_socket
;
2223 SetEvent(server_ready
);
2224 client_socket
= accept(par
->s
, (struct sockaddr
*) &address
, &len
);
2225 if (client_socket
!= INVALID_SOCKET
)
2226 closesocket(client_socket
);
2227 par
->ReadKilled
= (client_socket
== INVALID_SOCKET
);
2232 static int CALLBACK
AlwaysDeferConditionFunc(LPWSABUF lpCallerId
, LPWSABUF lpCallerData
, LPQOS pQos
,
2233 LPQOS lpGQOS
, LPWSABUF lpCalleeId
, LPWSABUF lpCalleeData
,
2234 GROUP FAR
* g
, DWORD_PTR dwCallbackData
)
2239 static void test_accept(void)
2242 SOCKET server_socket
= INVALID_SOCKET
, accepted
= INVALID_SOCKET
, connector
= INVALID_SOCKET
;
2243 struct sockaddr_in address
;
2245 select_thread_params thread_params
;
2246 HANDLE thread_handle
= NULL
;
2249 server_socket
= socket(AF_INET
, SOCK_STREAM
, 0);
2250 if (server_socket
== INVALID_SOCKET
)
2252 trace("error creating server socket: %d\n", WSAGetLastError());
2256 memset(&address
, 0, sizeof(address
));
2257 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2258 address
.sin_family
= AF_INET
;
2259 ret
= bind(server_socket
, (struct sockaddr
*) &address
, sizeof(address
));
2262 trace("error binding server socket: %d\n", WSAGetLastError());
2266 socklen
= sizeof(address
);
2267 ret
= getsockname(server_socket
, (struct sockaddr
*)&address
, &socklen
);
2269 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
2273 ret
= listen(server_socket
, 5);
2276 trace("error making server socket listen: %d\n", WSAGetLastError());
2280 trace("Blocking accept next\n");
2282 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
2283 ok(connector
!= INVALID_SOCKET
, "Failed to create connector socket, error %d\n", WSAGetLastError());
2285 ret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
2286 ok(ret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
2288 accepted
= WSAAccept(server_socket
, NULL
, NULL
, (LPCONDITIONPROC
) AlwaysDeferConditionFunc
, 0);
2289 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
2291 accepted
= accept(server_socket
, NULL
, 0);
2292 ok(accepted
!= INVALID_SOCKET
, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
2294 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
2295 if (server_ready
== INVALID_HANDLE_VALUE
)
2297 trace("error creating event: %d\n", GetLastError());
2301 thread_params
.s
= server_socket
;
2302 thread_params
.ReadKilled
= FALSE
;
2303 thread_handle
= CreateThread(NULL
, 0, (LPTHREAD_START_ROUTINE
) AcceptKillThread
,
2304 &thread_params
, 0, &id
);
2305 if (thread_handle
== NULL
)
2307 trace("error creating thread: %d\n", GetLastError());
2311 WaitForSingleObject(server_ready
, INFINITE
);
2313 ret
= closesocket(server_socket
);
2316 trace("closesocket failed: %d\n", WSAGetLastError());
2320 WaitForSingleObject(thread_handle
, 1000);
2321 ok(thread_params
.ReadKilled
|| broken(!thread_params
.ReadKilled
) /* Win98/ME, after accept */,
2322 "closesocket did not wakeup accept\n");
2325 if (accepted
!= INVALID_SOCKET
)
2326 closesocket(accepted
);
2327 if (connector
!= INVALID_SOCKET
)
2328 closesocket(connector
);
2329 if (thread_handle
!= NULL
)
2330 CloseHandle(thread_handle
);
2331 if (server_ready
!= INVALID_HANDLE_VALUE
)
2332 CloseHandle(server_ready
);
2333 if (server_socket
!= INVALID_SOCKET
)
2334 closesocket(server_socket
);
2337 static void test_extendedSocketOptions(void)
2341 struct sockaddr_in sa
;
2342 int sa_len
= sizeof(struct sockaddr_in
);
2343 int optval
, optlen
= sizeof(int), ret
;
2347 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
2348 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
2352 memset(&sa
, 0, sa_len
);
2354 sa
.sin_family
= AF_INET
;
2355 sa
.sin_port
= htons(0);
2356 sa
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
2358 if((sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
2359 trace("Creating the socket failed: %d\n", WSAGetLastError());
2364 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
2365 trace("Failed to bind socket: %d\n", WSAGetLastError());
2371 ret
= getsockopt(sock
, SOL_SOCKET
, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
2373 ok(ret
== 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret
);
2374 ok((optval
== 65507) || (optval
== 65527),
2375 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval
);
2377 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
2378 SetLastError(0xdeadbeef);
2379 optval
= 0xdeadbeef;
2380 optlen
= sizeof(int);
2381 ret
= getsockopt(sock
, 0xffffffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
2382 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
2383 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2384 ret
, WSAGetLastError(), optval
, optval
);
2386 /* more invalid values for level */
2387 SetLastError(0xdeadbeef);
2388 optval
= 0xdeadbeef;
2389 optlen
= sizeof(int);
2390 ret
= getsockopt(sock
, 0x1234ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
2391 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
2392 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2393 ret
, WSAGetLastError(), optval
, optval
);
2395 SetLastError(0xdeadbeef);
2396 optval
= 0xdeadbeef;
2397 optlen
= sizeof(int);
2398 ret
= getsockopt(sock
, 0x8000ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
2399 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
2400 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2401 ret
, WSAGetLastError(), optval
, optval
);
2403 SetLastError(0xdeadbeef);
2404 optval
= 0xdeadbeef;
2405 optlen
= sizeof(int);
2406 ret
= getsockopt(sock
, 0x00008000, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
2407 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
2408 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2409 ret
, WSAGetLastError(), optval
, optval
);
2411 SetLastError(0xdeadbeef);
2412 optval
= 0xdeadbeef;
2413 optlen
= sizeof(int);
2414 ret
= getsockopt(sock
, 0x00000800, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
2415 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
2416 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2417 ret
, WSAGetLastError(), optval
, optval
);
2419 optlen
= sizeof(LINGER
);
2420 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
2422 ok(ret
== SOCKET_ERROR
, "getsockopt should fail for UDP sockets but return value is 0x%08x\n", ret
);
2427 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
2428 trace("Creating the socket failed: %d\n", WSAGetLastError());
2433 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
2434 trace("Failed to bind socket: %d\n", WSAGetLastError());
2440 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
2441 ok(ret
== 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret
);
2443 optlen
= sizeof(BOOL
);
2444 ret
= getsockopt(sock
, SOL_SOCKET
, SO_DONTLINGER
, (char *)&bool_opt_val
, &optlen
);
2445 ok(ret
== 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret
);
2446 ok((linger_val
.l_onoff
&& !bool_opt_val
) || (!linger_val
.l_onoff
&& bool_opt_val
),
2447 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
2448 bool_opt_val
, linger_val
.l_onoff
);
2454 static void test_getsockname(void)
2458 struct sockaddr_in sa_set
, sa_get
;
2459 int sa_set_len
= sizeof(struct sockaddr_in
);
2460 int sa_get_len
= sa_set_len
;
2461 static const unsigned char null_padding
[] = {0,0,0,0,0,0,0,0};
2464 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
2465 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
2469 memset(&sa_set
, 0, sa_set_len
);
2471 sa_set
.sin_family
= AF_INET
;
2472 sa_set
.sin_port
= htons(0);
2473 sa_set
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
2475 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
2476 trace("Creating the socket failed: %d\n", WSAGetLastError());
2481 memcpy(&sa_get
, &sa_set
, sizeof(sa_set
));
2482 if (getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) == 0)
2483 ok(0, "getsockname on unbound socket should fail\n");
2485 ok(WSAGetLastError() == WSAEINVAL
, "getsockname on unbound socket "
2486 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL
);
2487 ok(memcmp(&sa_get
, &sa_set
, sizeof(sa_get
)) == 0,
2488 "failed getsockname modified sockaddr when it shouldn't\n");
2491 if(bind(sock
, (struct sockaddr
*) &sa_set
, sa_set_len
) < 0){
2492 trace("Failed to bind socket: %d\n", WSAGetLastError());
2498 if(getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) != 0){
2499 trace("Failed to call getsockname: %d\n", WSAGetLastError());
2505 ret
= memcmp(sa_get
.sin_zero
, null_padding
, 8);
2506 ok(ret
== 0 || broken(ret
!= 0), /* NT4 */
2507 "getsockname did not zero the sockaddr_in structure\n");
2513 static void test_dns(void)
2517 h
= gethostbyname("");
2518 ok(h
!= NULL
, "gethostbyname(\"\") failed with %d\n", h_errno
);
2521 /* Our winsock headers don't define gethostname because it conflicts with the
2522 * definition in unistd.h. Define it here to get rid of the warning. */
2524 int WINAPI
gethostname(char *name
, int namelen
);
2526 static void test_gethostbyname_hack(void)
2530 static BYTE loopback
[] = {127, 0, 0, 1};
2531 static BYTE magic_loopback
[] = {127, 12, 34, 56};
2534 ret
= gethostname(name
, 256);
2535 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
2537 he
= gethostbyname("localhost");
2538 ok(he
!= NULL
, "gethostbyname(\"localhost\") failed: %d\n", h_errno
);
2541 if(he
->h_length
!= 4)
2543 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
2547 ok(memcmp(he
->h_addr_list
[0], loopback
, he
->h_length
) == 0,
2548 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
2549 he
->h_addr_list
[0][0], he
->h_addr_list
[0][1], he
->h_addr_list
[0][2],
2550 he
->h_addr_list
[0][3]);
2553 /* No reason to test further with NULL hostname */
2557 if(strcmp(name
, "localhost") == 0)
2559 skip("hostname seems to be \"localhost\", skipping test.\n");
2564 he
= gethostbyname(name
);
2565 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, h_errno
);
2568 if(he
->h_length
!= 4)
2570 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
2574 if (he
->h_addr_list
[0][0] == 127)
2576 ok(memcmp(he
->h_addr_list
[0], magic_loopback
, he
->h_length
) == 0,
2577 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
2578 name
, he
->h_addr_list
[0][0], he
->h_addr_list
[0][1],
2579 he
->h_addr_list
[0][2], he
->h_addr_list
[0][3]);
2584 he
= gethostbyname("nonexistent.winehq.org");
2585 /* Don't check for the return value, as some braindead ISPs will kindly
2586 * resolve nonexistent host names to addresses of the ISP's spam pages. */
2589 static void test_inet_addr(void)
2593 addr
= inet_addr(NULL
);
2594 ok(addr
== INADDR_NONE
, "inet_addr succeeded unexpectedly\n");
2597 static void test_addr_to_print(void)
2603 struct in6_addr in6
;
2605 u_long addr0_Num
= 0x00000000;
2606 PCSTR addr0_Str
= "0.0.0.0";
2607 u_long addr1_Num
= 0x20201015;
2608 PCSTR addr1_Str
= "21.16.32.32";
2609 u_char addr2_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
2610 PCSTR addr2_Str
= "::fffe:cc98:bd74";
2611 u_char addr3_Num
[16] = {0x20,0x30,0xa4,0xb1};
2612 PCSTR addr3_Str
= "2030:a4b1::";
2613 u_char addr4_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
2614 PCSTR addr4_Str
= "::204.152.189.116";
2616 /* Test IPv4 addresses */
2617 in
.s_addr
= addr0_Num
;
2619 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
2620 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
2621 ok(!strcmp(pdst
, addr0_Str
),"Address %s != %s\n", pdst
, addr0_Str
);
2623 /* Test that inet_ntoa and inet_ntop return the same value */
2624 in
.S_un
.S_addr
= addr1_Num
;
2625 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
2626 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
2627 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
2629 /* InetNtop became available in Vista and Win2008 */
2632 win_skip("InetNtop not present, not executing tests\n");
2636 /* Second part of test */
2637 pdst
= pInetNtop(AF_INET
,(void*)&in
.s_addr
, dst
, sizeof(dst
));
2638 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst
);
2639 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
2641 /* Test invalid parm conditions */
2642 pdst
= pInetNtop(1, (void*)&in
.s_addr
, dst
, sizeof(dst
));
2643 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2644 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "Should be WSAEAFNOSUPPORT\n");
2646 /* Test Null destination */
2648 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, NULL
, sizeof(dst
));
2649 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2650 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
2651 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2653 /* Test zero length passed */
2656 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 0);
2657 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2658 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
2659 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2661 /* Test length one shorter than the address length */
2664 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 6);
2665 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2666 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
2667 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2669 /* Test longer length is ok */
2672 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, sizeof(dst
)+1);
2673 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
2674 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
2676 /* Test the IPv6 addresses */
2678 /* Test an zero prefixed IPV6 address */
2679 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
2680 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
2681 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
2682 ok(!strcmp(pdst
, addr2_Str
),"Address %s != %s\n", pdst
, addr2_Str
);
2684 /* Test an zero suffixed IPV6 address */
2685 memcpy(in6
.s6_addr
, addr3_Num
, sizeof(addr3_Num
));
2686 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
2687 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
2688 ok(!strcmp(pdst
, addr3_Str
),"Address %s != %s\n", pdst
, addr3_Str
);
2690 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
2691 memcpy(in6
.s6_addr
, addr4_Num
, sizeof(addr4_Num
));
2692 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
2693 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
2694 ok(!strcmp(pdst
, addr4_Str
),"Address %s != %s\n", pdst
, addr4_Str
);
2696 /* Test invalid parm conditions */
2697 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
2699 /* Test Null destination */
2701 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, NULL
, sizeof(dst6
));
2702 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2703 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
2704 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2706 /* Test zero length passed */
2709 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 0);
2710 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2711 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
2712 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2714 /* Test length one shorter than the address length */
2717 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 16);
2718 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2719 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
2720 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2722 /* Test longer length is ok */
2725 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 18);
2726 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
2729 static void test_ioctlsocket(void)
2733 static const LONG cmds
[] = {FIONBIO
, FIONREAD
, SIOCATMARK
};
2737 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
2738 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
2739 if(sock
== INVALID_SOCKET
)
2741 skip("Can't continue without a socket.\n");
2745 for(i
= 0; i
< sizeof(cmds
)/sizeof(cmds
[0]); i
++)
2747 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
2748 ret
= ioctlsocket(sock
, cmds
[i
], (u_long
*)1);
2749 ok(ret
== SOCKET_ERROR
, "ioctlsocket succeeded unexpectedly\n");
2750 ret
= WSAGetLastError();
2751 ok(ret
== WSAEFAULT
, "expected WSAEFAULT, got %d instead\n", ret
);
2754 /* A fresh and not connected socket has no urgent data, this test shows
2755 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
2757 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
2758 if(ret
!= SOCKET_ERROR
)
2759 todo_wine
ok(arg
, "expected a non-zero value\n");
2762 static int drain_pause
=0;
2763 static DWORD WINAPI
drain_socket_thread(LPVOID arg
)
2766 SOCKET sock
= *(SOCKET
*)arg
;
2769 while ((ret
= recv(sock
, buffer
, sizeof(buffer
), 0)) != 0)
2773 if (WSAGetLastError() == WSAEWOULDBLOCK
)
2777 FD_SET(sock
, &readset
);
2778 select(0, &readset
, NULL
, NULL
, NULL
);
2789 static void test_send(void)
2791 SOCKET src
= INVALID_SOCKET
;
2792 SOCKET dst
= INVALID_SOCKET
;
2793 HANDLE hThread
= NULL
;
2794 const int buflen
= 1024*1024;
2795 char *buffer
= NULL
;
2796 int ret
, i
, zero
= 0;
2800 DWORD id
, bytes_sent
, dwRet
;
2802 memset(&ov
, 0, sizeof(ov
));
2804 if (tcp_socketpair(&src
, &dst
) != 0)
2806 ok(0, "creating socket pair failed, skipping test\n");
2810 set_blocking(dst
, FALSE
);
2811 /* force disable buffering so we can get a pending overlapped request */
2812 ret
= setsockopt(dst
, SOL_SOCKET
, SO_SNDBUF
, (char *) &zero
, sizeof(zero
));
2813 ok(!ret
, "setsockopt SO_SNDBUF failed: %d - %d\n", ret
, GetLastError());
2815 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
2816 if (hThread
== NULL
)
2818 ok(0, "CreateThread failed, error %d\n", GetLastError());
2822 buffer
= HeapAlloc(GetProcessHeap(), 0, buflen
);
2825 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
2829 /* fill the buffer with some nonsense */
2830 for (i
= 0; i
< buflen
; ++i
)
2832 buffer
[i
] = (char) i
;
2835 ret
= send(src
, buffer
, buflen
, 0);
2837 ok(ret
== buflen
, "send should have sent %d bytes, but it only sent %d\n", buflen
, ret
);
2839 ok(0, "send failed, error %d\n", WSAGetLastError());
2844 ov
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
2845 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
2850 ret
= WSASend(dst
, &buf
, 1, &bytes_sent
, 0, &ov
, NULL
);
2851 todo_wine
ok((ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
) || broken(bytes_sent
== buflen
),
2852 "Failed to start overlapped send %d - %d - %d/%d\n", ret
, WSAGetLastError(), bytes_sent
, buflen
);
2853 if ( (ret
!= SOCKET_ERROR
|| GetLastError() != ERROR_IO_PENDING
) && bytes_sent
< buflen
)
2856 /* don't check for completion yet, we may need to drain the buffer while still sending */
2857 set_blocking(src
, FALSE
);
2858 for (i
= 0; i
< buflen
; ++i
)
2862 ret
= recv(src
, buffer
, 1, 0);
2863 while (ret
== SOCKET_ERROR
&& GetLastError() == WSAEWOULDBLOCK
&& j
< 100)
2867 ret
= recv(src
, buffer
, 1, 0);
2870 ok(ret
== 1, "Failed to receive data %d - %d (got %d/%d)\n", ret
, GetLastError(), i
, buflen
);
2874 ok(buffer
[0] == (char) i
, "Received bad data at position %d\n", i
);
2877 dwRet
= WaitForSingleObject(ov
.hEvent
, 1000);
2878 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
2879 if (dwRet
== WAIT_OBJECT_0
)
2881 bret
= GetOverlappedResult((HANDLE
)dst
, &ov
, &bytes_sent
, FALSE
);
2882 ok((bret
&& bytes_sent
== buflen
) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
2883 "Got %d instead of %d (%d - %d)\n", bytes_sent
, buflen
, bret
, GetLastError());
2887 if (src
!= INVALID_SOCKET
)
2889 if (dst
!= INVALID_SOCKET
)
2891 if (hThread
!= NULL
)
2892 CloseHandle(hThread
);
2894 CloseHandle(ov
.hEvent
);
2895 HeapFree(GetProcessHeap(), 0, buffer
);
2898 typedef struct async_message
2902 struct async_message
*next
;
2905 static struct async_message
*messages_received
;
2907 #define WM_SOCKET (WM_USER+100)
2908 static LRESULT CALLBACK
ws2_test_WndProc(HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
2910 struct async_message
*message
;
2915 message
= HeapAlloc(GetProcessHeap(), 0, sizeof(*message
));
2916 message
->socket
= (SOCKET
) wparam
;
2917 message
->lparam
= lparam
;
2918 message
->next
= NULL
;
2920 if (messages_received
)
2922 struct async_message
*last
= messages_received
;
2923 while (last
->next
) last
= last
->next
;
2924 last
->next
= message
;
2927 messages_received
= message
;
2931 return DefWindowProc(hwnd
, msg
, wparam
, lparam
);
2934 static void get_event_details(int event
, int *bit
, char *name
)
2939 if (bit
) *bit
= FD_ACCEPT_BIT
;
2940 if (name
) strcpy(name
, "FD_ACCEPT");
2943 if (bit
) *bit
= FD_CONNECT_BIT
;
2944 if (name
) strcpy(name
, "FD_CONNECT");
2947 if (bit
) *bit
= FD_READ_BIT
;
2948 if (name
) strcpy(name
, "FD_READ");
2951 if (bit
) *bit
= FD_OOB_BIT
;
2952 if (name
) strcpy(name
, "FD_OOB");
2955 if (bit
) *bit
= FD_WRITE_BIT
;
2956 if (name
) strcpy(name
, "FD_WRITE");
2959 if (bit
) *bit
= FD_CLOSE_BIT
;
2960 if (name
) strcpy(name
, "FD_CLOSE");
2964 if (name
) sprintf(name
, "bad%x", event
);
2968 static const char *dbgstr_event_seq(const LPARAM
*seq
)
2970 static char message
[1024];
2978 get_event_details(WSAGETSELECTEVENT(*seq
), NULL
, name
);
2979 len
+= sprintf(message
+ len
, "%s(%d) ", name
, WSAGETSELECTERROR(*seq
));
2983 strcpy( message
+ len
, "]" );
2987 static char *dbgstr_event_seq_result(SOCKET s
, WSANETWORKEVENTS
*netEvents
)
2989 static char message
[1024];
2990 struct async_message
*curr
= messages_received
;
2991 int index
, error
, bit
= 0;
3001 if (bit
>= FD_MAX_EVENTS
) break;
3002 if ( !(netEvents
->lNetworkEvents
& (1 << bit
)) )
3007 get_event_details(1 << bit
, &index
, name
);
3008 error
= netEvents
->iErrorCode
[index
];
3014 if (curr
->socket
!= s
)
3019 get_event_details(WSAGETSELECTEVENT(curr
->lparam
), NULL
, name
);
3020 error
= WSAGETSELECTERROR(curr
->lparam
);
3024 len
+= sprintf(message
+ len
, "%s(%d) ", name
, error
);
3027 strcpy( message
+ len
, "]" );
3031 static void flush_events(SOCKET s
, HANDLE hEvent
)
3033 WSANETWORKEVENTS netEvents
;
3034 struct async_message
*prev
= NULL
, *curr
= messages_received
;
3038 if (hEvent
!= INVALID_HANDLE_VALUE
)
3040 dwRet
= WaitForSingleObject(hEvent
, 100);
3041 if (dwRet
== WAIT_OBJECT_0
)
3043 ret
= WSAEnumNetworkEvents(s
, hEvent
, &netEvents
);
3045 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
3052 if (curr
->socket
== s
)
3054 if (prev
) prev
->next
= curr
->next
;
3055 else messages_received
= curr
->next
;
3057 HeapFree(GetProcessHeap(), 0, curr
);
3059 if (prev
) curr
= prev
->next
;
3060 else curr
= messages_received
;
3071 static int match_event_sequence(SOCKET s
, WSANETWORKEVENTS
*netEvents
, const LPARAM
*seq
)
3073 int event
, index
, error
, events
;
3074 struct async_message
*curr
;
3078 events
= netEvents
->lNetworkEvents
;
3081 event
= WSAGETSELECTEVENT(*seq
);
3082 error
= WSAGETSELECTERROR(*seq
);
3083 get_event_details(event
, &index
, NULL
);
3085 if (!(events
& event
) && index
!= -1)
3087 if (events
& event
&& index
!= -1)
3089 if (netEvents
->iErrorCode
[index
] != error
)
3100 curr
= messages_received
;
3103 if (curr
->socket
== s
)
3105 if (!*seq
) return 0;
3106 if (*seq
!= curr
->lparam
) return 0;
3117 /* checks for a sequence of events, (order only checked if window is used) */
3118 static void ok_event_sequence(SOCKET s
, HANDLE hEvent
, const LPARAM
*seq
, const LPARAM
**broken_seqs
, int completelyBroken
)
3121 WSANETWORKEVENTS events
, *netEvents
= NULL
;
3125 if (hEvent
!= INVALID_HANDLE_VALUE
)
3127 netEvents
= &events
;
3129 dwRet
= WaitForSingleObject(hEvent
, 200);
3130 if (dwRet
== WAIT_OBJECT_0
)
3132 ret
= WSAEnumNetworkEvents(s
, hEvent
, netEvents
);
3135 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
3140 memset(netEvents
, 0, sizeof(*netEvents
));
3145 /* Run the message loop a little */
3146 while (PeekMessageA( &msg
, 0, 0, 0, PM_REMOVE
))
3148 DispatchMessageA(&msg
);
3152 if (match_event_sequence(s
, netEvents
, seq
))
3154 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq
));
3155 flush_events(s
, hEvent
);
3161 for (; *broken_seqs
; broken_seqs
++)
3163 if (match_event_sequence(s
, netEvents
, *broken_seqs
))
3165 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s
, netEvents
), dbgstr_event_seq(seq
));
3166 flush_events(s
, hEvent
);
3172 winetest_ok(broken(completelyBroken
), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq
),
3173 dbgstr_event_seq_result(s
, netEvents
));
3174 flush_events(s
, hEvent
);
3177 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
3179 static void test_events(int useMessages
)
3181 SOCKET server
= INVALID_SOCKET
;
3182 SOCKET src
= INVALID_SOCKET
, src2
= INVALID_SOCKET
;
3183 SOCKET dst
= INVALID_SOCKET
, dst2
= INVALID_SOCKET
;
3184 struct sockaddr_in addr
;
3185 HANDLE hThread
= NULL
;
3186 HANDLE hEvent
= INVALID_HANDLE_VALUE
, hEvent2
= INVALID_HANDLE_VALUE
;
3187 WNDCLASSEX wndclass
;
3189 char *buffer
= NULL
;
3190 int bufferSize
= 1024*1024;
3194 DWORD bytesReturned
;
3200 static char szClassName
[] = "wstestclass";
3201 const LPARAM
*broken_seq
[3];
3202 static const LPARAM empty_seq
[] = { 0 };
3203 static const LPARAM close_seq
[] = { WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
3204 static const LPARAM write_seq
[] = { WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
3205 static const LPARAM read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
3206 static const LPARAM oob_seq
[] = { WSAMAKESELECTREPLY(FD_OOB
, 0), 0 };
3207 static const LPARAM connect_seq
[] = { WSAMAKESELECTREPLY(FD_CONNECT
, 0),
3208 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
3209 static const LPARAM read_read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
3210 WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
3211 static const LPARAM read_write_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
3212 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
3213 static const LPARAM read_close_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
3214 WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
3216 memset(&ov
, 0, sizeof(ov
));
3217 memset(&ov2
, 0, sizeof(ov2
));
3219 /* don't use socketpair, we want connection event */
3220 src
= socket(AF_INET
, SOCK_STREAM
, 0);
3221 if (src
== INVALID_SOCKET
)
3223 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3227 src2
= socket(AF_INET
, SOCK_STREAM
, 0);
3228 if (src2
== INVALID_SOCKET
)
3230 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3235 if (getsockopt(src
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&bret
, &len
) == SOCKET_ERROR
)
3237 ok(0, "failed to get oobinline status, %d\n", GetLastError());
3240 ok(bret
== FALSE
, "OOB not inline\n");
3244 trace("Event test using messages\n");
3246 wndclass
.cbSize
= sizeof(wndclass
);
3247 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
3248 wndclass
.lpfnWndProc
= ws2_test_WndProc
;
3249 wndclass
.cbClsExtra
= 0;
3250 wndclass
.cbWndExtra
= 0;
3251 wndclass
.hInstance
= GetModuleHandle(NULL
);
3252 wndclass
.hIcon
= LoadIcon(NULL
, IDI_APPLICATION
);
3253 wndclass
.hIconSm
= LoadIcon(NULL
, IDI_APPLICATION
);
3254 wndclass
.hCursor
= LoadCursor(NULL
, IDC_ARROW
);
3255 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
3256 wndclass
.lpszClassName
= szClassName
;
3257 wndclass
.lpszMenuName
= NULL
;
3258 RegisterClassEx(&wndclass
);
3260 hWnd
= CreateWindow(szClassName
, "WS2Test", WS_OVERLAPPEDWINDOW
, 0, 0, 500, 500, NULL
, NULL
, GetModuleHandle(NULL
), NULL
);
3263 ok(0, "failed to create window: %d\n", GetLastError());
3267 ret
= WSAAsyncSelect(src
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
3270 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
3274 ret
= WSAAsyncSelect(src2
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
3277 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
3283 trace("Event test using events\n");
3285 hEvent
= WSACreateEvent();
3286 if (hEvent
== INVALID_HANDLE_VALUE
)
3288 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
3292 hEvent2
= WSACreateEvent();
3293 if (hEvent2
== INVALID_HANDLE_VALUE
)
3295 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
3299 ret
= WSAEventSelect(src
, hEvent
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
3302 ok(0, "WSAEventSelect failed, error %d\n", ret
);
3306 ret
= WSAEventSelect(src2
, hEvent2
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
3309 ok(0, "WSAEventSelect failed, error %d\n", ret
);
3314 server
= socket(AF_INET
, SOCK_STREAM
, 0);
3315 if (server
== INVALID_SOCKET
)
3317 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3321 memset(&addr
, 0, sizeof(addr
));
3322 addr
.sin_family
= AF_INET
;
3323 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3324 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
3327 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3332 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
3335 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3339 ret
= listen(server
, 2);
3342 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3346 ret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
3347 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
3349 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3353 ret
= connect(src2
, (struct sockaddr
*)&addr
, sizeof(addr
));
3354 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
3356 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3361 dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
3362 if (dst
== INVALID_SOCKET
)
3364 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3369 dst2
= accept(server
, (struct sockaddr
*)&addr
, &len
);
3370 if (dst2
== INVALID_SOCKET
)
3372 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3376 closesocket(server
);
3377 server
= INVALID_SOCKET
;
3379 /* On Windows it seems when a non-blocking socket sends to a
3380 blocking socket on the same host, the send() is BLOCKING,
3381 so make both sockets non-blocking. src is already non-blocking
3382 from the async select */
3384 if (set_blocking(dst
, FALSE
))
3386 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
3390 buffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, bufferSize
);
3393 ok(0, "could not allocate memory for test\n");
3397 ov
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
3398 if (ov
.hEvent
== NULL
)
3400 ok(0, "could not create event object, errno = %d\n", GetLastError());
3404 ov2
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
3405 if (ov2
.hEvent
== NULL
)
3407 ok(0, "could not create event object, errno = %d\n", GetLastError());
3411 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
3412 ok_event_seq(src
, hEvent
, connect_seq
, NULL
, 1);
3413 ok_event_seq(src2
, hEvent2
, connect_seq
, NULL
, 1);
3414 /* broken on all windows - FD_CONNECT error is garbage */
3416 /* Test simple send/recv */
3417 ret
= send(dst
, buffer
, 100, 0);
3418 ok(ret
== 100, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3419 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
3421 ret
= recv(src
, buffer
, 50, 0);
3422 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
3423 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
3425 ret
= recv(src
, buffer
, 50, 0);
3426 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
3427 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
3429 /* fun fact - events are reenabled even on failure, but only for messages */
3430 ret
= send(dst
, "1", 1, 0);
3431 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3432 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
3434 ret
= recv(src
, buffer
, -1, 0);
3435 ok(ret
== SOCKET_ERROR
&& (GetLastError() == WSAEFAULT
|| GetLastError() == WSAENOBUFS
),
3436 "Failed to recv buffer %d err %d\n", ret
, GetLastError());
3439 broken_seq
[0] = empty_seq
; /* win9x */
3440 broken_seq
[1] = NULL
;
3441 todo_wine
ok_event_seq(src
, hEvent
, read_seq
, broken_seq
, 0);
3444 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
3446 ret
= recv(src
, buffer
, 1, 0);
3447 ok(ret
== 1, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
3448 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
3450 /* Interaction with overlapped */
3451 bufs
.len
= sizeof(char);
3453 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
3454 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
3455 "WSARecv failed - %d error %d\n", ret
, GetLastError());
3457 bufs
.len
= sizeof(char);
3458 bufs
.buf
= buffer
+1;
3459 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov2
, NULL
);
3460 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
3461 "WSARecv failed - %d error %d\n", ret
, GetLastError());
3463 ret
= send(dst
, "12", 2, 0);
3464 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3465 broken_seq
[0] = read_read_seq
; /* win9x */
3466 broken_seq
[1] = NULL
;
3467 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
3469 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
3470 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
3471 if (dwRet
== WAIT_OBJECT_0
)
3473 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
3474 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
3475 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
3476 ok(buffer
[0] == '1', "Got %c instead of 1\n", buffer
[0]);
3479 dwRet
= WaitForSingleObject(ov2
.hEvent
, 100);
3480 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
3481 if (dwRet
== WAIT_OBJECT_0
)
3483 bret
= GetOverlappedResult((HANDLE
)src
, &ov2
, &bytesReturned
, FALSE
);
3484 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
3485 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
3486 ok(buffer
[1] == '2', "Got %c instead of 2\n", buffer
[1]);
3489 ret
= send(dst
, "1", 1, 0);
3490 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3491 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
3493 ret
= recv(src
, buffer
, 1, 0);
3494 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
3495 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
3497 /* Notifications are delivered as soon as possible, blocked only on
3498 * async requests on the same type */
3499 bufs
.len
= sizeof(char);
3501 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
3502 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
3503 "WSARecv failed - %d error %d\n", ret
, GetLastError());
3506 ret
= send(dst
, "1", 1, MSG_OOB
);
3507 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3508 ok_event_seq(src
, hEvent
, oob_seq
, NULL
, 0);
3511 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
3512 ok(dwRet
== WAIT_TIMEOUT
, "OOB message activated read?: %d - %d\n", dwRet
, GetLastError());
3514 ret
= send(dst
, "2", 1, 0);
3515 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3516 broken_seq
[0] = read_seq
; /* win98 */
3517 broken_seq
[1] = NULL
;
3518 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
3520 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
3521 ok(dwRet
== WAIT_OBJECT_0
|| broken(dwRet
== WAIT_TIMEOUT
),
3522 "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
3523 if (dwRet
== WAIT_OBJECT_0
)
3525 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
3526 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
3527 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
3528 ok(buffer
[0] == '2', "Got %c instead of 2\n", buffer
[0]);
3530 else if (dwRet
== WAIT_TIMEOUT
)
3532 /* this happens on win98. We get an FD_READ later on the next test */
3533 CancelIo((HANDLE
) src
);
3537 ret
= recv(src
, buffer
, 1, MSG_OOB
);
3538 todo_wine
ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
3539 /* We get OOB notification, but no data on wine */
3540 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
3543 /* Flood the send queue */
3544 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
3545 if (hThread
== NULL
)
3547 ok(0, "CreateThread failed, error %d\n", GetLastError());
3551 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
3552 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
3554 /* Now if we send a ton of data and the 'server' does not drain it fast
3555 * enough (set drain_pause to be sure), the socket send buffer will only
3556 * take some of it, and we will get a short write. This will trigger
3557 * another FD_WRITE event as soon as data is sent and more space becomes
3558 * available, but not any earlier. */
3562 ret
= send(src
, buffer
, bufferSize
, 0);
3563 } while (ret
== bufferSize
);
3565 if (ret
>= 0 || WSAGetLastError() == WSAEWOULDBLOCK
)
3567 Sleep(400); /* win9x */
3568 broken_seq
[0] = read_write_seq
;
3569 broken_seq
[1] = NULL
;
3570 ok_event_seq(src
, hEvent
, write_seq
, broken_seq
, 0);
3574 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
3577 /* Test how FD_CLOSE is handled */
3578 ret
= send(dst
, "12", 2, 0);
3579 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3581 /* Wait a little and let the send complete */
3584 dst
= INVALID_SOCKET
;
3587 /* We can never implement this in wine, best we can hope for is
3588 sending FD_CLOSE after the reads complete */
3589 broken_seq
[0] = read_seq
; /* win9x */
3590 broken_seq
[1] = NULL
;
3591 todo_wine
ok_event_seq(src
, hEvent
, read_close_seq
, broken_seq
, 0);
3593 ret
= recv(src
, buffer
, 1, 0);
3594 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
3595 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
3597 ret
= recv(src
, buffer
, 1, 0);
3598 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
3599 /* want it? it's here, but you can't have it */
3600 broken_seq
[0] = close_seq
; /* win9x */
3601 broken_seq
[1] = NULL
;
3602 todo_wine
ok_event_seq(src
, hEvent
, empty_seq
, /* wine sends FD_CLOSE here */
3605 /* Test how FD_CLOSE is handled */
3606 ret
= send(dst2
, "12", 2, 0);
3607 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3610 shutdown(dst2
, SD_SEND
);
3613 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
3614 regressions, don't mark them as todo_wine, and mark windows as broken */
3615 broken_seq
[0] = read_close_seq
;
3616 broken_seq
[1] = close_seq
;
3617 broken_seq
[2] = NULL
;
3618 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
3620 ret
= recv(src2
, buffer
, 1, 0);
3621 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
3622 broken_seq
[0] = close_seq
; /* win98 */
3623 broken_seq
[1] = NULL
;
3624 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
3626 ret
= recv(src2
, buffer
, 1, 0);
3627 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
3628 broken_seq
[0] = empty_seq
;
3629 broken_seq
[1] = NULL
;
3630 ok_event_seq(src2
, hEvent2
, close_seq
, broken_seq
, 0);
3632 ret
= send(src2
, "1", 1, 0);
3633 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
3634 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
3636 ret
= send(src2
, "1", 1, 0);
3637 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
3638 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
3641 if (src
!= INVALID_SOCKET
)
3643 flush_events(src
, hEvent
);
3646 if (src2
!= INVALID_SOCKET
)
3648 flush_events(src2
, hEvent2
);
3651 HeapFree(GetProcessHeap(), 0, buffer
);
3652 if (server
!= INVALID_SOCKET
)
3653 closesocket(server
);
3654 if (dst
!= INVALID_SOCKET
)
3656 if (dst2
!= INVALID_SOCKET
)
3658 if (hThread
!= NULL
)
3659 CloseHandle(hThread
);
3663 CloseHandle(hEvent
);
3664 if (hEvent2
!= NULL
)
3665 CloseHandle(hEvent2
);
3666 if (ov
.hEvent
!= NULL
)
3667 CloseHandle(ov
.hEvent
);
3668 if (ov2
.hEvent
!= NULL
)
3669 CloseHandle(ov2
.hEvent
);
3672 static void test_ipv6only(void)
3674 SOCKET v4
= INVALID_SOCKET
,
3675 v6
= INVALID_SOCKET
;
3676 struct sockaddr_in sin4
;
3677 struct sockaddr_in6 sin6
;
3680 memset(&sin4
, 0, sizeof(sin4
));
3681 sin4
.sin_family
= AF_INET
;
3682 sin4
.sin_port
= htons(SERVERPORT
);
3684 memset(&sin6
, 0, sizeof(sin6
));
3685 sin6
.sin6_family
= AF_INET6
;
3686 sin6
.sin6_port
= htons(SERVERPORT
);
3688 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
3689 if (v6
== INVALID_SOCKET
) {
3690 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3691 WSAGetLastError(), WSAEAFNOSUPPORT
);
3694 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
3696 skip("Could not bind IPv6 address (LastError: %d).\n",
3701 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3702 if (v4
== INVALID_SOCKET
) {
3703 skip("Could not create IPv4 socket (LastError: %d).\n",
3707 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
3708 ok(!ret
, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
3709 WSAGetLastError(), WSAEADDRINUSE
);
3712 if (v4
!= INVALID_SOCKET
)
3714 if (v6
!= INVALID_SOCKET
)
3718 static void test_WSASendTo(void)
3721 struct sockaddr_in addr
;
3722 char buf
[12] = "hello world";
3726 addr
.sin_family
= AF_INET
;
3727 addr
.sin_port
= htons(139);
3728 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3729 data_buf
.len
= sizeof(buf
);
3732 if( (s
= socket(AF_INET
, SOCK_DGRAM
, 0)) == INVALID_SOCKET
) {
3733 ok(0, "socket() failed error: %d\n", WSAGetLastError());
3737 WSASetLastError(12345);
3738 if(WSASendTo(s
, &data_buf
, 1, &bytesSent
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
)) {
3739 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
3742 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
3743 "a successful call to WSASendTo()\n");
3746 static void test_WSARecv(void)
3752 DWORD bytesReturned
;
3759 tcp_socketpair(&src
, &dest
);
3760 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
3762 skip("failed to create sockets\n");
3766 bufs
.len
= sizeof(buf
);
3770 memset(&ov
, 0, sizeof(ov
));
3771 ov
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
3772 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
3778 ok(!setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
)), "Failed to set linger %d\n", GetLastError());
3780 iret
= WSARecv(dest
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
3781 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
3784 src
= INVALID_SOCKET
;
3786 dwret
= WaitForSingleObject(ov
.hEvent
, 1000);
3787 ok(dwret
== WAIT_OBJECT_0
, "Waiting for disconnect event failed with %d + errno %d\n", dwret
, GetLastError());
3789 bret
= GetOverlappedResult((HANDLE
)dest
, &ov
, &bytesReturned
, FALSE
);
3790 todo_wine
ok(!bret
&& (GetLastError() == ERROR_NETNAME_DELETED
|| broken(GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */),
3791 "Did not get disconnect event: %d, error %d\n", bret
, GetLastError());
3792 ok(bytesReturned
== 0, "Bytes received is %d\n", bytesReturned
);
3795 if (dest
!= INVALID_SOCKET
)
3797 if (src
!= INVALID_SOCKET
)
3800 WSACloseEvent(ov
.hEvent
);
3803 static void test_GetAddrInfoW(void)
3805 static const WCHAR port
[] = {'8','0',0};
3806 static const WCHAR empty
[] = {0};
3807 static const WCHAR localhost
[] = {'l','o','c','a','l','h','o','s','t',0};
3810 ADDRINFOW
*result
, hint
;
3812 if (!pGetAddrInfoW
|| !pFreeAddrInfoW
)
3814 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
3818 memset(&hint
, 0, sizeof(ADDRINFOW
));
3820 ret
= pGetAddrInfoW(NULL
, NULL
, NULL
, &result
);
3821 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
3824 ret
= pGetAddrInfoW(empty
, NULL
, NULL
, &result
);
3827 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3828 ok(result
!= NULL
, "GetAddrInfoW failed\n");
3830 pFreeAddrInfoW(result
);
3832 ret
= pGetAddrInfoW(localhost
, NULL
, NULL
, &result
);
3833 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3834 pFreeAddrInfoW(result
);
3836 ret
= pGetAddrInfoW(localhost
, port
, NULL
, &result
);
3837 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3838 pFreeAddrInfoW(result
);
3840 ret
= pGetAddrInfoW(localhost
, port
, &hint
, &result
);
3841 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3842 pFreeAddrInfoW(result
);
3845 static void test_ConnectEx(void)
3847 SOCKET listener
= INVALID_SOCKET
;
3848 SOCKET acceptor
= INVALID_SOCKET
;
3849 SOCKET connector
= INVALID_SOCKET
;
3850 struct sockaddr_in address
, conaddress
;
3852 OVERLAPPED overlapped
;
3853 LPFN_CONNECTEX pConnectEx
;
3854 GUID connectExGuid
= WSAID_CONNECTEX
;
3855 DWORD bytesReturned
;
3861 memset(&overlapped
, 0, sizeof(overlapped
));
3863 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
3864 if (listener
== INVALID_SOCKET
) {
3865 skip("could not create listener socket, error %d\n", WSAGetLastError());
3869 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
3870 if (connector
== INVALID_SOCKET
) {
3871 skip("could not create connector socket, error %d\n", WSAGetLastError());
3875 memset(&address
, 0, sizeof(address
));
3876 address
.sin_family
= AF_INET
;
3877 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3878 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
3880 skip("failed to bind, error %d\n", WSAGetLastError());
3884 addrlen
= sizeof(address
);
3885 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
3887 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
3891 if (set_blocking(listener
, TRUE
)) {
3892 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
3896 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectExGuid
, sizeof(connectExGuid
),
3897 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
3899 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret
, WSAGetLastError());
3903 bret
= pConnectEx(INVALID_SOCKET
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
3904 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "ConnectEx on invalid socket "
3905 "returned %d + errno %d\n", bret
, WSAGetLastError());
3907 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
3908 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "ConnectEx on a unbound socket "
3909 "returned %d + errno %d\n", bret
, WSAGetLastError());
3910 if (bret
== TRUE
|| WSAGetLastError() != WSAEINVAL
)
3912 acceptor
= accept(listener
, NULL
, NULL
);
3913 if (acceptor
!= INVALID_SOCKET
) {
3914 closesocket(acceptor
);
3915 acceptor
= INVALID_SOCKET
;
3918 closesocket(connector
);
3919 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
3920 if (connector
== INVALID_SOCKET
) {
3921 skip("could not create connector socket, error %d\n", WSAGetLastError());
3926 /* ConnectEx needs a bound socket */
3927 memset(&conaddress
, 0, sizeof(conaddress
));
3928 conaddress
.sin_family
= AF_INET
;
3929 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3930 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
3932 skip("failed to bind, error %d\n", WSAGetLastError());
3936 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, NULL
);
3937 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "ConnectEx on a NULL overlapped "
3938 "returned %d + errno %d\n", bret
, WSAGetLastError());
3940 overlapped
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
3941 if (overlapped
.hEvent
== NULL
) {
3942 skip("could not create event object, errno = %d\n", GetLastError());
3946 iret
= listen(listener
, 1);
3948 skip("listening failed, errno = %d\n", WSAGetLastError());
3952 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
3953 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
3954 "returned %d + errno %d\n", bret
, WSAGetLastError());
3955 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
3956 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
3958 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
3959 ok(bret
, "Connecting failed, error %d\n", GetLastError());
3960 ok(bytesReturned
== 0, "Bytes sent is %d\n", bytesReturned
);
3962 closesocket(connector
);
3963 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
3964 if (connector
== INVALID_SOCKET
) {
3965 skip("could not create connector socket, error %d\n", WSAGetLastError());
3968 /* ConnectEx needs a bound socket */
3969 memset(&conaddress
, 0, sizeof(conaddress
));
3970 conaddress
.sin_family
= AF_INET
;
3971 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3972 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
3974 skip("failed to bind, error %d\n", WSAGetLastError());
3978 acceptor
= accept(listener
, NULL
, NULL
);
3979 if (acceptor
!= INVALID_SOCKET
) {
3980 closesocket(acceptor
);
3981 acceptor
= INVALID_SOCKET
;
3987 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, buffer
, 3, &bytesReturned
, &overlapped
);
3988 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
3989 "returned %d + errno %d\n", bret
, WSAGetLastError());
3990 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
3991 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
3993 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
3994 ok(bret
, "Connecting failed, error %d\n", GetLastError());
3995 ok(bytesReturned
== 3, "Bytes sent is %d\n", bytesReturned
);
3997 acceptor
= accept(listener
, NULL
, NULL
);
3998 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket error %d\n", WSAGetLastError());
4000 bytesReturned
= recv(acceptor
, buffer
, 3, 0);
4002 ok(bytesReturned
== 3, "Didn't get all sent data, got only %d\n", bytesReturned
);
4003 ok(buffer
[0] == '1' && buffer
[1] == '2' && buffer
[2] == '3',
4004 "Failed to get the right data, expected '123', got '%s'\n", buffer
);
4006 closesocket(connector
);
4007 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4008 if (connector
== INVALID_SOCKET
) {
4009 skip("could not create connector socket, error %d\n", WSAGetLastError());
4012 /* ConnectEx needs a bound socket */
4013 memset(&conaddress
, 0, sizeof(conaddress
));
4014 conaddress
.sin_family
= AF_INET
;
4015 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4016 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
4018 skip("failed to bind, error %d\n", WSAGetLastError());
4022 if (acceptor
!= INVALID_SOCKET
) {
4023 closesocket(acceptor
);
4024 acceptor
= INVALID_SOCKET
;
4027 /* Connect with error */
4028 closesocket(listener
);
4029 listener
= INVALID_SOCKET
;
4031 address
.sin_port
= 1;
4033 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
4034 ok(bret
== FALSE
&& GetLastError(), "ConnectEx to bad destination failed: "
4035 "returned %d + errno %d\n", bret
, GetLastError());
4037 if (GetLastError() == ERROR_IO_PENDING
)
4039 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
4040 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
4042 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
4043 ok(bret
== FALSE
&& GetLastError() == ERROR_CONNECTION_REFUSED
,
4044 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
4047 ok(GetLastError() == WSAECONNREFUSED
,
4048 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
4052 if (overlapped
.hEvent
)
4053 WSACloseEvent(overlapped
.hEvent
);
4054 if (listener
!= INVALID_SOCKET
)
4055 closesocket(listener
);
4056 if (acceptor
!= INVALID_SOCKET
)
4057 closesocket(acceptor
);
4058 if (connector
!= INVALID_SOCKET
)
4059 closesocket(connector
);
4062 static void test_AcceptEx(void)
4064 SOCKET listener
= INVALID_SOCKET
;
4065 SOCKET acceptor
= INVALID_SOCKET
;
4066 SOCKET connector
= INVALID_SOCKET
;
4067 SOCKET connector2
= INVALID_SOCKET
;
4068 struct sockaddr_in bindAddress
;
4070 GUID acceptExGuid
= WSAID_ACCEPTEX
;
4071 LPFN_ACCEPTEX pAcceptEx
= NULL
;
4072 fd_set fds_accept
, fds_send
;
4073 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
4075 DWORD bytesReturned
;
4077 OVERLAPPED overlapped
;
4082 memset(&overlapped
, 0, sizeof(overlapped
));
4084 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
4085 if (listener
== INVALID_SOCKET
) {
4086 skip("could not create listener socket, error %d\n", WSAGetLastError());
4090 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4091 if (acceptor
== INVALID_SOCKET
) {
4092 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4096 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4097 if (connector
== INVALID_SOCKET
) {
4098 skip("could not create connector socket, error %d\n", WSAGetLastError());
4102 memset(&bindAddress
, 0, sizeof(bindAddress
));
4103 bindAddress
.sin_family
= AF_INET
;
4104 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4105 iret
= bind(listener
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4107 skip("failed to bind, error %d\n", WSAGetLastError());
4111 socklen
= sizeof(bindAddress
);
4112 iret
= getsockname(listener
, (struct sockaddr
*)&bindAddress
, &socklen
);
4114 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
4118 if (set_blocking(listener
, FALSE
)) {
4119 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
4123 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
4124 &pAcceptEx
, sizeof(pAcceptEx
), &bytesReturned
, NULL
, NULL
);
4126 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret
, WSAGetLastError());
4130 bret
= pAcceptEx(INVALID_SOCKET
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4131 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4132 &bytesReturned
, &overlapped
);
4133 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid listening socket "
4134 "returned %d + errno %d\n", bret
, WSAGetLastError());
4136 bret
= pAcceptEx(listener
, INVALID_SOCKET
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4137 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4138 &bytesReturned
, &overlapped
);
4139 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on invalid accepting socket "
4140 "returned %d + errno %d\n", bret
, WSAGetLastError());
4142 bret
= pAcceptEx(listener
, acceptor
, NULL
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4143 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4144 &bytesReturned
, &overlapped
);
4146 (WSAGetLastError() == WSAEINVAL
||
4147 broken(WSAGetLastError() == WSAEFAULT
)), /* NT4 */
4148 "AcceptEx on NULL buffer returned %d + errno %d\n", bret
, WSAGetLastError());
4150 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
4151 &bytesReturned
, &overlapped
);
4152 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on too small local address size "
4153 "returned %d + errno %d\n", bret
, WSAGetLastError());
4155 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16, 0,
4156 &bytesReturned
, &overlapped
);
4157 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on too small remote address size "
4158 "returned %d + errno %d\n", bret
, WSAGetLastError());
4160 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
4161 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4162 &bytesReturned
, NULL
);
4163 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
4164 "returned %d + errno %d\n", bret
, WSAGetLastError());
4166 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4167 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4168 &bytesReturned
, &overlapped
);
4169 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on a non-listening socket "
4170 "returned %d + errno %d\n", bret
, WSAGetLastError());
4172 iret
= listen(listener
, 5);
4174 skip("listening failed, errno = %d\n", WSAGetLastError());
4178 overlapped
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
4179 if (overlapped
.hEvent
== NULL
) {
4180 skip("could not create event object, errno = %d\n", GetLastError());
4184 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
4185 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4186 &bytesReturned
, &overlapped
);
4187 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4189 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
4190 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4191 &bytesReturned
, &overlapped
);
4192 todo_wine
ok((bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
) || broken(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) /* NT4 */,
4193 "AcceptEx on already pending socket returned %d + errno %d\n", bret
, WSAGetLastError());
4194 if (bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) {
4195 /* We need to cancel this call, otherwise things fail */
4196 bret
= CancelIo((HANDLE
) listener
);
4197 ok(bret
, "Failed to cancel failed test. Bailing...\n");
4199 WaitForSingleObject(overlapped
.hEvent
, 0);
4201 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
4202 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4203 &bytesReturned
, &overlapped
);
4204 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4207 iret
= connect(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4208 todo_wine
ok((iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
) || broken(!iret
) /* NT4 */,
4209 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret
, WSAGetLastError());
4210 if (!iret
|| (iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
)) {
4211 /* We need to cancel this call, otherwise things fail */
4212 closesocket(acceptor
);
4213 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4214 if (acceptor
== INVALID_SOCKET
) {
4215 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4219 bret
= CancelIo((HANDLE
) listener
);
4220 ok(bret
, "Failed to cancel failed test. Bailing...\n");
4223 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
4224 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4225 &bytesReturned
, &overlapped
);
4226 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4229 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4230 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
4232 dwret
= WaitForSingleObject(overlapped
.hEvent
, INFINITE
);
4233 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
4235 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
4236 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
4237 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
4239 closesocket(connector
);
4240 connector
= INVALID_SOCKET
;
4241 closesocket(acceptor
);
4242 acceptor
= INVALID_SOCKET
;
4244 /* Test short reads */
4246 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4247 if (acceptor
== INVALID_SOCKET
) {
4248 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4251 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4252 if (connector
== INVALID_SOCKET
) {
4253 skip("could not create connector socket, error %d\n", WSAGetLastError());
4256 bret
= pAcceptEx(listener
, acceptor
, buffer
, 2,
4257 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4258 &bytesReturned
, &overlapped
);
4259 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4261 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4262 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
4264 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
4265 ok(dwret
== WAIT_TIMEOUT
, "Waiting for accept event timeout failed with %d + errno %d\n", dwret
, GetLastError());
4267 iret
= send(connector
, buffer
, 1, 0);
4268 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
4270 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
4271 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
4273 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
4274 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
4275 ok(bytesReturned
== 1, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
4277 closesocket(connector
);
4278 connector
= INVALID_SOCKET
;
4279 closesocket(acceptor
);
4280 acceptor
= INVALID_SOCKET
;
4282 /* Test CF_DEFER & AcceptEx interaction */
4284 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4285 if (acceptor
== INVALID_SOCKET
) {
4286 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4289 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4290 if (connector
== INVALID_SOCKET
) {
4291 skip("could not create connector socket, error %d\n", WSAGetLastError());
4294 connector2
= socket(AF_INET
, SOCK_STREAM
, 0);
4295 if (connector
== INVALID_SOCKET
) {
4296 skip("could not create connector socket, error %d\n", WSAGetLastError());
4300 if (set_blocking(connector
, FALSE
)) {
4301 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
4305 if (set_blocking(connector2
, FALSE
)) {
4306 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
4310 /* Connect socket #1 */
4311 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4312 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
4314 FD_ZERO ( &fds_accept
);
4315 FD_ZERO ( &fds_send
);
4317 FD_SET ( listener
, &fds_accept
);
4318 FD_SET ( connector
, &fds_send
);
4324 for (i
= 0; i
< 4000; ++i
)
4326 fd_set fds_openaccept
= fds_accept
, fds_opensend
= fds_send
;
4328 wsa_ok ( ( select ( 0, &fds_openaccept
, &fds_opensend
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
4329 "acceptex test(%d): could not select on socket, errno %d\n" );
4331 /* check for incoming requests */
4332 if ( FD_ISSET ( listener
, &fds_openaccept
) ) {
4335 SOCKET tmp
= WSAAccept(listener
, NULL
, NULL
, (LPCONDITIONPROC
) AlwaysDeferConditionFunc
, 0);
4336 ok(tmp
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
4337 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
4338 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4339 &bytesReturned
, &overlapped
);
4340 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4342 else if (got
== 2) {
4343 /* this should be socket #2 */
4344 SOCKET tmp
= accept(listener
, NULL
, NULL
);
4345 ok(tmp
!= INVALID_SOCKET
, "accept failed %d\n", WSAGetLastError());
4349 ok(FALSE
, "Got more than 2 connections?\n");
4352 if ( conn1
&& FD_ISSET ( connector2
, &fds_opensend
) ) {
4353 /* Send data on second socket, and stop */
4354 send(connector2
, "2", 1, 0);
4355 FD_CLR ( connector2
, &fds_send
);
4359 if ( FD_ISSET ( connector
, &fds_opensend
) ) {
4360 /* Once #1 is connected, allow #2 to connect */
4363 send(connector
, "1", 1, 0);
4364 FD_CLR ( connector
, &fds_send
);
4366 iret
= connect(connector2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4367 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
4368 FD_SET ( connector2
, &fds_send
);
4372 ok (got
== 2 || broken(got
== 1) /* NT4 */,
4373 "Did not get both connections, got %d\n", got
);
4375 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
4376 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
4378 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
4379 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
4380 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
4382 set_blocking(acceptor
, TRUE
);
4383 iret
= recv( acceptor
, buffer
, 2, 0);
4384 ok(iret
== 1, "Failed to get data, %d, errno: %d\n", iret
, WSAGetLastError());
4386 ok(buffer
[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer
[0]);
4388 closesocket(connector
);
4389 connector
= INVALID_SOCKET
;
4390 closesocket(acceptor
);
4391 acceptor
= INVALID_SOCKET
;
4393 /* clean up in case of failures */
4394 while ((acceptor
= accept(listener
, NULL
, NULL
)) != INVALID_SOCKET
)
4395 closesocket(acceptor
);
4397 /* Disconnect during receive? */
4399 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4400 if (acceptor
== INVALID_SOCKET
) {
4401 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4404 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4405 if (connector
== INVALID_SOCKET
) {
4406 skip("could not create connector socket, error %d\n", WSAGetLastError());
4409 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4410 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4411 &bytesReturned
, &overlapped
);
4412 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4414 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4415 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
4417 closesocket(connector
);
4418 connector
= INVALID_SOCKET
;
4420 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
4421 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
4423 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
4424 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
4425 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
4427 closesocket(acceptor
);
4428 acceptor
= INVALID_SOCKET
;
4430 /* Test closing with pending requests */
4432 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4433 if (acceptor
== INVALID_SOCKET
) {
4434 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4437 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4438 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4439 &bytesReturned
, &overlapped
);
4440 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4442 closesocket(acceptor
);
4443 acceptor
= INVALID_SOCKET
;
4445 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
4446 todo_wine
ok(dwret
== WAIT_OBJECT_0
|| broken(dwret
== WAIT_TIMEOUT
) /* NT4/2000 */,
4447 "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
4449 if (dwret
!= WAIT_TIMEOUT
) {
4450 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
4451 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
4454 bret
= CancelIo((HANDLE
) listener
);
4455 ok(bret
, "Failed to cancel failed test. Bailing...\n");
4457 WaitForSingleObject(overlapped
.hEvent
, 0);
4460 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4461 if (acceptor
== INVALID_SOCKET
) {
4462 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4465 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4466 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4467 &bytesReturned
, &overlapped
);
4468 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4470 CancelIo((HANDLE
) acceptor
);
4472 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
4473 ok(dwret
== WAIT_TIMEOUT
, "Waiting for timeout failed with %d + errno %d\n", dwret
, GetLastError());
4475 closesocket(acceptor
);
4476 acceptor
= INVALID_SOCKET
;
4478 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4479 if (acceptor
== INVALID_SOCKET
) {
4480 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4483 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4484 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4485 &bytesReturned
, &overlapped
);
4486 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4488 closesocket(listener
);
4489 listener
= INVALID_SOCKET
;
4491 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
4492 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
4494 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
4495 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
4498 if (overlapped
.hEvent
)
4499 WSACloseEvent(overlapped
.hEvent
);
4500 if (listener
!= INVALID_SOCKET
)
4501 closesocket(listener
);
4502 if (acceptor
!= INVALID_SOCKET
)
4503 closesocket(acceptor
);
4504 if (connector
!= INVALID_SOCKET
)
4505 closesocket(connector
);
4506 if (connector2
!= INVALID_SOCKET
)
4507 closesocket(connector2
);
4510 static void test_getpeername(void)
4513 struct sockaddr_in sa
, sa_out
;
4515 const char buf
[] = "hello world";
4518 /* Test the parameter validation order. */
4519 ret
= getpeername(INVALID_SOCKET
, NULL
, NULL
);
4520 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
4521 ok(WSAGetLastError() == WSAENOTSOCK
,
4522 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
4524 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
4525 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
4526 if (sock
== INVALID_SOCKET
)
4528 skip("Socket creation failed with %d\n", WSAGetLastError());
4532 ret
= getpeername(sock
, NULL
, NULL
);
4533 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
4534 ok(WSAGetLastError() == WSAENOTCONN
||
4535 broken(WSAGetLastError() == WSAEFAULT
), /* Win9x and WinMe */
4536 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
4538 memset(&sa
, 0, sizeof(sa
));
4539 sa
.sin_family
= AF_INET
;
4540 sa
.sin_port
= htons(139);
4541 sa
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4543 /* sendto does not change a socket's connection state. */
4544 ret
= sendto(sock
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
4545 ok(ret
!= SOCKET_ERROR
,
4546 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
4548 ret
= getpeername(sock
, NULL
, NULL
);
4549 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
4550 ok(WSAGetLastError() == WSAENOTCONN
||
4551 broken(WSAGetLastError() == WSAEFAULT
), /* Win9x and WinMe */
4552 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
4554 ret
= connect(sock
, (struct sockaddr
*)&sa
, sizeof(sa
));
4556 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
4558 ret
= getpeername(sock
, NULL
, NULL
);
4559 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
4560 ok(WSAGetLastError() == WSAEFAULT
,
4561 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
4563 /* Test crashes on Wine. */
4566 ret
= getpeername(sock
, (void*)0xdeadbeef, (void*)0xcafebabe);
4567 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
4568 ok(WSAGetLastError() == WSAEFAULT
,
4569 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
4573 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, &sa_len
);
4574 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
4575 ok(WSAGetLastError() == WSAEFAULT
,
4576 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
4578 sa_len
= sizeof(sa_out
);
4579 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, &sa_len
);
4580 ok(ret
== 0, "Expected getpeername to return 0, got %d\n", ret
);
4581 ok(!memcmp(&sa
, &sa_out
, sizeof(sa
)),
4582 "Expected the returned structure to be identical to the connect structure\n");
4587 static void test_sioRoutingInterfaceQuery(void)
4591 SOCKADDR_IN sin
= { 0 }, sout
= { 0 };
4592 DWORD bytesReturned
;
4594 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
4595 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
4596 if (sock
== INVALID_SOCKET
)
4598 skip("Socket creation failed with %d\n", WSAGetLastError());
4601 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, NULL
, 0, NULL
, 0, NULL
,
4603 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
4604 "expected WSAEFAULT, got %d\n", WSAGetLastError());
4605 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
4606 NULL
, 0, NULL
, NULL
, NULL
);
4607 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
4608 "expected WSAEFAULT, got %d\n", WSAGetLastError());
4609 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
4610 NULL
, 0, &bytesReturned
, NULL
, NULL
);
4611 ok(ret
== SOCKET_ERROR
&&
4612 (WSAGetLastError() == WSAEFAULT
/* Win98 */ ||
4613 WSAGetLastError() == WSAEINVAL
/* NT4 */||
4614 WSAGetLastError() == WSAEAFNOSUPPORT
),
4615 "expected WSAEFAULT or WSAEINVAL or WSAEAFNOSUPPORT, got %d\n",
4617 sin
.sin_family
= AF_INET
;
4618 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
4619 NULL
, 0, &bytesReturned
, NULL
, NULL
);
4620 ok(ret
== SOCKET_ERROR
&&
4621 (WSAGetLastError() == WSAEFAULT
/* Win98 */ ||
4622 WSAGetLastError() == WSAEINVAL
),
4623 "expected WSAEFAULT or WSAEINVAL, got %d\n", WSAGetLastError());
4624 sin
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
4625 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
4626 NULL
, 0, &bytesReturned
, NULL
, NULL
);
4627 ok(ret
== SOCKET_ERROR
&&
4628 (WSAGetLastError() == WSAEINVAL
/* NT4 */ ||
4629 WSAGetLastError() == WSAEFAULT
),
4630 "expected WSAEINVAL or WSAEFAULT, got %d\n", WSAGetLastError());
4631 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
4632 &sout
, sizeof(sout
), &bytesReturned
, NULL
, NULL
);
4633 ok(!ret
|| broken(WSAGetLastError() == WSAEINVAL
/* NT4 */),
4634 "WSAIoctl failed: %d\n", WSAGetLastError());
4637 ok(sout
.sin_family
== AF_INET
, "expected AF_INET, got %d\n",
4639 /* We expect the source address to be INADDR_LOOPBACK as well, but
4640 * there's no guarantee that a route to the loopback address exists,
4641 * so rather than introduce spurious test failures we do not test the
4649 /**************** Main program ***************/
4655 /* Leave these tests at the beginning. They depend on WSAStartup not having been
4656 * called, which is done by Init() below. */
4657 test_WithoutWSAStartup();
4658 test_WithWSAStartup();
4662 test_set_getsockopt();
4663 test_so_reuseaddr();
4665 test_extendedSocketOptions();
4667 for (i
= 0; i
< NUM_TESTS
; i
++)
4669 trace ( " **** STARTING TEST %d ****\n", i
);
4670 do_test ( &tests
[i
] );
4671 trace ( " **** TEST %d COMPLETE ****\n", i
);
4676 test_getservbyname();
4679 test_WSAAddressToStringA();
4680 test_WSAAddressToStringW();
4682 test_WSAStringToAddressA();
4683 test_WSAStringToAddressW();
4690 test_addr_to_print();
4693 test_gethostbyname_hack();
4702 test_GetAddrInfoW();
4707 test_sioRoutingInterfaceQuery();
4709 /* this is a io heavy test, do it at the end so the kernel doesn't start dropping packets */