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
30 #include "wine/test.h"
32 #define MAX_CLIENTS 4 /* Max number of clients */
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_oob_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
), MSG_OOB
);
260 wsa_ok ( n
, 0 <=, "do_oob_send (%x): error %d\n" );
264 static int do_synchronous_send ( SOCKET s
, char *buf
, int buflen
, int sendlen
)
266 char* last
= buf
+ buflen
, *p
;
268 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
269 n
= send ( s
, p
, min ( sendlen
, last
- p
), 0 );
270 wsa_ok ( n
, 0 <=, "do_synchronous_send (%x): error %d\n" );
274 static int do_synchronous_recv ( SOCKET s
, char *buf
, int buflen
, int recvlen
)
276 char* last
= buf
+ buflen
, *p
;
278 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
279 n
= recv ( s
, p
, min ( recvlen
, last
- p
), 0 );
280 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
284 static int do_synchronous_recvfrom ( SOCKET s
, char *buf
, int buflen
,int flags
,struct sockaddr
*from
, int *fromlen
, int recvlen
)
286 char* last
= buf
+ buflen
, *p
;
288 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
289 n
= recvfrom ( s
, p
, min ( recvlen
, last
- p
), 0, from
, fromlen
);
290 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
295 * Call this routine right after thread startup.
296 * SO_OPENTYPE must by 0, regardless what the server did.
298 static void check_so_opentype (void)
302 getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
, (LPVOID
) &tmp
, &len
);
303 ok ( tmp
== 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp
);
306 /**************** Server utility functions ***************/
309 * Even if we have closed our server socket cleanly,
310 * the OS may mark the address "in use" for some time -
311 * this happens with native Linux apps, too.
313 static void do_bind ( SOCKET s
, struct sockaddr
* addr
, int addrlen
)
315 int err
, wsaerr
= 0, n_try
= BIND_TRIES
;
317 while ( ( err
= bind ( s
, addr
, addrlen
) ) != 0 &&
318 ( wsaerr
= WSAGetLastError () ) == WSAEADDRINUSE
&&
321 trace ( "address in use, waiting ...\n" );
322 Sleep ( 1000 * BIND_SLEEP
);
324 ok ( err
== 0, "failed to bind: %d\n", wsaerr
);
327 static void server_start ( server_params
*par
)
330 test_params
*gen
= par
->general
;
331 server_memory
*mem
= LocalAlloc ( LPTR
, sizeof ( server_memory
) );
333 TlsSetValue ( tls
, mem
);
334 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
335 NULL
, 0, par
->sock_flags
);
336 ok ( mem
->s
!= INVALID_SOCKET
, "Server: WSASocket failed\n" );
338 mem
->addr
.sin_family
= AF_INET
;
339 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
340 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
342 for (i
= 0; i
< MAX_CLIENTS
; i
++)
344 mem
->sock
[i
].s
= INVALID_SOCKET
;
345 mem
->sock
[i
].buf
= LocalAlloc ( LPTR
, gen
->n_chunks
* gen
->chunk_size
);
346 mem
->sock
[i
].n_recvd
= 0;
347 mem
->sock
[i
].n_sent
= 0;
350 if ( gen
->sock_type
== SOCK_STREAM
)
351 do_bind ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof (mem
->addr
) );
354 static void server_stop (void)
357 server_memory
*mem
= TlsGetValue ( tls
);
359 for (i
= 0; i
< MAX_CLIENTS
; i
++ )
361 LocalFree ( mem
->sock
[i
].buf
);
362 if ( mem
->sock
[i
].s
!= INVALID_SOCKET
)
363 closesocket ( mem
->sock
[i
].s
);
365 ok ( closesocket ( mem
->s
) == 0, "closesocket failed\n" );
367 ExitThread ( GetCurrentThreadId () );
370 /**************** Client utilitiy functions ***************/
372 static void client_start ( client_params
*par
)
374 test_params
*gen
= par
->general
;
375 client_memory
*mem
= LocalAlloc (LPTR
, sizeof (client_memory
));
377 TlsSetValue ( tls
, mem
);
379 WaitForSingleObject ( server_ready
, INFINITE
);
381 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
382 NULL
, 0, par
->sock_flags
);
384 mem
->addr
.sin_family
= AF_INET
;
385 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
386 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
388 ok ( mem
->s
!= INVALID_SOCKET
, "Client: WSASocket failed\n" );
390 mem
->send_buf
= LocalAlloc ( LPTR
, 2 * gen
->n_chunks
* gen
->chunk_size
);
391 mem
->recv_buf
= mem
->send_buf
+ gen
->n_chunks
* gen
->chunk_size
;
392 fill_buffer ( mem
->send_buf
, gen
->chunk_size
, gen
->n_chunks
);
394 SetEvent ( client_ready
[client_id
] );
395 /* Wait for the other clients to come up */
396 WaitForMultipleObjects ( min ( gen
->n_clients
, MAX_CLIENTS
), client_ready
, TRUE
, INFINITE
);
399 static void client_stop (void)
401 client_memory
*mem
= TlsGetValue ( tls
);
402 wsa_ok ( closesocket ( mem
->s
), 0 ==, "closesocket error (%x): %d\n" );
403 LocalFree ( mem
->send_buf
);
408 /**************** Servers ***************/
411 * simple_server: A very basic server doing synchronous IO.
413 static VOID WINAPI
simple_server ( server_params
*par
)
415 test_params
*gen
= par
->general
;
417 int pos
, n_recvd
, n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
418 id
= GetCurrentThreadId();
420 trace ( "simple_server (%x) starting\n", id
);
422 set_so_opentype ( FALSE
); /* non-overlapped */
423 server_start ( par
);
424 mem
= TlsGetValue ( tls
);
426 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
427 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "simple_server (%x): listen failed: %d\n");
429 trace ( "simple_server (%x) ready\n", id
);
430 SetEvent ( server_ready
); /* notify clients */
432 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
434 trace ( "simple_server (%x): waiting for client\n", id
);
436 /* accept a single connection */
437 tmp
= sizeof ( mem
->sock
[0].peer
);
438 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
439 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "simple_server (%x): accept failed: %d\n" );
441 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
442 "simple_server (%x): strange peer address\n", id
);
444 /* Receive data & check it */
445 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
446 ok ( n_recvd
== n_expected
,
447 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
448 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
449 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
452 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
453 ok ( n_sent
== n_expected
,
454 "simple_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
457 read_zero_bytes ( mem
->sock
[0].s
);
458 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "simple_server (%x): closesocket error: %d\n" );
459 mem
->sock
[0].s
= INVALID_SOCKET
;
462 trace ( "simple_server (%x) exiting\n", id
);
467 * oob_server: A very basic server receiving out-of-band data.
469 static VOID WINAPI
oob_server ( server_params
*par
)
471 test_params
*gen
= par
->general
;
474 int pos
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
,
475 id
= GetCurrentThreadId();
477 trace ( "oob_server (%x) starting\n", id
);
479 set_so_opentype ( FALSE
); /* non-overlapped */
480 server_start ( par
);
481 mem
= TlsGetValue ( tls
);
483 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
484 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "oob_server (%x): listen failed: %d\n");
486 trace ( "oob_server (%x) ready\n", id
);
487 SetEvent ( server_ready
); /* notify clients */
489 trace ( "oob_server (%x): waiting for client\n", id
);
491 /* accept a single connection */
492 tmp
= sizeof ( mem
->sock
[0].peer
);
493 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
494 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "oob_server (%x): accept failed: %d\n" );
496 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
497 "oob_server (%x): strange peer address\n", id
);
499 /* check atmark state */
500 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
501 todo_wine
ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
503 /* Receive normal data and check atmark state */
504 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
505 ok ( n_recvd
== n_expected
,
506 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
507 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
508 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
510 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
511 todo_wine
ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
513 /* Receive a part of the out-of-band data and check atmark state */
514 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, 8, par
->buflen
);
516 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, 8 );
519 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
520 ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %i\n", id
, atmark
);
522 /* Receive the rest of the out-of-band data and check atmark state */
523 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
525 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
526 ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %i\n", id
, atmark
);
529 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "oob_server (%x): closesocket error: %d\n" );
530 mem
->sock
[0].s
= INVALID_SOCKET
;
532 trace ( "oob_server (%x) exiting\n", id
);
537 * select_server: A non-blocking server.
539 static VOID WINAPI
select_server ( server_params
*par
)
541 test_params
*gen
= par
->general
;
543 int n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
544 id
= GetCurrentThreadId(), n_connections
= 0, n_sent
, n_recvd
,
545 n_set
, delta
, n_ready
;
546 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
547 fd_set fds_recv
, fds_send
, fds_openrecv
, fds_opensend
;
549 trace ( "select_server (%x) starting\n", id
);
551 set_so_opentype ( FALSE
); /* non-overlapped */
552 server_start ( par
);
553 mem
= TlsGetValue ( tls
);
555 wsa_ok ( set_blocking ( mem
->s
, FALSE
), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
556 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "select_server (%x): listen failed: %d\n");
558 trace ( "select_server (%x) ready\n", id
);
559 SetEvent ( server_ready
); /* notify clients */
561 FD_ZERO ( &fds_openrecv
);
562 FD_ZERO ( &fds_recv
);
563 FD_ZERO ( &fds_send
);
564 FD_ZERO ( &fds_opensend
);
566 FD_SET ( mem
->s
, &fds_openrecv
);
570 fds_recv
= fds_openrecv
;
571 fds_send
= fds_opensend
;
575 wsa_ok ( ( n_ready
= select ( 0, &fds_recv
, &fds_send
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
576 "select_server (%x): select() failed: %d\n" );
578 /* check for incoming requests */
579 if ( FD_ISSET ( mem
->s
, &fds_recv
) ) {
582 trace ( "select_server (%x): accepting client connection\n", id
);
584 /* accept a single connection */
585 tmp
= sizeof ( mem
->sock
[n_connections
].peer
);
586 mem
->sock
[n_connections
].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[n_connections
].peer
, &tmp
);
587 wsa_ok ( mem
->sock
[n_connections
].s
, INVALID_SOCKET
!=, "select_server (%x): accept() failed: %d\n" );
589 ok ( mem
->sock
[n_connections
].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
590 "select_server (%x): strange peer address\n", id
);
592 /* add to list of open connections */
593 FD_SET ( mem
->sock
[n_connections
].s
, &fds_openrecv
);
594 FD_SET ( mem
->sock
[n_connections
].s
, &fds_opensend
);
599 /* handle open requests */
601 for ( i
= 0; i
< n_connections
; i
++ )
603 if ( FD_ISSET( mem
->sock
[i
].s
, &fds_recv
) ) {
606 if ( mem
->sock
[i
].n_recvd
< n_expected
) {
607 /* Receive data & check it */
608 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 );
609 ok ( n_recvd
!= SOCKET_ERROR
, "select_server (%x): error in recv(): %d\n", id
, WSAGetLastError() );
610 mem
->sock
[i
].n_recvd
+= n_recvd
;
612 if ( mem
->sock
[i
].n_recvd
== n_expected
) {
613 int pos
= test_buffer ( mem
->sock
[i
].buf
, gen
->chunk_size
, gen
->n_chunks
);
614 ok ( pos
== -1, "select_server (%x): test pattern error: %d\n", id
, pos
);
615 FD_CLR ( mem
->sock
[i
].s
, &fds_openrecv
);
618 ok ( mem
->sock
[i
].n_recvd
<= n_expected
, "select_server (%x): received too many bytes: %d\n", id
, mem
->sock
[i
].n_recvd
);
622 /* only echo back what we've received */
623 delta
= mem
->sock
[i
].n_recvd
- mem
->sock
[i
].n_sent
;
625 if ( FD_ISSET ( mem
->sock
[i
].s
, &fds_send
) ) {
628 if ( ( delta
> 0 ) && ( mem
->sock
[i
].n_sent
< n_expected
) ) {
630 n_sent
= send ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_sent
, min ( delta
, par
->buflen
), 0 );
631 ok ( n_sent
!= SOCKET_ERROR
, "select_server (%x): error in send(): %d\n", id
, WSAGetLastError() );
632 mem
->sock
[i
].n_sent
+= n_sent
;
634 if ( mem
->sock
[i
].n_sent
== n_expected
) {
635 FD_CLR ( mem
->sock
[i
].s
, &fds_opensend
);
638 ok ( mem
->sock
[i
].n_sent
<= n_expected
, "select_server (%x): sent too many bytes: %d\n", id
, mem
->sock
[i
].n_sent
);
643 /* check that select returned the correct number of ready sockets */
644 ok ( ( n_set
== n_ready
), "select_server (%x): select() returns wrong number of ready sockets\n", id
);
646 /* check if all clients are done */
647 if ( ( fds_opensend
.fd_count
== 0 )
648 && ( fds_openrecv
.fd_count
== 1 ) /* initial socket that accepts clients */
649 && ( n_connections
== min ( gen
->n_clients
, MAX_CLIENTS
) ) ) {
654 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
657 read_zero_bytes ( mem
->sock
[i
].s
);
658 wsa_ok ( closesocket ( mem
->sock
[i
].s
), 0 ==, "select_server (%x): closesocket error: %d\n" );
659 mem
->sock
[i
].s
= INVALID_SOCKET
;
662 trace ( "select_server (%x) exiting\n", id
);
666 /**************** Clients ***************/
669 * simple_client: A very basic client doing synchronous IO.
671 static VOID WINAPI
simple_client ( client_params
*par
)
673 test_params
*gen
= par
->general
;
675 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
677 id
= GetCurrentThreadId();
678 trace ( "simple_client (%x): starting\n", id
);
679 /* wait here because we want to call set_so_opentype before creating a socket */
680 WaitForSingleObject ( server_ready
, INFINITE
);
681 trace ( "simple_client (%x): server ready\n", id
);
683 check_so_opentype ();
684 set_so_opentype ( FALSE
); /* non-overlapped */
685 client_start ( par
);
686 mem
= TlsGetValue ( tls
);
689 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
690 0 ==, "simple_client (%x): connect error: %d\n" );
691 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
692 "simple_client (%x): failed to set blocking mode\n", id
);
693 trace ( "simple_client (%x) connected\n", id
);
695 /* send data to server */
696 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
);
697 ok ( n_sent
== n_expected
,
698 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
700 /* shutdown send direction */
701 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
703 /* Receive data echoed back & check it */
704 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, par
->buflen
);
705 ok ( n_recvd
== n_expected
,
706 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
709 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
710 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
713 read_zero_bytes ( mem
->s
);
714 trace ( "simple_client (%x) exiting\n", id
);
719 * oob_client: A very basic client sending out-of-band data.
721 static VOID WINAPI
oob_client ( client_params
*par
)
723 test_params
*gen
= par
->general
;
725 int n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
727 id
= GetCurrentThreadId();
728 trace ( "oob_client (%x): starting\n", id
);
729 /* wait here because we want to call set_so_opentype before creating a socket */
730 WaitForSingleObject ( server_ready
, INFINITE
);
731 trace ( "oob_client (%x): server ready\n", id
);
733 check_so_opentype ();
734 set_so_opentype ( FALSE
); /* non-overlapped */
735 client_start ( par
);
736 mem
= TlsGetValue ( tls
);
739 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
740 0 ==, "oob_client (%x): connect error: %d\n" );
741 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
742 "oob_client (%x): failed to set blocking mode\n", id
);
743 trace ( "oob_client (%x) connected\n", id
);
745 /* send data to server */
746 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
);
747 ok ( n_sent
== n_expected
,
748 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
750 /* send out-of-band data to server */
751 n_sent
= do_oob_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
);
752 ok ( n_sent
== n_expected
,
753 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
755 /* shutdown send direction */
756 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
759 read_zero_bytes ( mem
->s
);
760 trace ( "oob_client (%x) exiting\n", id
);
765 * simple_mixed_client: mixing send and recvfrom
767 static VOID WINAPI
simple_mixed_client ( client_params
*par
)
769 test_params
*gen
= par
->general
;
771 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
772 int fromLen
= sizeof(mem
->addr
);
773 struct sockaddr test
;
775 id
= GetCurrentThreadId();
776 trace ( "simple_client (%x): starting\n", id
);
777 /* wait here because we want to call set_so_opentype before creating a socket */
778 WaitForSingleObject ( server_ready
, INFINITE
);
779 trace ( "simple_client (%x): server ready\n", id
);
781 check_so_opentype ();
782 set_so_opentype ( FALSE
); /* non-overlapped */
783 client_start ( par
);
784 mem
= TlsGetValue ( tls
);
787 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
788 0 ==, "simple_client (%x): connect error: %d\n" );
789 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
790 "simple_client (%x): failed to set blocking mode\n", id
);
791 trace ( "simple_client (%x) connected\n", id
);
793 /* send data to server */
794 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
);
795 ok ( n_sent
== n_expected
,
796 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
798 /* shutdown send direction */
799 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
801 /* this shouldn't change, since lpFrom, is not updated on
802 connection oriented sockets - exposed by bug 11640
804 ((struct sockaddr_in
*)&test
)->sin_addr
.s_addr
= inet_addr("0.0.0.0");
806 /* Receive data echoed back & check it */
807 n_recvd
= do_synchronous_recvfrom ( mem
->s
,
811 (struct sockaddr
*)&test
,
814 ok ( n_recvd
== n_expected
,
815 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
817 /* check that lpFrom was not updated */
820 inet_ntoa(((struct sockaddr_in
*)&test
)->sin_addr
),
821 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
824 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
825 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
828 read_zero_bytes ( mem
->s
);
829 trace ( "simple_client (%x) exiting\n", id
);
834 * event_client: An event-driven client
836 static void WINAPI
event_client ( client_params
*par
)
838 test_params
*gen
= par
->general
;
840 int id
= GetCurrentThreadId(), n_expected
= gen
->n_chunks
* gen
->chunk_size
,
843 WSANETWORKEVENTS wsa_events
;
844 char *send_last
, *recv_last
, *send_p
, *recv_p
;
845 LONG mask
= FD_READ
| FD_WRITE
| FD_CLOSE
;
847 trace ( "event_client (%x): starting\n", id
);
848 client_start ( par
);
849 trace ( "event_client (%x): server ready\n", id
);
851 mem
= TlsGetValue ( tls
);
853 /* Prepare event notification for connect, makes socket nonblocking */
854 event
= WSACreateEvent ();
855 WSAEventSelect ( mem
->s
, event
, FD_CONNECT
);
856 tmp
= connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) );
858 err
= WSAGetLastError ();
859 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): connect error: %d\n", id
, err
);
860 tmp
= WaitForSingleObject ( event
, INFINITE
);
861 ok ( tmp
== WAIT_OBJECT_0
, "event_client (%x): wait for connect event failed: %d\n", id
, tmp
);
862 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
863 ok ( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
864 err
= wsa_events
.iErrorCode
[ FD_CONNECT_BIT
];
865 ok ( err
== 0, "event_client (%x): connect error: %d\n", id
, err
);
869 trace ( "event_client (%x) connected\n", id
);
871 WSAEventSelect ( mem
->s
, event
, mask
);
873 recv_p
= mem
->recv_buf
;
874 recv_last
= mem
->recv_buf
+ n_expected
;
875 send_p
= mem
->send_buf
;
876 send_last
= mem
->send_buf
+ n_expected
;
880 err
= WaitForSingleObject ( event
, INFINITE
);
881 ok ( err
== WAIT_OBJECT_0
, "event_client (%x): wait failed\n", id
);
883 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
884 ok( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
886 if ( wsa_events
.lNetworkEvents
& FD_WRITE
)
888 err
= wsa_events
.iErrorCode
[ FD_WRITE_BIT
];
889 ok ( err
== 0, "event_client (%x): FD_WRITE error code: %d\n", id
, err
);
894 n
= send ( mem
->s
, send_p
, min ( send_last
- send_p
, par
->buflen
), 0 );
897 err
= WSAGetLastError ();
898 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): send error: %d\n", id
, err
);
903 while ( n
>= 0 && send_p
< send_last
);
905 if ( send_p
== send_last
)
907 trace ( "event_client (%x): all data sent - shutdown\n", id
);
908 shutdown ( mem
->s
, SD_SEND
);
910 WSAEventSelect ( mem
->s
, event
, mask
);
913 if ( wsa_events
.lNetworkEvents
& FD_READ
)
915 err
= wsa_events
.iErrorCode
[ FD_READ_BIT
];
916 ok ( err
== 0, "event_client (%x): FD_READ error code: %d\n", id
, err
);
917 if ( err
!= 0 ) break;
919 /* First read must succeed */
920 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
921 wsa_ok ( n
, 0 <=, "event_client (%x): recv error: %d\n" );
925 if ( recv_p
== recv_last
)
928 trace ( "event_client (%x): all data received\n", id
);
929 WSAEventSelect ( mem
->s
, event
, mask
);
932 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
933 if ( n
< 0 && ( err
= WSAGetLastError()) != WSAEWOULDBLOCK
)
934 ok ( 0, "event_client (%x): read error: %d\n", id
, err
);
938 if ( wsa_events
.lNetworkEvents
& FD_CLOSE
)
940 trace ( "event_client (%x): close event\n", id
);
941 err
= wsa_events
.iErrorCode
[ FD_CLOSE_BIT
];
942 ok ( err
== 0, "event_client (%x): FD_CLOSE error code: %d\n", id
, err
);
947 n
= send_p
- mem
->send_buf
;
948 ok ( send_p
== send_last
,
949 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n
, n_expected
);
950 n
= recv_p
- mem
->recv_buf
;
951 ok ( recv_p
== recv_last
,
952 "simple_client (%x): received less data than expected: %d of %d\n", id
, n
, n_expected
);
953 n
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
954 ok ( n
== -1, "event_client (%x): test pattern error: %d\n", id
, n
);
957 WSACloseEvent ( event
);
958 trace ( "event_client (%x) exiting\n", id
);
962 /* Tests for WSAStartup */
963 static void test_WithoutWSAStartup(void)
967 WSASetLastError(0xdeadbeef);
968 ptr
= gethostbyname("localhost");
970 ok(ptr
== NULL
, "gethostbyname() succeeded unexpectedly: %d\n", WSAGetLastError());
971 ok(WSAGetLastError() == WSANOTINITIALISED
, "gethostbyname() failed with unexpected error: %d\n",
975 static void test_WithWSAStartup(void)
978 WORD version
= MAKEWORD( 2, 2 );
982 res
= WSAStartup( version
, &data
);
983 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
985 ptr
= gethostbyname("localhost");
986 ok(ptr
!= NULL
, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
991 /**************** Main program utility functions ***************/
993 static void Init (void)
995 WORD ver
= MAKEWORD (2, 2);
997 HMODULE hws2_32
= GetModuleHandle("ws2_32.dll");
999 pFreeAddrInfoW
= (void *)GetProcAddress(hws2_32
, "FreeAddrInfoW");
1000 pGetAddrInfoW
= (void *)GetProcAddress(hws2_32
, "GetAddrInfoW");
1001 pInetNtop
= (void *)GetProcAddress(hws2_32
, "inet_ntop");
1003 ok ( WSAStartup ( ver
, &data
) == 0, "WSAStartup failed\n" );
1007 static void Exit (void)
1012 err
= WSAGetLastError();
1013 ok ( ret
== 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret
, err
);
1015 err
= WSAGetLastError();
1016 ok ( (ret
== SOCKET_ERROR
&& err
== WSANOTINITIALISED
) ||
1017 broken(ret
== 0), /* WinME */
1018 "WSACleanup returned %d GetLastError is %d\n", ret
, err
);
1021 static void StartServer (LPTHREAD_START_ROUTINE routine
,
1022 test_params
*general
, server_params
*par
)
1024 par
->general
= general
;
1025 thread
[0] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[0] );
1026 ok ( thread
[0] != NULL
, "Failed to create server thread\n" );
1029 static void StartClients (LPTHREAD_START_ROUTINE routine
,
1030 test_params
*general
, client_params
*par
)
1033 par
->general
= general
;
1034 for ( i
= 1; i
<= min ( general
->n_clients
, MAX_CLIENTS
); i
++ )
1037 thread
[i
] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[i
] );
1038 ok ( thread
[i
] != NULL
, "Failed to create client thread\n" );
1039 /* Make sure the client is up and running */
1040 WaitForSingleObject ( client_ready
[client_id
], INFINITE
);
1044 static void do_test( test_setup
*test
)
1046 DWORD i
, n
= min (test
->general
.n_clients
, MAX_CLIENTS
);
1049 server_ready
= CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1050 for (i
= 0; i
<= n
; i
++)
1051 client_ready
[i
] = CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1053 StartServer ( test
->srv
, &test
->general
, &test
->srv_params
);
1054 StartClients ( test
->clt
, &test
->general
, &test
->clt_params
);
1055 WaitForSingleObject ( server_ready
, INFINITE
);
1057 wait
= WaitForMultipleObjects ( 1 + n
, thread
, TRUE
, 1000 * TEST_TIMEOUT
);
1058 ok ( wait
<= WAIT_OBJECT_0
+ n
,
1059 "some threads have not completed: %x\n", wait
);
1061 if ( ! ( wait
<= WAIT_OBJECT_0
+ n
) )
1063 for (i
= 0; i
<= n
; i
++)
1065 if ( WaitForSingleObject ( thread
[i
], 0 ) != WAIT_OBJECT_0
)
1067 trace ("terminating thread %08x\n", thread_id
[i
]);
1068 TerminateThread ( thread
[i
], 0 );
1072 CloseHandle ( server_ready
);
1073 for (i
= 0; i
<= n
; i
++)
1074 CloseHandle ( client_ready
[i
] );
1077 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1078 /* optname = SO_LINGER */
1079 static const LINGER linger_testvals
[] = {
1086 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1087 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1088 bug in the linux kernel (fixed in 2.6.8) */
1089 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1091 static void test_set_getsockopt(void)
1094 int i
, err
, lasterr
;
1099 s
= socket(AF_INET
, SOCK_STREAM
, 0);
1100 ok(s
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1101 if( s
== INVALID_SOCKET
) return;
1103 timeout
= SOCKTIMEOUT1
;
1104 size
= sizeof(timeout
);
1105 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1107 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1108 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1109 ok( timeout
== SOCKTIMEOUT1
, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1112 size
= sizeof(timeout
);
1113 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1115 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1116 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1117 ok( timeout
== 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1120 timeout
= SOCKTIMEOUT2
; /* 997 seconds. See remark above */
1121 size
= sizeof(timeout
);
1122 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, size
);
1124 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, &size
);
1125 ok( !err
, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1126 ok( timeout
== SOCKTIMEOUT2
, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout
);
1128 for( i
= 0; i
< sizeof(linger_testvals
)/sizeof(LINGER
);i
++) {
1129 size
= sizeof(lingval
);
1130 lingval
= linger_testvals
[i
];
1131 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, size
);
1133 err
= getsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, &size
);
1134 ok( !err
, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1135 ok( !lingval
.l_onoff
== !linger_testvals
[i
].l_onoff
&&
1136 (lingval
.l_linger
== linger_testvals
[i
].l_linger
||
1137 (!lingval
.l_linger
&& !linger_testvals
[i
].l_onoff
))
1138 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i
,
1139 lingval
.l_onoff
, lingval
.l_linger
,
1140 linger_testvals
[i
].l_onoff
, linger_testvals
[i
].l_linger
);
1142 /* Test for erroneously passing a value instead of a pointer as optval */
1143 size
= sizeof(char);
1144 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTROUTE
, (char *)1, size
);
1145 ok(err
== SOCKET_ERROR
, "setsockopt with optval being a value passed "
1146 "instead of failing.\n");
1147 lasterr
= WSAGetLastError();
1148 ok(lasterr
== WSAEFAULT
, "setsockopt with optval being a value "
1149 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1150 lasterr
, WSAEFAULT
);
1152 /* SO_RCVTIMEO with invalid values for level */
1153 size
= sizeof(timeout
);
1154 timeout
= SOCKTIMEOUT1
;
1155 SetLastError(0xdeadbeef);
1156 err
= setsockopt(s
, 0xffffffff, SO_RCVTIMEO
, (char *) &timeout
, size
);
1157 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1158 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL\n",
1159 err
, WSAGetLastError());
1161 timeout
= SOCKTIMEOUT1
;
1162 SetLastError(0xdeadbeef);
1163 err
= setsockopt(s
, 0x00008000, SO_RCVTIMEO
, (char *) &timeout
, size
);
1164 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1165 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL\n",
1166 err
, WSAGetLastError());
1171 static void test_so_reuseaddr(void)
1173 struct sockaddr_in saddr
;
1175 unsigned int rc
,reuse
;
1178 saddr
.sin_family
= AF_INET
;
1179 saddr
.sin_port
= htons(9375);
1180 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1182 s1
=socket(AF_INET
, SOCK_STREAM
, 0);
1183 ok(s1
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1184 rc
= bind(s1
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1185 ok(rc
!=SOCKET_ERROR
, "bind(s1) failed error: %d\n", WSAGetLastError());
1187 s2
=socket(AF_INET
, SOCK_STREAM
, 0);
1188 ok(s2
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1192 rc
=getsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, &size
);
1193 ok(rc
==0 && reuse
==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc
,reuse
);
1195 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1196 ok(rc
==SOCKET_ERROR
, "bind() succeeded\n");
1199 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
1200 ok(rc
==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1202 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1203 * a port immediately after closing another socket on that port, so
1204 * basically following the BSD socket semantics here. */
1206 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1207 ok(rc
==0, "bind() failed error: %d\n", WSAGetLastError());
1212 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1214 static void test_ip_pktinfo(void)
1216 ULONG addresses
[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY
)};
1217 char recvbuf
[10], pktbuf
[512], msg
[] = "HELLO";
1218 struct sockaddr_in s1addr
, s2addr
, s3addr
;
1219 GUID WSARecvMsg_GUID
= WSAID_WSARECVMSG
;
1220 LPFN_WSARECVMSG pWSARecvMsg
= NULL
;
1221 unsigned int rc
, foundhdr
, yes
= 1;
1222 DWORD dwBytes
, dwSize
, dwFlags
;
1231 memset(&ov
, 0, sizeof(ov
));
1232 ov
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
1233 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
1235 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
1239 memset(&hdr
, 0x00, sizeof(hdr
));
1240 s1addr
.sin_family
= AF_INET
;
1241 s1addr
.sin_port
= htons(0);
1242 /* Note: s1addr.sin_addr is set below */
1243 iovec
[0].buf
= recvbuf
;
1244 iovec
[0].len
= sizeof(recvbuf
);
1245 hdr
.name
= (struct sockaddr
*)&s3addr
;
1246 hdr
.namelen
= sizeof(s3addr
);
1247 hdr
.lpBuffers
= &iovec
[0];
1248 hdr
.dwBufferCount
= 1;
1249 hdr
.Control
.buf
= pktbuf
;
1250 /* Note: hdr.Control.len is set below */
1253 for (i
=0;i
<sizeof(addresses
)/sizeof(UINT32
);i
++)
1255 s1addr
.sin_addr
.s_addr
= addresses
[i
];
1257 /* Build "server" side socket */
1258 s1
=socket(AF_INET
, SOCK_DGRAM
, 0);
1259 if (s1
== INVALID_SOCKET
)
1261 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1265 /* Obtain the WSARecvMsg function */
1266 WSAIoctl(s1
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
1267 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &dwBytes
, NULL
, NULL
);
1270 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
1275 /* Setup the server side socket */
1276 rc
=bind(s1
, (struct sockaddr
*)&s1addr
, sizeof(s1addr
));
1277 ok(rc
!= SOCKET_ERROR
, "bind() failed error: %d\n", WSAGetLastError());
1278 rc
=setsockopt(s1
, IPPROTO_IP
, IP_PKTINFO
, (const char*)&yes
, sizeof(yes
));
1279 ok(rc
== 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1281 /* Build "client" side socket */
1282 addrlen
= sizeof(s2addr
);
1283 if (getsockname(s1
, (struct sockaddr
*) &s2addr
, &addrlen
) != 0)
1285 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
1289 s2addr
.sin_addr
.s_addr
= addresses
[0]; /* Always target the local adapter address */
1290 s2
=socket(AF_INET
, SOCK_DGRAM
, 0);
1291 if (s2
== INVALID_SOCKET
)
1293 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1298 /* Test an empty message header */
1299 rc
=pWSARecvMsg(s1
, NULL
, NULL
, NULL
, NULL
);
1300 err
=WSAGetLastError();
1301 ok(rc
== SOCKET_ERROR
&& err
== WSAEFAULT
, "WSARecvMsg() failed error: %d (ret = %d)\n", err
, rc
);
1304 * Send a packet from the client to the server and test for specifying
1305 * a short control header.
1307 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1308 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1309 hdr
.Control
.len
= 1;
1310 rc
=pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
1311 err
=WSAGetLastError();
1312 ok(rc
== SOCKET_ERROR
&& err
== WSAEMSGSIZE
&& (hdr
.dwFlags
& MSG_CTRUNC
),
1313 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err
, rc
, hdr
.dwFlags
);
1314 hdr
.dwFlags
= 0; /* Reset flags */
1316 /* Perform another short control header test, this time with an overlapped receive */
1317 hdr
.Control
.len
= 1;
1318 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1319 err
=WSAGetLastError();
1320 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1321 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1322 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1323 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
1325 skip("Server side did not receive packet, some tests skipped.\n");
1331 WSAGetOverlappedResult(s1
, &ov
, NULL
, FALSE
, &dwFlags
);
1333 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags
);
1334 ok(hdr
.dwFlags
== MSG_CTRUNC
,
1335 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr
.dwFlags
);
1336 hdr
.dwFlags
= 0; /* Reset flags */
1339 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1340 * on the server end and check that the returned packet matches what was sent.
1342 hdr
.Control
.len
= sizeof(pktbuf
);
1343 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1344 err
=WSAGetLastError();
1345 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1346 ok(hdr
.Control
.len
== sizeof(pktbuf
),
1347 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr
.Control
.len
);
1348 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1349 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1350 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
1352 skip("Server side did not receive packet, some tests skipped.\n");
1358 WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, NULL
);
1359 ok(dwSize
== sizeof(msg
),
1360 "WSARecvMsg() buffer length does not match transmitted data!\n");
1361 ok(strncmp(iovec
[0].buf
, msg
, sizeof(msg
)) == 0,
1362 "WSARecvMsg() buffer does not match transmitted data!\n");
1363 ok(hdr
.Control
.len
== IP_PKTINFO_LEN
,
1364 "WSARecvMsg() control length mismatch (%d).\n", hdr
.Control
.len
);
1366 /* Test for the expected IP_PKTINFO return information. */
1368 for (cmsg
= WSA_CMSG_FIRSTHDR(&hdr
); cmsg
!= NULL
; cmsg
= WSA_CMSG_NXTHDR(&hdr
, cmsg
))
1370 if (cmsg
->cmsg_level
== IPPROTO_IP
&& cmsg
->cmsg_type
== IP_PKTINFO
)
1372 struct in_pktinfo
*pi
= (struct in_pktinfo
*)WSA_CMSG_DATA(cmsg
);
1374 ok(pi
->ipi_addr
.s_addr
== s2addr
.sin_addr
.s_addr
, "destination ip mismatch!\n");
1378 ok(foundhdr
, "IP_PKTINFO header information was not returned!\n");
1385 CloseHandle(ov
.hEvent
);
1388 /************* Array containing the tests to run **********/
1390 #define STD_STREAM_SOCKET \
1396 static test_setup tests
[] =
1398 /* Test 0: synchronous client and server */
1419 /* Test 1: event-driven client, synchronous server */
1436 WSA_FLAG_OVERLAPPED
,
1440 /* Test 2: synchronous client, non-blocking server via select() */
1461 /* Test 3: OOB client, OOB server */
1482 /* Test 4: synchronous mixed client and server */
1496 simple_mixed_client
,
1505 static void test_UDP(void)
1507 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
1508 possible that this test fails due to dropped packets. */
1510 /* peer 0 receives data from all other peers */
1511 struct sock_info peer
[NUM_UDP_PEERS
];
1513 int ss
, i
, n_recv
, n_sent
;
1515 memset (buf
,0,sizeof(buf
));
1516 for ( i
= NUM_UDP_PEERS
- 1; i
>= 0; i
-- ) {
1517 ok ( ( peer
[i
].s
= socket ( AF_INET
, SOCK_DGRAM
, 0 ) ) != INVALID_SOCKET
, "UDP: socket failed\n" );
1519 peer
[i
].addr
.sin_family
= AF_INET
;
1520 peer
[i
].addr
.sin_addr
.s_addr
= inet_addr ( SERVERIP
);
1523 peer
[i
].addr
.sin_port
= htons ( SERVERPORT
);
1525 peer
[i
].addr
.sin_port
= htons ( 0 );
1528 do_bind ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, sizeof( peer
[i
].addr
) );
1530 /* test getsockname() to get peer's port */
1531 ss
= sizeof ( peer
[i
].addr
);
1532 ok ( getsockname ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, &ss
) != SOCKET_ERROR
, "UDP: could not getsockname()\n" );
1533 ok ( peer
[i
].addr
.sin_port
!= htons ( 0 ), "UDP: bind() did not associate port\n" );
1536 /* test getsockname() */
1537 ok ( peer
[0].addr
.sin_port
== htons ( SERVERPORT
), "UDP: getsockname returned incorrect peer port\n" );
1539 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
1540 /* send client's ip */
1541 memcpy( buf
, &peer
[i
].addr
.sin_port
, sizeof(peer
[i
].addr
.sin_port
) );
1542 n_sent
= sendto ( peer
[i
].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*) &peer
[0].addr
, sizeof(peer
[0].addr
) );
1543 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
1546 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
1547 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0,(struct sockaddr
*) &peer
[0].peer
, &ss
);
1548 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
1549 ok ( memcmp ( &peer
[0].peer
.sin_port
, buf
, sizeof(peer
[0].addr
.sin_port
) ) == 0, "UDP: port numbers do not match\n" );
1553 static void WINAPI
do_getservbyname( HANDLE
*starttest
)
1559 } serv
[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
1562 struct servent
*pserv
[2];
1564 ok ( WaitForSingleObject ( *starttest
, TEST_TIMEOUT
* 1000 ) != WAIT_TIMEOUT
, "test_getservbyname: timeout waiting for start signal\n");
1566 /* ensure that necessary buffer resizes are completed */
1567 for ( j
= 0; j
< 2; j
++) {
1568 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
1571 for ( i
= 0; i
< NUM_QUERIES
/ 2; i
++ ) {
1572 for ( j
= 0; j
< 2; j
++ ) {
1573 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
1574 ok ( pserv
[j
] != NULL
, "getservbyname could not retrieve information for %s: %d\n", serv
[j
].name
, WSAGetLastError() );
1575 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
) );
1576 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
);
1577 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
);
1580 ok ( pserv
[0] == pserv
[1], "getservbyname: winsock resized servent buffer when not necessary\n" );
1584 static void test_getservbyname(void)
1587 HANDLE starttest
, thread
[NUM_THREADS
];
1588 DWORD thread_id
[NUM_THREADS
];
1590 starttest
= CreateEvent ( NULL
, 1, 0, "test_getservbyname_starttest" );
1592 /* create threads */
1593 for ( i
= 0; i
< NUM_THREADS
; i
++ ) {
1594 thread
[i
] = CreateThread ( NULL
, 0, (LPTHREAD_START_ROUTINE
) &do_getservbyname
, &starttest
, 0, &thread_id
[i
] );
1597 /* signal threads to start */
1598 SetEvent ( starttest
);
1600 for ( i
= 0; i
< NUM_THREADS
; i
++) {
1601 WaitForSingleObject ( thread
[i
], TEST_TIMEOUT
* 1000 );
1605 static void test_WSASocket(void)
1607 SOCKET sock
= INVALID_SOCKET
;
1608 WSAPROTOCOL_INFOA
*pi
;
1609 int providers
[] = {6, 0};
1613 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
1614 * to avoid a crash on win98.
1617 ret
= WSAEnumProtocolsA(providers
, NULL
, &pi_size
);
1618 ok(ret
== SOCKET_ERROR
, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
1620 err
= WSAGetLastError();
1621 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
1624 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
1625 ok(pi
!= NULL
, "Failed to allocate memory\n");
1627 skip("Can't continue without memory.\n");
1631 ret
= WSAEnumProtocolsA(providers
, pi
, &pi_size
);
1632 ok(ret
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
1636 skip("No protocols enumerated.\n");
1637 HeapFree(GetProcessHeap(), 0, pi
);
1641 sock
= WSASocketA(FROM_PROTOCOL_INFO
, FROM_PROTOCOL_INFO
,
1642 FROM_PROTOCOL_INFO
, &pi
[0], 0, 0);
1643 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1647 HeapFree(GetProcessHeap(), 0, pi
);
1650 static void test_WSAAddressToStringA(void)
1652 SOCKET v6
= INVALID_SOCKET
;
1656 SOCKADDR_IN sockaddr
;
1657 CHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1659 CHAR expect1
[] = "0.0.0.0";
1660 CHAR expect2
[] = "255.255.255.255";
1661 CHAR expect3
[] = "0.0.0.0:65535";
1662 CHAR expect4
[] = "255.255.255.255:65535";
1664 SOCKADDR_IN6 sockaddr6
;
1665 CHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
1667 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1668 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1669 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
1671 CHAR expect6_1
[] = "::1";
1672 CHAR expect6_2
[] = "20ab::1";
1673 CHAR expect6_3
[] = "[20ab::2001]:33274";
1674 CHAR expect6_3_nt
[] = "20ab::2001@33274";
1675 CHAR expect6_3_w2k
[] = "20ab::2001";
1676 CHAR expect6_3_2
[] = "[20ab::2001%4660]:33274";
1677 CHAR expect6_3_2_nt
[] = "4660/20ab::2001@33274";
1678 CHAR expect6_3_2_w2k
[] = "20ab::2001%4660";
1679 CHAR expect6_3_3
[] = "20ab::2001%4660";
1680 CHAR expect6_3_3_nt
[] = "4660/20ab::2001";
1684 sockaddr
.sin_family
= AF_INET
;
1685 sockaddr
.sin_port
= 0;
1686 sockaddr
.sin_addr
.s_addr
= 0;
1688 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1689 GLE
= WSAGetLastError();
1690 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
1691 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1694 len
= sizeof(address
);
1696 sockaddr
.sin_family
= AF_INET
;
1697 sockaddr
.sin_port
= 0;
1698 sockaddr
.sin_addr
.s_addr
= 0;
1700 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1701 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1703 ok( !strcmp( address
, expect1
), "Expected: %s, got: %s\n", expect1
, address
);
1704 ok( len
== sizeof( expect1
), "Got size %d\n", len
);
1706 len
= sizeof(address
);
1708 sockaddr
.sin_family
= AF_INET
;
1709 sockaddr
.sin_port
= 0;
1710 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
1712 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1713 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1715 ok( !strcmp( address
, expect2
), "Expected: %s, got: %s\n", expect2
, address
);
1717 len
= sizeof(address
);
1719 sockaddr
.sin_family
= AF_INET
;
1720 sockaddr
.sin_port
= 0xffff;
1721 sockaddr
.sin_addr
.s_addr
= 0;
1723 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1724 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1726 ok( !strcmp( address
, expect3
), "Expected: %s, got: %s\n", expect3
, address
);
1728 len
= sizeof(address
);
1730 sockaddr
.sin_family
= AF_INET
;
1731 sockaddr
.sin_port
= 0xffff;
1732 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
1734 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1735 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1737 ok( !strcmp( address
, expect4
), "Expected: %s, got: %s\n", expect4
, address
);
1738 ok( len
== sizeof( expect4
), "Got size %d\n", len
);
1740 /*check to see it IPv6 is available */
1741 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
1742 if (v6
== INVALID_SOCKET
) {
1743 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
1744 WSAGetLastError(), WSAEAFNOSUPPORT
);
1747 /* Test a short IPv6 address */
1748 len
= sizeof(address6
);
1750 sockaddr6
.sin6_family
= AF_INET6
;
1751 sockaddr6
.sin6_port
= 0x0000;
1752 sockaddr6
.sin6_scope_id
= 0;
1753 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
1755 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1756 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1757 ok( !strcmp( address6
, expect6_1
), "Expected: %s, got: %s\n", expect6_1
, address6
);
1758 ok( len
== sizeof(expect6_1
), "Got size %d\n", len
);
1760 /* Test a longer IPv6 address */
1761 len
= sizeof(address6
);
1763 sockaddr6
.sin6_family
= AF_INET6
;
1764 sockaddr6
.sin6_port
= 0x0000;
1765 sockaddr6
.sin6_scope_id
= 0;
1766 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
1768 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1769 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1770 ok( !strcmp( address6
, expect6_2
), "Expected: %s, got: %s\n", expect6_2
, address6
);
1771 ok( len
== sizeof(expect6_2
), "Got size %d\n", len
);
1773 /* Test IPv6 address and port number */
1774 len
= sizeof(address6
);
1776 sockaddr6
.sin6_family
= AF_INET6
;
1777 sockaddr6
.sin6_port
= 0xfa81;
1778 sockaddr6
.sin6_scope_id
= 0;
1779 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
1781 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1782 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1783 ok( !strcmp( address6
, expect6_3
) ||
1784 broken( !strcmp( address6
, expect6_3_nt
) ) || /* NT4 */
1785 broken( !strcmp( address6
, expect6_3_w2k
) ), /* Win2000 */
1786 "Expected: %s, got: %s\n", expect6_3
, address6
);
1787 ok( len
== sizeof(expect6_3
) ||
1788 broken( len
== sizeof(expect6_3_nt
) ) || /* NT4 */
1789 broken( len
== sizeof(expect6_3_w2k
) ), /* Win2000 */
1790 "Got size %d\n", len
);
1792 /* Test IPv6 address, port number and scope_id */
1793 len
= sizeof(address6
);
1795 sockaddr6
.sin6_family
= AF_INET6
;
1796 sockaddr6
.sin6_port
= 0xfa81;
1797 sockaddr6
.sin6_scope_id
= 0x1234;
1798 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
1800 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1801 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1802 ok( !strcmp( address6
, expect6_3_2
) ||
1803 broken( !strcmp( address6
, expect6_3_2_nt
) ) || /* NT4 */
1804 broken( !strcmp( address6
, expect6_3_2_w2k
) ), /* Win2000 */
1805 "Expected: %s, got: %s\n", expect6_3_2
, address6
);
1806 ok( len
== sizeof(expect6_3_2
) ||
1807 broken( len
== sizeof(expect6_3_2_nt
) ) || /* NT4 */
1808 broken( len
== sizeof(expect6_3_2_w2k
) ), /* Win2000 */
1809 "Got size %d\n", len
);
1811 /* Test IPv6 address and scope_id */
1812 len
= sizeof(address6
);
1814 sockaddr6
.sin6_family
= AF_INET6
;
1815 sockaddr6
.sin6_port
= 0x0000;
1816 sockaddr6
.sin6_scope_id
= 0x1234;
1817 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
1819 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1820 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1821 ok( !strcmp( address6
, expect6_3_3
) ||
1822 broken( !strcmp( address6
, expect6_3_3_nt
) ), /* NT4 */
1823 "Expected: %s, got: %s\n", expect6_3_3
, address6
);
1824 ok( len
== sizeof(expect6_3_3
) ||
1825 broken( len
== sizeof(expect6_3_3_nt
) ), /* NT4 */
1826 "Got size %d\n", len
);
1829 if (v6
!= INVALID_SOCKET
)
1833 static void test_WSAAddressToStringW(void)
1835 SOCKET v6
= INVALID_SOCKET
;
1839 SOCKADDR_IN sockaddr
;
1840 WCHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1842 WCHAR expect1
[] = { '0','.','0','.','0','.','0', 0 };
1843 WCHAR expect2
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1844 WCHAR expect3
[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
1845 WCHAR expect4
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1846 '6', '5', '5', '3', '5', 0 };
1848 SOCKADDR_IN6 sockaddr6
;
1849 WCHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
1851 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1852 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1853 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
1855 WCHAR expect6_1
[] = {':',':','1',0};
1856 WCHAR expect6_2
[] = {'2','0','a','b',':',':','1',0};
1857 WCHAR expect6_3
[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
1858 WCHAR expect6_3_nt
[] = {'2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
1859 WCHAR expect6_3_w2k
[] = {'2','0','a','b',':',':','2','0','0','1',0};
1860 WCHAR expect6_3_2
[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
1861 WCHAR expect6_3_2_nt
[] = {'4','6','6','0','/','2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
1862 WCHAR expect6_3_2_w2k
[] = {'2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',0};
1863 WCHAR expect6_3_3
[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
1864 WCHAR expect6_3_3_nt
[] = {'6','5','5','3','4','/','2','0','a','b',':',':','2','0','0','1',0};
1868 sockaddr
.sin_family
= AF_INET
;
1869 sockaddr
.sin_port
= 0;
1870 sockaddr
.sin_addr
.s_addr
= 0;
1872 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1873 GLE
= WSAGetLastError();
1874 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
1875 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1878 len
= sizeof(address
);
1880 sockaddr
.sin_family
= AF_INET
;
1881 sockaddr
.sin_port
= 0;
1882 sockaddr
.sin_addr
.s_addr
= 0;
1884 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1885 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1887 ok( !lstrcmpW( address
, expect1
), "Expected different address string\n" );
1888 ok( len
== sizeof( expect1
)/sizeof( WCHAR
), "Got size %d\n", len
);
1890 len
= sizeof(address
);
1892 sockaddr
.sin_family
= AF_INET
;
1893 sockaddr
.sin_port
= 0;
1894 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
1896 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1897 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1899 ok( !lstrcmpW( address
, expect2
), "Expected different address string\n" );
1901 len
= sizeof(address
);
1903 sockaddr
.sin_family
= AF_INET
;
1904 sockaddr
.sin_port
= 0xffff;
1905 sockaddr
.sin_addr
.s_addr
= 0;
1907 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1908 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1910 ok( !lstrcmpW( address
, expect3
), "Expected different address string\n" );
1912 len
= sizeof(address
);
1914 sockaddr
.sin_family
= AF_INET
;
1915 sockaddr
.sin_port
= 0xffff;
1916 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
1918 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
1919 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1921 ok( !lstrcmpW( address
, expect4
), "Expected different address string\n" );
1922 ok( len
== sizeof( expect4
)/sizeof( WCHAR
), "Got %d\n", len
);
1924 /*check to see it IPv6 is available */
1925 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
1926 if (v6
== INVALID_SOCKET
) {
1927 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
1928 WSAGetLastError(), WSAEAFNOSUPPORT
);
1932 /* Test a short IPv6 address */
1933 len
= sizeof(address6
)/sizeof(WCHAR
);
1935 sockaddr6
.sin6_family
= AF_INET6
;
1936 sockaddr6
.sin6_port
= 0x0000;
1937 sockaddr6
.sin6_scope_id
= 0;
1938 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
1940 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1941 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1942 ok( !lstrcmpW( address6
, expect6_1
), "Wrong string returned\n" );
1943 ok( len
== sizeof(expect6_1
)/sizeof(WCHAR
), "Got %d\n", len
);
1945 /* Test a longer IPv6 address */
1946 len
= sizeof(address6
)/sizeof(WCHAR
);
1948 sockaddr6
.sin6_family
= AF_INET6
;
1949 sockaddr6
.sin6_port
= 0x0000;
1950 sockaddr6
.sin6_scope_id
= 0;
1951 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
1953 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1954 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1956 ok( !lstrcmpW( address6
, expect6_2
), "Wrong string returned\n" );
1957 ok( len
== sizeof(expect6_2
)/sizeof(WCHAR
), "Got %d\n", len
);
1959 /* Test IPv6 address and port number */
1960 len
= sizeof(address6
)/sizeof(WCHAR
);
1962 sockaddr6
.sin6_family
= AF_INET6
;
1963 sockaddr6
.sin6_port
= 0xfa81;
1964 sockaddr6
.sin6_scope_id
= 0;
1965 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
1967 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1968 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1969 ok( !lstrcmpW( address6
, expect6_3
) ||
1970 broken( !lstrcmpW( address6
, expect6_3_nt
) ) || /* NT4 */
1971 broken( !lstrcmpW( address6
, expect6_3_w2k
) ), /* Win2000 */
1972 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3
),
1973 wine_dbgstr_w(address6
) );
1974 ok( len
== sizeof(expect6_3
)/sizeof(WCHAR
) ||
1975 broken(len
== sizeof(expect6_3_nt
)/sizeof(WCHAR
) ) || /* NT4 */
1976 broken(len
== sizeof(expect6_3_w2k
)/sizeof(WCHAR
) ), /* Win2000 */
1979 /* Test IPv6 address, port number and scope_id */
1980 len
= sizeof(address6
)/sizeof(WCHAR
);
1982 sockaddr6
.sin6_family
= AF_INET6
;
1983 sockaddr6
.sin6_port
= 0xfa81;
1984 sockaddr6
.sin6_scope_id
= 0x1234;
1985 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
1987 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
1988 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1989 ok( !lstrcmpW( address6
, expect6_3_2
) ||
1990 broken( !lstrcmpW( address6
, expect6_3_2_nt
) ) || /* NT4 */
1991 broken( !lstrcmpW( address6
, expect6_3_2_w2k
) ), /* Win2000 */
1992 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2
),
1993 wine_dbgstr_w(address6
) );
1994 ok( len
== sizeof(expect6_3_2
)/sizeof(WCHAR
) ||
1995 broken( len
== sizeof(expect6_3_2_nt
)/sizeof(WCHAR
) ) || /* NT4 */
1996 broken( len
== sizeof(expect6_3_2_w2k
)/sizeof(WCHAR
) ), /* Win2000 */
1999 /* Test IPv6 address and scope_id */
2000 len
= sizeof(address6
)/sizeof(WCHAR
);
2002 sockaddr6
.sin6_family
= AF_INET6
;
2003 sockaddr6
.sin6_port
= 0x0000;
2004 sockaddr6
.sin6_scope_id
= 0xfffe;
2005 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2007 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2008 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2009 ok( !lstrcmpW( address6
, expect6_3_3
) ||
2010 broken( !lstrcmpW( address6
, expect6_3_3_nt
) ), /* NT4 */
2011 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3
),
2012 wine_dbgstr_w(address6
) );
2013 ok( len
== sizeof(expect6_3_3
)/sizeof(WCHAR
) ||
2014 broken( len
== sizeof(expect6_3_3_nt
)/sizeof(WCHAR
) ), /* NT4 */
2018 if (v6
!= INVALID_SOCKET
)
2022 static void test_WSAStringToAddressA(void)
2025 SOCKADDR_IN sockaddr
;
2026 SOCKADDR_IN6 sockaddr6
;
2029 CHAR address1
[] = "0.0.0.0";
2030 CHAR address2
[] = "127.127.127.127";
2031 CHAR address3
[] = "255.255.255.255";
2032 CHAR address4
[] = "127.127.127.127:65535";
2033 CHAR address5
[] = "255.255.255.255:65535";
2034 CHAR address6
[] = "::1";
2035 CHAR address7
[] = "[::1]";
2036 CHAR address8
[] = "[::1]:65535";
2039 sockaddr
.sin_family
= AF_INET
;
2041 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2042 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
2043 WSAGetLastError() );
2045 len
= sizeof(sockaddr
);
2046 sockaddr
.sin_port
= 0;
2047 sockaddr
.sin_addr
.s_addr
= 0;
2049 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2050 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
2051 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
2053 len
= sizeof(sockaddr
);
2054 sockaddr
.sin_port
= 0;
2055 sockaddr
.sin_addr
.s_addr
= 0;
2057 ret
= WSAStringToAddressA( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2058 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
2059 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
2061 len
= sizeof(sockaddr
);
2062 sockaddr
.sin_port
= 0;
2063 sockaddr
.sin_addr
.s_addr
= 0;
2065 ret
= WSAStringToAddressA( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2066 GLE
= WSAGetLastError();
2067 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
2068 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2069 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
2071 len
= sizeof(sockaddr
);
2072 sockaddr
.sin_port
= 0;
2073 sockaddr
.sin_addr
.s_addr
= 0;
2075 ret
= WSAStringToAddressA( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2076 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
2077 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
2079 len
= sizeof(sockaddr
);
2080 sockaddr
.sin_port
= 0;
2081 sockaddr
.sin_addr
.s_addr
= 0;
2083 ret
= WSAStringToAddressA( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2084 GLE
= WSAGetLastError();
2085 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
2086 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2087 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
2089 len
= sizeof(sockaddr6
);
2090 memset(&sockaddr6
, 0, len
);
2091 sockaddr6
.sin6_family
= AF_INET6
;
2093 ret
= WSAStringToAddressA( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2095 GLE
= WSAGetLastError();
2096 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2097 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
2099 len
= sizeof(sockaddr6
);
2100 memset(&sockaddr6
, 0, len
);
2101 sockaddr6
.sin6_family
= AF_INET6
;
2103 ret
= WSAStringToAddressA( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2105 GLE
= WSAGetLastError();
2106 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2107 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
2109 len
= sizeof(sockaddr6
);
2110 memset(&sockaddr6
, 0, len
);
2111 sockaddr6
.sin6_family
= AF_INET6
;
2113 ret
= WSAStringToAddressA( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2115 GLE
= WSAGetLastError();
2116 ok( (ret
== 0 && sockaddr6
.sin6_port
== 0xffff) ||
2117 (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2118 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
2122 static void test_WSAStringToAddressW(void)
2125 SOCKADDR_IN sockaddr
, *sin
;
2126 SOCKADDR_IN6 sockaddr6
;
2127 SOCKADDR_STORAGE sockaddr_storage
;
2130 WCHAR address1
[] = { '0','.','0','.','0','.','0', 0 };
2131 WCHAR address2
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
2132 WCHAR address3
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
2133 WCHAR address4
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
2134 ':', '6', '5', '5', '3', '5', 0 };
2135 WCHAR address5
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
2136 '6', '5', '5', '3', '5', 0 };
2137 WCHAR address6
[] = {':',':','1','\0'};
2138 WCHAR address7
[] = {'[',':',':','1',']','\0'};
2139 WCHAR address8
[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
2142 sockaddr
.sin_family
= AF_INET
;
2144 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2145 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressW() failed unexpectedly: %d\n",
2146 WSAGetLastError() );
2148 len
= sizeof(sockaddr
);
2149 sockaddr
.sin_port
= 0;
2150 sockaddr
.sin_addr
.s_addr
= 0;
2152 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2153 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
2154 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2156 len
= sizeof(sockaddr
);
2157 sockaddr
.sin_port
= 0;
2158 sockaddr
.sin_addr
.s_addr
= 0;
2160 ret
= WSAStringToAddressW( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2161 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
2162 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2164 len
= sizeof(sockaddr
);
2165 sockaddr
.sin_port
= 0;
2166 sockaddr
.sin_addr
.s_addr
= 0;
2168 ret
= WSAStringToAddressW( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2169 GLE
= WSAGetLastError();
2170 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
2171 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2172 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
2174 len
= sizeof(sockaddr
);
2175 sockaddr
.sin_port
= 0;
2176 sockaddr
.sin_addr
.s_addr
= 0;
2178 ret
= WSAStringToAddressW( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2179 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
2180 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2182 len
= sizeof(sockaddr
);
2183 sockaddr
.sin_port
= 0;
2184 sockaddr
.sin_addr
.s_addr
= 0;
2186 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2187 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
2188 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2189 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
2191 /* Test with a larger buffer than necessary */
2192 len
= sizeof(sockaddr_storage
);
2193 sin
= (SOCKADDR_IN
*)&sockaddr_storage
;
2195 sin
->sin_addr
.s_addr
= 0;
2197 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)sin
, &len
);
2198 ok( (ret
== 0 && sin
->sin_addr
.s_addr
== 0xffffffff && sin
->sin_port
== 0xffff) ||
2199 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2200 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
2201 ok( len
== sizeof(SOCKADDR_IN
) ||
2202 broken(len
== sizeof(SOCKADDR_STORAGE
)) /* NT4/2k */,
2203 "unexpected length %d\n", len
);
2205 len
= sizeof(sockaddr6
);
2206 memset(&sockaddr6
, 0, len
);
2207 sockaddr6
.sin6_family
= AF_INET6
;
2209 ret
= WSAStringToAddressW( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2211 GLE
= WSAGetLastError();
2212 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2213 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
2215 len
= sizeof(sockaddr6
);
2216 memset(&sockaddr6
, 0, len
);
2217 sockaddr6
.sin6_family
= AF_INET6
;
2219 ret
= WSAStringToAddressW( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2221 GLE
= WSAGetLastError();
2222 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2223 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
2225 len
= sizeof(sockaddr6
);
2226 memset(&sockaddr6
, 0, len
);
2227 sockaddr6
.sin6_family
= AF_INET6
;
2229 ret
= WSAStringToAddressW( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2231 GLE
= WSAGetLastError();
2232 ok( (ret
== 0 && sockaddr6
.sin6_port
== 0xffff) ||
2233 (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2234 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
2238 static VOID WINAPI
SelectReadThread(select_thread_params
*par
)
2242 struct sockaddr_in addr
;
2243 struct timeval select_timeout
;
2246 FD_SET(par
->s
, &readfds
);
2247 select_timeout
.tv_sec
=5;
2248 select_timeout
.tv_usec
=0;
2249 addr
.sin_family
= AF_INET
;
2250 addr
.sin_addr
.s_addr
= inet_addr(SERVERIP
);
2251 addr
.sin_port
= htons(SERVERPORT
);
2253 do_bind(par
->s
, (struct sockaddr
*)&addr
, sizeof(addr
));
2254 wsa_ok(listen(par
->s
, SOMAXCONN
), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
2256 SetEvent(server_ready
);
2257 ret
= select(par
->s
+1, &readfds
, NULL
, NULL
, &select_timeout
);
2258 par
->ReadKilled
= (ret
== 1);
2261 static void test_select(void)
2263 SOCKET fdRead
, fdWrite
;
2264 fd_set readfds
, writefds
, exceptfds
;
2267 struct timeval select_timeout
;
2268 select_thread_params thread_params
;
2269 HANDLE thread_handle
;
2272 fdRead
= socket(AF_INET
, SOCK_STREAM
, 0);
2273 ok( (fdRead
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2274 fdWrite
= socket(AF_INET
, SOCK_STREAM
, 0);
2275 ok( (fdWrite
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2279 FD_ZERO(&exceptfds
);
2280 FD_SET(fdRead
, &readfds
);
2281 FD_SET(fdWrite
, &writefds
);
2282 FD_SET(fdRead
, &exceptfds
);
2283 FD_SET(fdWrite
, &exceptfds
);
2284 select_timeout
.tv_sec
=0;
2285 select_timeout
.tv_usec
=500;
2288 if (fdWrite
> maxfd
)
2292 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2293 ok ( (ret
== 0), "select should not return any socket handles\n");
2294 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
2295 ok ( !FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
2298 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
2299 ok ( !FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
2302 ok ((listen(fdWrite
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
2304 ret
= closesocket(fdWrite
);
2305 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
2307 thread_params
.s
= fdRead
;
2308 thread_params
.ReadKilled
= FALSE
;
2309 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
2310 thread_handle
= CreateThread (NULL
, 0, (LPTHREAD_START_ROUTINE
) &SelectReadThread
, &thread_params
, 0, &id
);
2311 ok ( (thread_handle
!= NULL
), "CreateThread failed unexpectedly: %d\n", GetLastError());
2313 WaitForSingleObject (server_ready
, INFINITE
);
2315 ret
= closesocket(fdRead
);
2316 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
2318 WaitForSingleObject (thread_handle
, 1000);
2319 ok ( (thread_params
.ReadKilled
) ||
2320 broken(thread_params
.ReadKilled
== 0), /*Win98*/
2321 "closesocket did not wakeup select\n");
2323 /* Test selecting invalid handles */
2326 FD_ZERO(&exceptfds
);
2329 ret
= select(maxfd
+1, 0, 0, 0, &select_timeout
);
2330 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2331 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
2334 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2335 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2336 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
2338 FD_SET(INVALID_SOCKET
, &readfds
);
2340 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2341 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2342 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
2343 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
2346 FD_SET(INVALID_SOCKET
, &writefds
);
2348 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2349 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2350 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
2351 ok ( !FD_ISSET(fdRead
, &writefds
), "FD should not be set\n");
2354 FD_SET(INVALID_SOCKET
, &exceptfds
);
2356 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
2357 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
2358 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
2359 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
2362 static DWORD WINAPI
AcceptKillThread(select_thread_params
*par
)
2364 struct sockaddr_in address
;
2365 int len
= sizeof(address
);
2366 SOCKET client_socket
;
2368 SetEvent(server_ready
);
2369 client_socket
= accept(par
->s
, (struct sockaddr
*) &address
, &len
);
2370 if (client_socket
!= INVALID_SOCKET
)
2371 closesocket(client_socket
);
2372 par
->ReadKilled
= (client_socket
== INVALID_SOCKET
);
2377 static int CALLBACK
AlwaysDeferConditionFunc(LPWSABUF lpCallerId
, LPWSABUF lpCallerData
, LPQOS pQos
,
2378 LPQOS lpGQOS
, LPWSABUF lpCalleeId
, LPWSABUF lpCalleeData
,
2379 GROUP FAR
* g
, DWORD_PTR dwCallbackData
)
2384 static void test_accept(void)
2387 SOCKET server_socket
= INVALID_SOCKET
, accepted
= INVALID_SOCKET
, connector
= INVALID_SOCKET
;
2388 struct sockaddr_in address
;
2390 select_thread_params thread_params
;
2391 HANDLE thread_handle
= NULL
;
2394 server_socket
= socket(AF_INET
, SOCK_STREAM
, 0);
2395 if (server_socket
== INVALID_SOCKET
)
2397 trace("error creating server socket: %d\n", WSAGetLastError());
2401 memset(&address
, 0, sizeof(address
));
2402 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2403 address
.sin_family
= AF_INET
;
2404 ret
= bind(server_socket
, (struct sockaddr
*) &address
, sizeof(address
));
2407 trace("error binding server socket: %d\n", WSAGetLastError());
2411 socklen
= sizeof(address
);
2412 ret
= getsockname(server_socket
, (struct sockaddr
*)&address
, &socklen
);
2414 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
2418 ret
= listen(server_socket
, 5);
2421 trace("error making server socket listen: %d\n", WSAGetLastError());
2425 trace("Blocking accept next\n");
2427 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
2428 ok(connector
!= INVALID_SOCKET
, "Failed to create connector socket, error %d\n", WSAGetLastError());
2430 ret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
2431 ok(ret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
2433 accepted
= WSAAccept(server_socket
, NULL
, NULL
, (LPCONDITIONPROC
) AlwaysDeferConditionFunc
, 0);
2434 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
2436 accepted
= accept(server_socket
, NULL
, 0);
2437 ok(accepted
!= INVALID_SOCKET
, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
2439 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
2440 if (server_ready
== INVALID_HANDLE_VALUE
)
2442 trace("error creating event: %d\n", GetLastError());
2446 thread_params
.s
= server_socket
;
2447 thread_params
.ReadKilled
= FALSE
;
2448 thread_handle
= CreateThread(NULL
, 0, (LPTHREAD_START_ROUTINE
) AcceptKillThread
,
2449 &thread_params
, 0, &id
);
2450 if (thread_handle
== NULL
)
2452 trace("error creating thread: %d\n", GetLastError());
2456 WaitForSingleObject(server_ready
, INFINITE
);
2458 ret
= closesocket(server_socket
);
2461 trace("closesocket failed: %d\n", WSAGetLastError());
2465 WaitForSingleObject(thread_handle
, 1000);
2466 ok(thread_params
.ReadKilled
|| broken(!thread_params
.ReadKilled
) /* Win98/ME, after accept */,
2467 "closesocket did not wakeup accept\n");
2470 if (accepted
!= INVALID_SOCKET
)
2471 closesocket(accepted
);
2472 if (connector
!= INVALID_SOCKET
)
2473 closesocket(connector
);
2474 if (thread_handle
!= NULL
)
2475 CloseHandle(thread_handle
);
2476 if (server_ready
!= INVALID_HANDLE_VALUE
)
2477 CloseHandle(server_ready
);
2478 if (server_socket
!= INVALID_SOCKET
)
2479 closesocket(server_socket
);
2482 static void test_extendedSocketOptions(void)
2486 struct sockaddr_in sa
;
2487 int sa_len
= sizeof(struct sockaddr_in
);
2488 int optval
, optlen
= sizeof(int), ret
;
2492 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
2493 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
2497 memset(&sa
, 0, sa_len
);
2499 sa
.sin_family
= AF_INET
;
2500 sa
.sin_port
= htons(0);
2501 sa
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
2503 if((sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
2504 trace("Creating the socket failed: %d\n", WSAGetLastError());
2509 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
2510 trace("Failed to bind socket: %d\n", WSAGetLastError());
2516 ret
= getsockopt(sock
, SOL_SOCKET
, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
2518 ok(ret
== 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret
);
2519 ok((optval
== 65507) || (optval
== 65527),
2520 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval
);
2522 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
2523 SetLastError(0xdeadbeef);
2524 optval
= 0xdeadbeef;
2525 optlen
= sizeof(int);
2526 ret
= getsockopt(sock
, 0xffffffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
2527 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
2528 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2529 ret
, WSAGetLastError(), optval
, optval
);
2531 /* more invalid values for level */
2532 SetLastError(0xdeadbeef);
2533 optval
= 0xdeadbeef;
2534 optlen
= sizeof(int);
2535 ret
= getsockopt(sock
, 0x1234ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
2536 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
2537 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2538 ret
, WSAGetLastError(), optval
, optval
);
2540 SetLastError(0xdeadbeef);
2541 optval
= 0xdeadbeef;
2542 optlen
= sizeof(int);
2543 ret
= getsockopt(sock
, 0x8000ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
2544 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
2545 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2546 ret
, WSAGetLastError(), optval
, optval
);
2548 SetLastError(0xdeadbeef);
2549 optval
= 0xdeadbeef;
2550 optlen
= sizeof(int);
2551 ret
= getsockopt(sock
, 0x00008000, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
2552 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
2553 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2554 ret
, WSAGetLastError(), optval
, optval
);
2556 SetLastError(0xdeadbeef);
2557 optval
= 0xdeadbeef;
2558 optlen
= sizeof(int);
2559 ret
= getsockopt(sock
, 0x00000800, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
2560 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
2561 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2562 ret
, WSAGetLastError(), optval
, optval
);
2564 optlen
= sizeof(LINGER
);
2565 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
2567 ok(ret
== SOCKET_ERROR
, "getsockopt should fail for UDP sockets but return value is 0x%08x\n", ret
);
2572 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
2573 trace("Creating the socket failed: %d\n", WSAGetLastError());
2578 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
2579 trace("Failed to bind socket: %d\n", WSAGetLastError());
2585 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
2586 ok(ret
== 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret
);
2588 optlen
= sizeof(BOOL
);
2589 ret
= getsockopt(sock
, SOL_SOCKET
, SO_DONTLINGER
, (char *)&bool_opt_val
, &optlen
);
2590 ok(ret
== 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret
);
2591 ok((linger_val
.l_onoff
&& !bool_opt_val
) || (!linger_val
.l_onoff
&& bool_opt_val
),
2592 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
2593 bool_opt_val
, linger_val
.l_onoff
);
2599 static void test_getsockname(void)
2603 struct sockaddr_in sa_set
, sa_get
;
2604 int sa_set_len
= sizeof(struct sockaddr_in
);
2605 int sa_get_len
= sa_set_len
;
2606 static const unsigned char null_padding
[] = {0,0,0,0,0,0,0,0};
2609 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
2610 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
2614 memset(&sa_set
, 0, sa_set_len
);
2616 sa_set
.sin_family
= AF_INET
;
2617 sa_set
.sin_port
= htons(0);
2618 sa_set
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
2620 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
2621 trace("Creating the socket failed: %d\n", WSAGetLastError());
2626 memcpy(&sa_get
, &sa_set
, sizeof(sa_set
));
2627 if (getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) == 0)
2628 ok(0, "getsockname on unbound socket should fail\n");
2630 ok(WSAGetLastError() == WSAEINVAL
, "getsockname on unbound socket "
2631 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL
);
2632 ok(memcmp(&sa_get
, &sa_set
, sizeof(sa_get
)) == 0,
2633 "failed getsockname modified sockaddr when it shouldn't\n");
2636 if(bind(sock
, (struct sockaddr
*) &sa_set
, sa_set_len
) < 0){
2637 trace("Failed to bind socket: %d\n", WSAGetLastError());
2643 if(getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) != 0){
2644 trace("Failed to call getsockname: %d\n", WSAGetLastError());
2650 ret
= memcmp(sa_get
.sin_zero
, null_padding
, 8);
2651 ok(ret
== 0 || broken(ret
!= 0), /* NT4 */
2652 "getsockname did not zero the sockaddr_in structure\n");
2658 static void test_dns(void)
2662 h
= gethostbyname("");
2663 ok(h
!= NULL
, "gethostbyname(\"\") failed with %d\n", h_errno
);
2666 /* Our winsock headers don't define gethostname because it conflicts with the
2667 * definition in unistd.h. Define it here to get rid of the warning. */
2669 int WINAPI
gethostname(char *name
, int namelen
);
2671 static void test_gethostbyname_hack(void)
2675 static BYTE loopback
[] = {127, 0, 0, 1};
2676 static BYTE magic_loopback
[] = {127, 12, 34, 56};
2679 ret
= gethostname(name
, 256);
2680 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
2682 he
= gethostbyname("localhost");
2683 ok(he
!= NULL
, "gethostbyname(\"localhost\") failed: %d\n", h_errno
);
2686 if(he
->h_length
!= 4)
2688 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
2692 ok(memcmp(he
->h_addr_list
[0], loopback
, he
->h_length
) == 0,
2693 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
2694 he
->h_addr_list
[0][0], he
->h_addr_list
[0][1], he
->h_addr_list
[0][2],
2695 he
->h_addr_list
[0][3]);
2698 if(strcmp(name
, "localhost") == 0)
2700 skip("hostname seems to be \"localhost\", skipping test.\n");
2705 he
= gethostbyname(name
);
2706 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, h_errno
);
2709 if(he
->h_length
!= 4)
2711 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
2715 if (he
->h_addr_list
[0][0] == 127)
2717 ok(memcmp(he
->h_addr_list
[0], magic_loopback
, he
->h_length
) == 0,
2718 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
2719 name
, he
->h_addr_list
[0][0], he
->h_addr_list
[0][1],
2720 he
->h_addr_list
[0][2], he
->h_addr_list
[0][3]);
2724 gethostbyname("nonexistent.winehq.org");
2725 /* Don't check for the return value, as some braindead ISPs will kindly
2726 * resolve nonexistent host names to addresses of the ISP's spam pages. */
2729 static void test_inet_addr(void)
2733 addr
= inet_addr(NULL
);
2734 ok(addr
== INADDR_NONE
, "inet_addr succeeded unexpectedly\n");
2737 static void test_addr_to_print(void)
2743 struct in6_addr in6
;
2745 u_long addr0_Num
= 0x00000000;
2746 PCSTR addr0_Str
= "0.0.0.0";
2747 u_long addr1_Num
= 0x20201015;
2748 PCSTR addr1_Str
= "21.16.32.32";
2749 u_char addr2_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
2750 PCSTR addr2_Str
= "::fffe:cc98:bd74";
2751 u_char addr3_Num
[16] = {0x20,0x30,0xa4,0xb1};
2752 PCSTR addr3_Str
= "2030:a4b1::";
2753 u_char addr4_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
2754 PCSTR addr4_Str
= "::204.152.189.116";
2756 /* Test IPv4 addresses */
2757 in
.s_addr
= addr0_Num
;
2759 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
2760 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
2761 ok(!strcmp(pdst
, addr0_Str
),"Address %s != %s\n", pdst
, addr0_Str
);
2763 /* Test that inet_ntoa and inet_ntop return the same value */
2764 in
.S_un
.S_addr
= addr1_Num
;
2765 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
2766 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
2767 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
2769 /* InetNtop became available in Vista and Win2008 */
2772 win_skip("InetNtop not present, not executing tests\n");
2776 /* Second part of test */
2777 pdst
= pInetNtop(AF_INET
,(void*)&in
.s_addr
, dst
, sizeof(dst
));
2778 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst
);
2779 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
2781 /* Test invalid parm conditions */
2782 pdst
= pInetNtop(1, (void*)&in
.s_addr
, dst
, sizeof(dst
));
2783 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2784 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "Should be WSAEAFNOSUPPORT\n");
2786 /* Test Null destination */
2788 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, NULL
, sizeof(dst
));
2789 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2790 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
2791 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2793 /* Test zero length passed */
2796 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 0);
2797 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2798 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
2799 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2801 /* Test length one shorter than the address length */
2804 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 6);
2805 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2806 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
2807 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2809 /* Test longer length is ok */
2812 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, sizeof(dst
)+1);
2813 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
2814 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
2816 /* Test the IPv6 addresses */
2818 /* Test an zero prefixed IPV6 address */
2819 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
2820 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
2821 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
2822 ok(!strcmp(pdst
, addr2_Str
),"Address %s != %s\n", pdst
, addr2_Str
);
2824 /* Test an zero suffixed IPV6 address */
2825 memcpy(in6
.s6_addr
, addr3_Num
, sizeof(addr3_Num
));
2826 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
2827 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
2828 ok(!strcmp(pdst
, addr3_Str
),"Address %s != %s\n", pdst
, addr3_Str
);
2830 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
2831 memcpy(in6
.s6_addr
, addr4_Num
, sizeof(addr4_Num
));
2832 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
2833 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
2834 ok(!strcmp(pdst
, addr4_Str
),"Address %s != %s\n", pdst
, addr4_Str
);
2836 /* Test invalid parm conditions */
2837 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
2839 /* Test Null destination */
2841 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, NULL
, sizeof(dst6
));
2842 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2843 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
2844 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2846 /* Test zero length passed */
2849 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 0);
2850 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2851 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
2852 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2854 /* Test length one shorter than the address length */
2857 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 16);
2858 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
2859 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
2860 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2862 /* Test longer length is ok */
2865 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 18);
2866 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
2869 static void test_ioctlsocket(void)
2873 static const LONG cmds
[] = {FIONBIO
, FIONREAD
, SIOCATMARK
};
2877 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
2878 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
2879 if(sock
== INVALID_SOCKET
)
2881 skip("Can't continue without a socket.\n");
2885 for(i
= 0; i
< sizeof(cmds
)/sizeof(cmds
[0]); i
++)
2887 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
2888 ret
= ioctlsocket(sock
, cmds
[i
], (u_long
*)1);
2889 ok(ret
== SOCKET_ERROR
, "ioctlsocket succeeded unexpectedly\n");
2890 ret
= WSAGetLastError();
2891 ok(ret
== WSAEFAULT
, "expected WSAEFAULT, got %d instead\n", ret
);
2894 /* A fresh and not connected socket has no urgent data, this test shows
2895 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
2897 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
2898 if(ret
!= SOCKET_ERROR
)
2899 todo_wine
ok(arg
, "expected a non-zero value\n");
2902 static int drain_pause
=0;
2903 static DWORD WINAPI
drain_socket_thread(LPVOID arg
)
2906 SOCKET sock
= *(SOCKET
*)arg
;
2909 while ((ret
= recv(sock
, buffer
, sizeof(buffer
), 0)) != 0)
2913 if (WSAGetLastError() == WSAEWOULDBLOCK
)
2917 FD_SET(sock
, &readset
);
2918 select(0, &readset
, NULL
, NULL
, NULL
);
2929 static void test_send(void)
2931 SOCKET src
= INVALID_SOCKET
;
2932 SOCKET dst
= INVALID_SOCKET
;
2933 HANDLE hThread
= NULL
;
2934 const int buflen
= 1024*1024;
2935 char *buffer
= NULL
;
2936 int ret
, i
, zero
= 0;
2940 DWORD id
, bytes_sent
, dwRet
;
2942 memset(&ov
, 0, sizeof(ov
));
2944 if (tcp_socketpair(&src
, &dst
) != 0)
2946 ok(0, "creating socket pair failed, skipping test\n");
2950 set_blocking(dst
, FALSE
);
2951 /* force disable buffering so we can get a pending overlapped request */
2952 ret
= setsockopt(dst
, SOL_SOCKET
, SO_SNDBUF
, (char *) &zero
, sizeof(zero
));
2953 ok(!ret
, "setsockopt SO_SNDBUF failed: %d - %d\n", ret
, GetLastError());
2955 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
2956 if (hThread
== NULL
)
2958 ok(0, "CreateThread failed, error %d\n", GetLastError());
2962 buffer
= HeapAlloc(GetProcessHeap(), 0, buflen
);
2965 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
2969 /* fill the buffer with some nonsense */
2970 for (i
= 0; i
< buflen
; ++i
)
2972 buffer
[i
] = (char) i
;
2975 ret
= send(src
, buffer
, buflen
, 0);
2977 ok(ret
== buflen
, "send should have sent %d bytes, but it only sent %d\n", buflen
, ret
);
2979 ok(0, "send failed, error %d\n", WSAGetLastError());
2984 ov
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
2985 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
2990 ret
= WSASend(dst
, &buf
, 1, &bytes_sent
, 0, &ov
, NULL
);
2991 ok((ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
) || broken(bytes_sent
== buflen
),
2992 "Failed to start overlapped send %d - %d - %d/%d\n", ret
, WSAGetLastError(), bytes_sent
, buflen
);
2994 /* don't check for completion yet, we may need to drain the buffer while still sending */
2995 set_blocking(src
, FALSE
);
2996 for (i
= 0; i
< buflen
; ++i
)
3000 ret
= recv(src
, buffer
, 1, 0);
3001 while (ret
== SOCKET_ERROR
&& GetLastError() == WSAEWOULDBLOCK
&& j
< 100)
3005 ret
= recv(src
, buffer
, 1, 0);
3008 ok(ret
== 1, "Failed to receive data %d - %d (got %d/%d)\n", ret
, GetLastError(), i
, buflen
);
3012 ok(buffer
[0] == (char) i
, "Received bad data at position %d\n", i
);
3015 dwRet
= WaitForSingleObject(ov
.hEvent
, 1000);
3016 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
3017 if (dwRet
== WAIT_OBJECT_0
)
3019 bret
= GetOverlappedResult((HANDLE
)dst
, &ov
, &bytes_sent
, FALSE
);
3020 ok((bret
&& bytes_sent
== buflen
) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
3021 "Got %d instead of %d (%d - %d)\n", bytes_sent
, buflen
, bret
, GetLastError());
3025 if (src
!= INVALID_SOCKET
)
3027 if (dst
!= INVALID_SOCKET
)
3029 if (hThread
!= NULL
)
3030 CloseHandle(hThread
);
3032 CloseHandle(ov
.hEvent
);
3033 HeapFree(GetProcessHeap(), 0, buffer
);
3036 typedef struct async_message
3040 struct async_message
*next
;
3043 static struct async_message
*messages_received
;
3045 #define WM_SOCKET (WM_USER+100)
3046 static LRESULT CALLBACK
ws2_test_WndProc(HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
3048 struct async_message
*message
;
3053 message
= HeapAlloc(GetProcessHeap(), 0, sizeof(*message
));
3054 message
->socket
= (SOCKET
) wparam
;
3055 message
->lparam
= lparam
;
3056 message
->next
= NULL
;
3058 if (messages_received
)
3060 struct async_message
*last
= messages_received
;
3061 while (last
->next
) last
= last
->next
;
3062 last
->next
= message
;
3065 messages_received
= message
;
3069 return DefWindowProc(hwnd
, msg
, wparam
, lparam
);
3072 static void get_event_details(int event
, int *bit
, char *name
)
3077 if (bit
) *bit
= FD_ACCEPT_BIT
;
3078 if (name
) strcpy(name
, "FD_ACCEPT");
3081 if (bit
) *bit
= FD_CONNECT_BIT
;
3082 if (name
) strcpy(name
, "FD_CONNECT");
3085 if (bit
) *bit
= FD_READ_BIT
;
3086 if (name
) strcpy(name
, "FD_READ");
3089 if (bit
) *bit
= FD_OOB_BIT
;
3090 if (name
) strcpy(name
, "FD_OOB");
3093 if (bit
) *bit
= FD_WRITE_BIT
;
3094 if (name
) strcpy(name
, "FD_WRITE");
3097 if (bit
) *bit
= FD_CLOSE_BIT
;
3098 if (name
) strcpy(name
, "FD_CLOSE");
3102 if (name
) sprintf(name
, "bad%x", event
);
3106 static const char *dbgstr_event_seq(const LPARAM
*seq
)
3108 static char message
[1024];
3116 get_event_details(WSAGETSELECTEVENT(*seq
), NULL
, name
);
3117 len
+= sprintf(message
+ len
, "%s(%d) ", name
, WSAGETSELECTERROR(*seq
));
3121 strcpy( message
+ len
, "]" );
3125 static char *dbgstr_event_seq_result(SOCKET s
, WSANETWORKEVENTS
*netEvents
)
3127 static char message
[1024];
3128 struct async_message
*curr
= messages_received
;
3129 int index
, error
, bit
= 0;
3139 if (bit
>= FD_MAX_EVENTS
) break;
3140 if ( !(netEvents
->lNetworkEvents
& (1 << bit
)) )
3145 get_event_details(1 << bit
, &index
, name
);
3146 error
= netEvents
->iErrorCode
[index
];
3152 if (curr
->socket
!= s
)
3157 get_event_details(WSAGETSELECTEVENT(curr
->lparam
), NULL
, name
);
3158 error
= WSAGETSELECTERROR(curr
->lparam
);
3162 len
+= sprintf(message
+ len
, "%s(%d) ", name
, error
);
3165 strcpy( message
+ len
, "]" );
3169 static void flush_events(SOCKET s
, HANDLE hEvent
)
3171 WSANETWORKEVENTS netEvents
;
3172 struct async_message
*prev
= NULL
, *curr
= messages_received
;
3176 if (hEvent
!= INVALID_HANDLE_VALUE
)
3178 dwRet
= WaitForSingleObject(hEvent
, 100);
3179 if (dwRet
== WAIT_OBJECT_0
)
3181 ret
= WSAEnumNetworkEvents(s
, hEvent
, &netEvents
);
3183 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
3190 if (curr
->socket
== s
)
3192 if (prev
) prev
->next
= curr
->next
;
3193 else messages_received
= curr
->next
;
3195 HeapFree(GetProcessHeap(), 0, curr
);
3197 if (prev
) curr
= prev
->next
;
3198 else curr
= messages_received
;
3209 static int match_event_sequence(SOCKET s
, WSANETWORKEVENTS
*netEvents
, const LPARAM
*seq
)
3211 int event
, index
, error
, events
;
3212 struct async_message
*curr
;
3216 events
= netEvents
->lNetworkEvents
;
3219 event
= WSAGETSELECTEVENT(*seq
);
3220 error
= WSAGETSELECTERROR(*seq
);
3221 get_event_details(event
, &index
, NULL
);
3223 if (!(events
& event
) && index
!= -1)
3225 if (events
& event
&& index
!= -1)
3227 if (netEvents
->iErrorCode
[index
] != error
)
3238 curr
= messages_received
;
3241 if (curr
->socket
== s
)
3243 if (!*seq
) return 0;
3244 if (*seq
!= curr
->lparam
) return 0;
3255 /* checks for a sequence of events, (order only checked if window is used) */
3256 static void ok_event_sequence(SOCKET s
, HANDLE hEvent
, const LPARAM
*seq
, const LPARAM
**broken_seqs
, int completelyBroken
)
3259 WSANETWORKEVENTS events
, *netEvents
= NULL
;
3263 if (hEvent
!= INVALID_HANDLE_VALUE
)
3265 netEvents
= &events
;
3267 dwRet
= WaitForSingleObject(hEvent
, 200);
3268 if (dwRet
== WAIT_OBJECT_0
)
3270 ret
= WSAEnumNetworkEvents(s
, hEvent
, netEvents
);
3273 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
3278 memset(netEvents
, 0, sizeof(*netEvents
));
3283 /* Run the message loop a little */
3284 while (PeekMessageA( &msg
, 0, 0, 0, PM_REMOVE
))
3286 DispatchMessageA(&msg
);
3290 if (match_event_sequence(s
, netEvents
, seq
))
3292 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq
));
3293 flush_events(s
, hEvent
);
3299 for (; *broken_seqs
; broken_seqs
++)
3301 if (match_event_sequence(s
, netEvents
, *broken_seqs
))
3303 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s
, netEvents
), dbgstr_event_seq(seq
));
3304 flush_events(s
, hEvent
);
3310 winetest_ok(broken(completelyBroken
), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq
),
3311 dbgstr_event_seq_result(s
, netEvents
));
3312 flush_events(s
, hEvent
);
3315 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
3317 static void test_events(int useMessages
)
3319 SOCKET server
= INVALID_SOCKET
;
3320 SOCKET src
= INVALID_SOCKET
, src2
= INVALID_SOCKET
;
3321 SOCKET dst
= INVALID_SOCKET
, dst2
= INVALID_SOCKET
;
3322 struct sockaddr_in addr
;
3323 HANDLE hThread
= NULL
;
3324 HANDLE hEvent
= INVALID_HANDLE_VALUE
, hEvent2
= INVALID_HANDLE_VALUE
;
3325 WNDCLASSEX wndclass
;
3327 char *buffer
= NULL
;
3328 int bufferSize
= 1024*1024;
3332 DWORD bytesReturned
;
3338 static char szClassName
[] = "wstestclass";
3339 const LPARAM
*broken_seq
[3];
3340 static const LPARAM empty_seq
[] = { 0 };
3341 static const LPARAM close_seq
[] = { WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
3342 static const LPARAM write_seq
[] = { WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
3343 static const LPARAM read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
3344 static const LPARAM oob_seq
[] = { WSAMAKESELECTREPLY(FD_OOB
, 0), 0 };
3345 static const LPARAM connect_seq
[] = { WSAMAKESELECTREPLY(FD_CONNECT
, 0),
3346 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
3347 static const LPARAM read_read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
3348 WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
3349 static const LPARAM read_write_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
3350 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
3351 static const LPARAM read_close_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
3352 WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
3354 memset(&ov
, 0, sizeof(ov
));
3355 memset(&ov2
, 0, sizeof(ov2
));
3357 /* don't use socketpair, we want connection event */
3358 src
= socket(AF_INET
, SOCK_STREAM
, 0);
3359 if (src
== INVALID_SOCKET
)
3361 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3365 src2
= socket(AF_INET
, SOCK_STREAM
, 0);
3366 if (src2
== INVALID_SOCKET
)
3368 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3373 if (getsockopt(src
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&bret
, &len
) == SOCKET_ERROR
)
3375 ok(0, "failed to get oobinline status, %d\n", GetLastError());
3378 ok(bret
== FALSE
, "OOB not inline\n");
3382 trace("Event test using messages\n");
3384 wndclass
.cbSize
= sizeof(wndclass
);
3385 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
3386 wndclass
.lpfnWndProc
= ws2_test_WndProc
;
3387 wndclass
.cbClsExtra
= 0;
3388 wndclass
.cbWndExtra
= 0;
3389 wndclass
.hInstance
= GetModuleHandle(NULL
);
3390 wndclass
.hIcon
= LoadIcon(NULL
, IDI_APPLICATION
);
3391 wndclass
.hIconSm
= LoadIcon(NULL
, IDI_APPLICATION
);
3392 wndclass
.hCursor
= LoadCursor(NULL
, IDC_ARROW
);
3393 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
3394 wndclass
.lpszClassName
= szClassName
;
3395 wndclass
.lpszMenuName
= NULL
;
3396 RegisterClassEx(&wndclass
);
3398 hWnd
= CreateWindow(szClassName
, "WS2Test", WS_OVERLAPPEDWINDOW
, 0, 0, 500, 500, NULL
, NULL
, GetModuleHandle(NULL
), NULL
);
3401 ok(0, "failed to create window: %d\n", GetLastError());
3405 ret
= WSAAsyncSelect(src
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
3408 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
3412 ret
= WSAAsyncSelect(src2
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
3415 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
3421 trace("Event test using events\n");
3423 hEvent
= WSACreateEvent();
3424 if (hEvent
== INVALID_HANDLE_VALUE
)
3426 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
3430 hEvent2
= WSACreateEvent();
3431 if (hEvent2
== INVALID_HANDLE_VALUE
)
3433 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
3437 ret
= WSAEventSelect(src
, hEvent
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
3440 ok(0, "WSAEventSelect failed, error %d\n", ret
);
3444 ret
= WSAEventSelect(src2
, hEvent2
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
3447 ok(0, "WSAEventSelect failed, error %d\n", ret
);
3452 server
= socket(AF_INET
, SOCK_STREAM
, 0);
3453 if (server
== INVALID_SOCKET
)
3455 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3459 memset(&addr
, 0, sizeof(addr
));
3460 addr
.sin_family
= AF_INET
;
3461 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3462 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
3465 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3470 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
3473 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3477 ret
= listen(server
, 2);
3480 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3484 ret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
3485 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
3487 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3491 ret
= connect(src2
, (struct sockaddr
*)&addr
, sizeof(addr
));
3492 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
3494 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3499 dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
3500 if (dst
== INVALID_SOCKET
)
3502 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3507 dst2
= accept(server
, (struct sockaddr
*)&addr
, &len
);
3508 if (dst2
== INVALID_SOCKET
)
3510 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3514 closesocket(server
);
3515 server
= INVALID_SOCKET
;
3517 /* On Windows it seems when a non-blocking socket sends to a
3518 blocking socket on the same host, the send() is BLOCKING,
3519 so make both sockets non-blocking. src is already non-blocking
3520 from the async select */
3522 if (set_blocking(dst
, FALSE
))
3524 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
3528 buffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, bufferSize
);
3531 ok(0, "could not allocate memory for test\n");
3535 ov
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
3536 if (ov
.hEvent
== NULL
)
3538 ok(0, "could not create event object, errno = %d\n", GetLastError());
3542 ov2
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
3543 if (ov2
.hEvent
== NULL
)
3545 ok(0, "could not create event object, errno = %d\n", GetLastError());
3549 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
3550 ok_event_seq(src
, hEvent
, connect_seq
, NULL
, 1);
3551 ok_event_seq(src2
, hEvent2
, connect_seq
, NULL
, 1);
3552 /* broken on all windows - FD_CONNECT error is garbage */
3554 /* Test simple send/recv */
3555 ret
= send(dst
, buffer
, 100, 0);
3556 ok(ret
== 100, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3557 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
3559 ret
= recv(src
, buffer
, 50, 0);
3560 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
3561 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
3563 ret
= recv(src
, buffer
, 50, 0);
3564 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
3565 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
3567 /* fun fact - events are reenabled even on failure, but only for messages */
3568 ret
= send(dst
, "1", 1, 0);
3569 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3570 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
3572 ret
= recv(src
, buffer
, -1, 0);
3573 ok(ret
== SOCKET_ERROR
&& (GetLastError() == WSAEFAULT
|| GetLastError() == WSAENOBUFS
),
3574 "Failed to recv buffer %d err %d\n", ret
, GetLastError());
3577 broken_seq
[0] = empty_seq
; /* win9x */
3578 broken_seq
[1] = NULL
;
3579 todo_wine
ok_event_seq(src
, hEvent
, read_seq
, broken_seq
, 0);
3582 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
3584 ret
= recv(src
, buffer
, 1, 0);
3585 ok(ret
== 1, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
3586 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
3588 /* Interaction with overlapped */
3589 bufs
.len
= sizeof(char);
3591 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
3592 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
3593 "WSARecv failed - %d error %d\n", ret
, GetLastError());
3595 bufs
.len
= sizeof(char);
3596 bufs
.buf
= buffer
+1;
3597 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov2
, NULL
);
3598 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
3599 "WSARecv failed - %d error %d\n", ret
, GetLastError());
3601 ret
= send(dst
, "12", 2, 0);
3602 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3603 broken_seq
[0] = read_read_seq
; /* win9x */
3604 broken_seq
[1] = NULL
;
3605 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
3607 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
3608 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
3609 if (dwRet
== WAIT_OBJECT_0
)
3611 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
3612 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
3613 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
3614 ok(buffer
[0] == '1', "Got %c instead of 1\n", buffer
[0]);
3617 dwRet
= WaitForSingleObject(ov2
.hEvent
, 100);
3618 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
3619 if (dwRet
== WAIT_OBJECT_0
)
3621 bret
= GetOverlappedResult((HANDLE
)src
, &ov2
, &bytesReturned
, FALSE
);
3622 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
3623 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
3624 ok(buffer
[1] == '2', "Got %c instead of 2\n", buffer
[1]);
3627 ret
= send(dst
, "1", 1, 0);
3628 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3629 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
3631 ret
= recv(src
, buffer
, 1, 0);
3632 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
3633 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
3635 /* Notifications are delivered as soon as possible, blocked only on
3636 * async requests on the same type */
3637 bufs
.len
= sizeof(char);
3639 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
3640 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
3641 "WSARecv failed - %d error %d\n", ret
, GetLastError());
3644 ret
= send(dst
, "1", 1, MSG_OOB
);
3645 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3646 ok_event_seq(src
, hEvent
, oob_seq
, NULL
, 0);
3649 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
3650 ok(dwRet
== WAIT_TIMEOUT
, "OOB message activated read?: %d - %d\n", dwRet
, GetLastError());
3652 ret
= send(dst
, "2", 1, 0);
3653 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3654 broken_seq
[0] = read_seq
; /* win98 */
3655 broken_seq
[1] = NULL
;
3656 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
3658 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
3659 ok(dwRet
== WAIT_OBJECT_0
|| broken(dwRet
== WAIT_TIMEOUT
),
3660 "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
3661 if (dwRet
== WAIT_OBJECT_0
)
3663 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
3664 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
3665 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
3666 ok(buffer
[0] == '2', "Got %c instead of 2\n", buffer
[0]);
3668 else if (dwRet
== WAIT_TIMEOUT
)
3670 /* this happens on win98. We get an FD_READ later on the next test */
3671 CancelIo((HANDLE
) src
);
3675 ret
= recv(src
, buffer
, 1, MSG_OOB
);
3676 todo_wine
ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
3677 /* We get OOB notification, but no data on wine */
3678 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
3681 /* Flood the send queue */
3682 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
3683 if (hThread
== NULL
)
3685 ok(0, "CreateThread failed, error %d\n", GetLastError());
3689 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
3690 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
3692 /* Now if we send a ton of data and the 'server' does not drain it fast
3693 * enough (set drain_pause to be sure), the socket send buffer will only
3694 * take some of it, and we will get a short write. This will trigger
3695 * another FD_WRITE event as soon as data is sent and more space becomes
3696 * available, but not any earlier. */
3700 ret
= send(src
, buffer
, bufferSize
, 0);
3701 } while (ret
== bufferSize
);
3703 if (ret
>= 0 || WSAGetLastError() == WSAEWOULDBLOCK
)
3705 Sleep(400); /* win9x */
3706 broken_seq
[0] = read_write_seq
;
3707 broken_seq
[1] = NULL
;
3708 ok_event_seq(src
, hEvent
, write_seq
, broken_seq
, 0);
3712 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
3715 /* Test how FD_CLOSE is handled */
3716 ret
= send(dst
, "12", 2, 0);
3717 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3719 /* Wait a little and let the send complete */
3722 dst
= INVALID_SOCKET
;
3725 /* We can never implement this in wine, best we can hope for is
3726 sending FD_CLOSE after the reads complete */
3727 broken_seq
[0] = read_seq
; /* win9x */
3728 broken_seq
[1] = NULL
;
3729 todo_wine
ok_event_seq(src
, hEvent
, read_close_seq
, broken_seq
, 0);
3731 ret
= recv(src
, buffer
, 1, 0);
3732 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
3733 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
3735 ret
= recv(src
, buffer
, 1, 0);
3736 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
3737 /* want it? it's here, but you can't have it */
3738 broken_seq
[0] = close_seq
; /* win9x */
3739 broken_seq
[1] = NULL
;
3740 todo_wine
ok_event_seq(src
, hEvent
, empty_seq
, /* wine sends FD_CLOSE here */
3743 /* Test how FD_CLOSE is handled */
3744 ret
= send(dst2
, "12", 2, 0);
3745 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
3748 shutdown(dst2
, SD_SEND
);
3751 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
3752 regressions, don't mark them as todo_wine, and mark windows as broken */
3753 broken_seq
[0] = read_close_seq
;
3754 broken_seq
[1] = close_seq
;
3755 broken_seq
[2] = NULL
;
3756 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
3758 ret
= recv(src2
, buffer
, 1, 0);
3759 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
3760 broken_seq
[0] = close_seq
; /* win98 */
3761 broken_seq
[1] = NULL
;
3762 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
3764 ret
= recv(src2
, buffer
, 1, 0);
3765 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
3766 broken_seq
[0] = empty_seq
;
3767 broken_seq
[1] = NULL
;
3768 ok_event_seq(src2
, hEvent2
, close_seq
, broken_seq
, 0);
3770 ret
= send(src2
, "1", 1, 0);
3771 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
3772 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
3774 ret
= send(src2
, "1", 1, 0);
3775 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
3776 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
3779 if (src
!= INVALID_SOCKET
)
3781 flush_events(src
, hEvent
);
3784 if (src2
!= INVALID_SOCKET
)
3786 flush_events(src2
, hEvent2
);
3789 HeapFree(GetProcessHeap(), 0, buffer
);
3790 if (server
!= INVALID_SOCKET
)
3791 closesocket(server
);
3792 if (dst
!= INVALID_SOCKET
)
3794 if (dst2
!= INVALID_SOCKET
)
3796 if (hThread
!= NULL
)
3797 CloseHandle(hThread
);
3799 DestroyWindow(hWnd
);
3801 CloseHandle(hEvent
);
3802 if (hEvent2
!= NULL
)
3803 CloseHandle(hEvent2
);
3804 if (ov
.hEvent
!= NULL
)
3805 CloseHandle(ov
.hEvent
);
3806 if (ov2
.hEvent
!= NULL
)
3807 CloseHandle(ov2
.hEvent
);
3810 static void test_ipv6only(void)
3812 SOCKET v4
= INVALID_SOCKET
,
3813 v6
= INVALID_SOCKET
;
3814 struct sockaddr_in sin4
;
3815 struct sockaddr_in6 sin6
;
3818 memset(&sin4
, 0, sizeof(sin4
));
3819 sin4
.sin_family
= AF_INET
;
3820 sin4
.sin_port
= htons(SERVERPORT
);
3822 memset(&sin6
, 0, sizeof(sin6
));
3823 sin6
.sin6_family
= AF_INET6
;
3824 sin6
.sin6_port
= htons(SERVERPORT
);
3826 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
3827 if (v6
== INVALID_SOCKET
) {
3828 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3829 WSAGetLastError(), WSAEAFNOSUPPORT
);
3832 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
3834 skip("Could not bind IPv6 address (LastError: %d).\n",
3839 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3840 if (v4
== INVALID_SOCKET
) {
3841 skip("Could not create IPv4 socket (LastError: %d).\n",
3845 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
3846 ok(!ret
, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
3847 WSAGetLastError(), WSAEADDRINUSE
);
3850 if (v4
!= INVALID_SOCKET
)
3852 if (v6
!= INVALID_SOCKET
)
3856 static void test_WSASendTo(void)
3859 struct sockaddr_in addr
;
3860 char buf
[12] = "hello world";
3864 addr
.sin_family
= AF_INET
;
3865 addr
.sin_port
= htons(139);
3866 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3867 data_buf
.len
= sizeof(buf
);
3870 if( (s
= socket(AF_INET
, SOCK_DGRAM
, 0)) == INVALID_SOCKET
) {
3871 ok(0, "socket() failed error: %d\n", WSAGetLastError());
3875 WSASetLastError(12345);
3876 if(WSASendTo(s
, &data_buf
, 1, &bytesSent
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
)) {
3877 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
3880 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
3881 "a successful call to WSASendTo()\n");
3884 static void test_WSARecv(void)
3890 DWORD bytesReturned
;
3897 tcp_socketpair(&src
, &dest
);
3898 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
3900 skip("failed to create sockets\n");
3904 bufs
.len
= sizeof(buf
);
3908 memset(&ov
, 0, sizeof(ov
));
3909 ov
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
3910 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
3916 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
3917 ok(!iret
, "Failed to set linger %d\n", GetLastError());
3919 iret
= WSARecv(dest
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
3920 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
3923 src
= INVALID_SOCKET
;
3925 dwret
= WaitForSingleObject(ov
.hEvent
, 1000);
3926 ok(dwret
== WAIT_OBJECT_0
, "Waiting for disconnect event failed with %d + errno %d\n", dwret
, GetLastError());
3928 bret
= GetOverlappedResult((HANDLE
)dest
, &ov
, &bytesReturned
, FALSE
);
3929 todo_wine
ok(!bret
&& (GetLastError() == ERROR_NETNAME_DELETED
|| broken(GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */),
3930 "Did not get disconnect event: %d, error %d\n", bret
, GetLastError());
3931 ok(bytesReturned
== 0, "Bytes received is %d\n", bytesReturned
);
3934 if (dest
!= INVALID_SOCKET
)
3936 if (src
!= INVALID_SOCKET
)
3939 WSACloseEvent(ov
.hEvent
);
3942 static void test_GetAddrInfoW(void)
3944 static const WCHAR port
[] = {'8','0',0};
3945 static const WCHAR empty
[] = {0};
3946 static const WCHAR localhost
[] = {'l','o','c','a','l','h','o','s','t',0};
3949 ADDRINFOW
*result
, hint
;
3951 if (!pGetAddrInfoW
|| !pFreeAddrInfoW
)
3953 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
3957 memset(&hint
, 0, sizeof(ADDRINFOW
));
3959 ret
= pGetAddrInfoW(NULL
, NULL
, NULL
, &result
);
3960 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
3963 ret
= pGetAddrInfoW(empty
, NULL
, NULL
, &result
);
3966 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3967 ok(result
!= NULL
, "GetAddrInfoW failed\n");
3969 pFreeAddrInfoW(result
);
3971 ret
= pGetAddrInfoW(localhost
, NULL
, NULL
, &result
);
3972 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3973 pFreeAddrInfoW(result
);
3975 ret
= pGetAddrInfoW(localhost
, port
, NULL
, &result
);
3976 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3977 pFreeAddrInfoW(result
);
3979 ret
= pGetAddrInfoW(localhost
, port
, &hint
, &result
);
3980 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3981 pFreeAddrInfoW(result
);
3984 static void test_ConnectEx(void)
3986 SOCKET listener
= INVALID_SOCKET
;
3987 SOCKET acceptor
= INVALID_SOCKET
;
3988 SOCKET connector
= INVALID_SOCKET
;
3989 struct sockaddr_in address
, conaddress
;
3991 OVERLAPPED overlapped
;
3992 LPFN_CONNECTEX pConnectEx
;
3993 GUID connectExGuid
= WSAID_CONNECTEX
;
3994 DWORD bytesReturned
;
4000 memset(&overlapped
, 0, sizeof(overlapped
));
4002 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
4003 if (listener
== INVALID_SOCKET
) {
4004 skip("could not create listener socket, error %d\n", WSAGetLastError());
4008 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4009 if (connector
== INVALID_SOCKET
) {
4010 skip("could not create connector socket, error %d\n", WSAGetLastError());
4014 memset(&address
, 0, sizeof(address
));
4015 address
.sin_family
= AF_INET
;
4016 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4017 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
4019 skip("failed to bind, error %d\n", WSAGetLastError());
4023 addrlen
= sizeof(address
);
4024 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
4026 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
4030 if (set_blocking(listener
, TRUE
)) {
4031 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
4035 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectExGuid
, sizeof(connectExGuid
),
4036 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
4038 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret
, WSAGetLastError());
4042 bret
= pConnectEx(INVALID_SOCKET
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
4043 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "ConnectEx on invalid socket "
4044 "returned %d + errno %d\n", bret
, WSAGetLastError());
4046 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
4047 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "ConnectEx on a unbound socket "
4048 "returned %d + errno %d\n", bret
, WSAGetLastError());
4049 if (bret
== TRUE
|| WSAGetLastError() != WSAEINVAL
)
4051 acceptor
= accept(listener
, NULL
, NULL
);
4052 if (acceptor
!= INVALID_SOCKET
) {
4053 closesocket(acceptor
);
4054 acceptor
= INVALID_SOCKET
;
4057 closesocket(connector
);
4058 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4059 if (connector
== INVALID_SOCKET
) {
4060 skip("could not create connector socket, error %d\n", WSAGetLastError());
4065 /* ConnectEx needs a bound socket */
4066 memset(&conaddress
, 0, sizeof(conaddress
));
4067 conaddress
.sin_family
= AF_INET
;
4068 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4069 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
4071 skip("failed to bind, error %d\n", WSAGetLastError());
4075 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, NULL
);
4076 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "ConnectEx on a NULL overlapped "
4077 "returned %d + errno %d\n", bret
, WSAGetLastError());
4079 overlapped
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
4080 if (overlapped
.hEvent
== NULL
) {
4081 skip("could not create event object, errno = %d\n", GetLastError());
4085 iret
= listen(listener
, 1);
4087 skip("listening failed, errno = %d\n", WSAGetLastError());
4091 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
4092 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
4093 "returned %d + errno %d\n", bret
, WSAGetLastError());
4094 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
4095 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
4097 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
4098 ok(bret
, "Connecting failed, error %d\n", GetLastError());
4099 ok(bytesReturned
== 0, "Bytes sent is %d\n", bytesReturned
);
4101 closesocket(connector
);
4102 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4103 if (connector
== INVALID_SOCKET
) {
4104 skip("could not create connector socket, error %d\n", WSAGetLastError());
4107 /* ConnectEx needs a bound socket */
4108 memset(&conaddress
, 0, sizeof(conaddress
));
4109 conaddress
.sin_family
= AF_INET
;
4110 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4111 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
4113 skip("failed to bind, error %d\n", WSAGetLastError());
4117 acceptor
= accept(listener
, NULL
, NULL
);
4118 if (acceptor
!= INVALID_SOCKET
) {
4119 closesocket(acceptor
);
4125 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, buffer
, 3, &bytesReturned
, &overlapped
);
4126 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
4127 "returned %d + errno %d\n", bret
, WSAGetLastError());
4128 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
4129 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
4131 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
4132 ok(bret
, "Connecting failed, error %d\n", GetLastError());
4133 ok(bytesReturned
== 3, "Bytes sent is %d\n", bytesReturned
);
4135 acceptor
= accept(listener
, NULL
, NULL
);
4136 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket error %d\n", WSAGetLastError());
4138 bytesReturned
= recv(acceptor
, buffer
, 3, 0);
4140 ok(bytesReturned
== 3, "Didn't get all sent data, got only %d\n", bytesReturned
);
4141 ok(buffer
[0] == '1' && buffer
[1] == '2' && buffer
[2] == '3',
4142 "Failed to get the right data, expected '123', got '%s'\n", buffer
);
4144 closesocket(connector
);
4145 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4146 if (connector
== INVALID_SOCKET
) {
4147 skip("could not create connector socket, error %d\n", WSAGetLastError());
4150 /* ConnectEx needs a bound socket */
4151 memset(&conaddress
, 0, sizeof(conaddress
));
4152 conaddress
.sin_family
= AF_INET
;
4153 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4154 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
4156 skip("failed to bind, error %d\n", WSAGetLastError());
4160 if (acceptor
!= INVALID_SOCKET
) {
4161 closesocket(acceptor
);
4162 acceptor
= INVALID_SOCKET
;
4165 /* Connect with error */
4166 closesocket(listener
);
4167 listener
= INVALID_SOCKET
;
4169 address
.sin_port
= htons(1);
4171 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
4172 ok(bret
== FALSE
&& GetLastError(), "ConnectEx to bad destination failed: "
4173 "returned %d + errno %d\n", bret
, GetLastError());
4175 if (GetLastError() == ERROR_IO_PENDING
)
4177 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
4178 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
4180 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
4181 ok(bret
== FALSE
&& GetLastError() == ERROR_CONNECTION_REFUSED
,
4182 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
4185 ok(GetLastError() == WSAECONNREFUSED
,
4186 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
4190 if (overlapped
.hEvent
)
4191 WSACloseEvent(overlapped
.hEvent
);
4192 if (listener
!= INVALID_SOCKET
)
4193 closesocket(listener
);
4194 if (acceptor
!= INVALID_SOCKET
)
4195 closesocket(acceptor
);
4196 if (connector
!= INVALID_SOCKET
)
4197 closesocket(connector
);
4200 static void test_AcceptEx(void)
4202 SOCKET listener
= INVALID_SOCKET
;
4203 SOCKET acceptor
= INVALID_SOCKET
;
4204 SOCKET connector
= INVALID_SOCKET
;
4205 SOCKET connector2
= INVALID_SOCKET
;
4206 struct sockaddr_in bindAddress
;
4208 GUID acceptExGuid
= WSAID_ACCEPTEX
;
4209 LPFN_ACCEPTEX pAcceptEx
= NULL
;
4210 fd_set fds_accept
, fds_send
;
4211 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
4213 DWORD bytesReturned
;
4215 OVERLAPPED overlapped
;
4220 memset(&overlapped
, 0, sizeof(overlapped
));
4222 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
4223 if (listener
== INVALID_SOCKET
) {
4224 skip("could not create listener socket, error %d\n", WSAGetLastError());
4228 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4229 if (acceptor
== INVALID_SOCKET
) {
4230 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4234 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4235 if (connector
== INVALID_SOCKET
) {
4236 skip("could not create connector socket, error %d\n", WSAGetLastError());
4240 memset(&bindAddress
, 0, sizeof(bindAddress
));
4241 bindAddress
.sin_family
= AF_INET
;
4242 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4243 iret
= bind(listener
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4245 skip("failed to bind, error %d\n", WSAGetLastError());
4249 socklen
= sizeof(bindAddress
);
4250 iret
= getsockname(listener
, (struct sockaddr
*)&bindAddress
, &socklen
);
4252 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
4256 if (set_blocking(listener
, FALSE
)) {
4257 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
4261 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
4262 &pAcceptEx
, sizeof(pAcceptEx
), &bytesReturned
, NULL
, NULL
);
4264 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret
, WSAGetLastError());
4268 bret
= pAcceptEx(INVALID_SOCKET
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4269 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4270 &bytesReturned
, &overlapped
);
4271 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid listening socket "
4272 "returned %d + errno %d\n", bret
, WSAGetLastError());
4274 bret
= pAcceptEx(listener
, INVALID_SOCKET
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4275 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4276 &bytesReturned
, &overlapped
);
4277 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on invalid accepting socket "
4278 "returned %d + errno %d\n", bret
, WSAGetLastError());
4280 bret
= pAcceptEx(listener
, acceptor
, NULL
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4281 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4282 &bytesReturned
, &overlapped
);
4284 (WSAGetLastError() == WSAEINVAL
||
4285 broken(WSAGetLastError() == WSAEFAULT
)), /* NT4 */
4286 "AcceptEx on NULL buffer returned %d + errno %d\n", bret
, WSAGetLastError());
4288 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
4289 &bytesReturned
, &overlapped
);
4290 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on too small local address size "
4291 "returned %d + errno %d\n", bret
, WSAGetLastError());
4293 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16, 0,
4294 &bytesReturned
, &overlapped
);
4295 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on too small remote address size "
4296 "returned %d + errno %d\n", bret
, WSAGetLastError());
4298 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
4299 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4300 &bytesReturned
, NULL
);
4301 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
4302 "returned %d + errno %d\n", bret
, WSAGetLastError());
4304 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4305 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4306 &bytesReturned
, &overlapped
);
4307 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on a non-listening socket "
4308 "returned %d + errno %d\n", bret
, WSAGetLastError());
4310 iret
= listen(listener
, 5);
4312 skip("listening failed, errno = %d\n", WSAGetLastError());
4316 overlapped
.hEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
4317 if (overlapped
.hEvent
== NULL
) {
4318 skip("could not create event object, errno = %d\n", GetLastError());
4322 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
4323 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4324 &bytesReturned
, &overlapped
);
4325 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4327 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
4328 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4329 &bytesReturned
, &overlapped
);
4330 todo_wine
ok((bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
) || broken(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) /* NT4 */,
4331 "AcceptEx on already pending socket returned %d + errno %d\n", bret
, WSAGetLastError());
4332 if (bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) {
4333 /* We need to cancel this call, otherwise things fail */
4334 bret
= CancelIo((HANDLE
) listener
);
4335 ok(bret
, "Failed to cancel failed test. Bailing...\n");
4337 WaitForSingleObject(overlapped
.hEvent
, 0);
4339 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
4340 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4341 &bytesReturned
, &overlapped
);
4342 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4345 iret
= connect(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4346 todo_wine
ok((iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
) || broken(!iret
) /* NT4 */,
4347 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret
, WSAGetLastError());
4348 if (!iret
|| (iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
)) {
4349 /* We need to cancel this call, otherwise things fail */
4350 closesocket(acceptor
);
4351 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4352 if (acceptor
== INVALID_SOCKET
) {
4353 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4357 bret
= CancelIo((HANDLE
) listener
);
4358 ok(bret
, "Failed to cancel failed test. Bailing...\n");
4361 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
4362 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4363 &bytesReturned
, &overlapped
);
4364 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4367 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4368 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
4370 dwret
= WaitForSingleObject(overlapped
.hEvent
, INFINITE
);
4371 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
4373 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
4374 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
4375 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
4377 closesocket(connector
);
4378 connector
= INVALID_SOCKET
;
4379 closesocket(acceptor
);
4381 /* Test short reads */
4383 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4384 if (acceptor
== INVALID_SOCKET
) {
4385 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4388 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4389 if (connector
== INVALID_SOCKET
) {
4390 skip("could not create connector socket, error %d\n", WSAGetLastError());
4393 bret
= pAcceptEx(listener
, acceptor
, buffer
, 2,
4394 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4395 &bytesReturned
, &overlapped
);
4396 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4398 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4399 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
4401 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
4402 ok(dwret
== WAIT_TIMEOUT
, "Waiting for accept event timeout failed with %d + errno %d\n", dwret
, GetLastError());
4404 iret
= send(connector
, buffer
, 1, 0);
4405 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
4407 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
4408 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
4410 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
4411 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
4412 ok(bytesReturned
== 1, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
4414 closesocket(connector
);
4415 connector
= INVALID_SOCKET
;
4416 closesocket(acceptor
);
4418 /* Test CF_DEFER & AcceptEx interaction */
4420 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4421 if (acceptor
== INVALID_SOCKET
) {
4422 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4425 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4426 if (connector
== INVALID_SOCKET
) {
4427 skip("could not create connector socket, error %d\n", WSAGetLastError());
4430 connector2
= socket(AF_INET
, SOCK_STREAM
, 0);
4431 if (connector
== INVALID_SOCKET
) {
4432 skip("could not create connector socket, error %d\n", WSAGetLastError());
4436 if (set_blocking(connector
, FALSE
)) {
4437 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
4441 if (set_blocking(connector2
, FALSE
)) {
4442 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
4446 /* Connect socket #1 */
4447 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4448 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
4450 FD_ZERO ( &fds_accept
);
4451 FD_ZERO ( &fds_send
);
4453 FD_SET ( listener
, &fds_accept
);
4454 FD_SET ( connector
, &fds_send
);
4460 for (i
= 0; i
< 4000; ++i
)
4462 fd_set fds_openaccept
= fds_accept
, fds_opensend
= fds_send
;
4464 wsa_ok ( ( select ( 0, &fds_openaccept
, &fds_opensend
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
4465 "acceptex test(%d): could not select on socket, errno %d\n" );
4467 /* check for incoming requests */
4468 if ( FD_ISSET ( listener
, &fds_openaccept
) ) {
4471 SOCKET tmp
= WSAAccept(listener
, NULL
, NULL
, (LPCONDITIONPROC
) AlwaysDeferConditionFunc
, 0);
4472 ok(tmp
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
4473 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
4474 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4475 &bytesReturned
, &overlapped
);
4476 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4478 else if (got
== 2) {
4479 /* this should be socket #2 */
4480 SOCKET tmp
= accept(listener
, NULL
, NULL
);
4481 ok(tmp
!= INVALID_SOCKET
, "accept failed %d\n", WSAGetLastError());
4485 ok(FALSE
, "Got more than 2 connections?\n");
4488 if ( conn1
&& FD_ISSET ( connector2
, &fds_opensend
) ) {
4489 /* Send data on second socket, and stop */
4490 send(connector2
, "2", 1, 0);
4491 FD_CLR ( connector2
, &fds_send
);
4495 if ( FD_ISSET ( connector
, &fds_opensend
) ) {
4496 /* Once #1 is connected, allow #2 to connect */
4499 send(connector
, "1", 1, 0);
4500 FD_CLR ( connector
, &fds_send
);
4502 iret
= connect(connector2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4503 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
4504 FD_SET ( connector2
, &fds_send
);
4508 ok (got
== 2 || broken(got
== 1) /* NT4 */,
4509 "Did not get both connections, got %d\n", got
);
4511 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
4512 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
4514 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
4515 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
4516 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
4518 set_blocking(acceptor
, TRUE
);
4519 iret
= recv( acceptor
, buffer
, 2, 0);
4520 ok(iret
== 1, "Failed to get data, %d, errno: %d\n", iret
, WSAGetLastError());
4522 ok(buffer
[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer
[0]);
4524 closesocket(connector
);
4525 connector
= INVALID_SOCKET
;
4526 closesocket(acceptor
);
4528 /* clean up in case of failures */
4529 while ((acceptor
= accept(listener
, NULL
, NULL
)) != INVALID_SOCKET
)
4530 closesocket(acceptor
);
4532 /* Disconnect during receive? */
4534 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4535 if (acceptor
== INVALID_SOCKET
) {
4536 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4539 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4540 if (connector
== INVALID_SOCKET
) {
4541 skip("could not create connector socket, error %d\n", WSAGetLastError());
4544 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4545 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4546 &bytesReturned
, &overlapped
);
4547 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4549 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
4550 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
4552 closesocket(connector
);
4553 connector
= INVALID_SOCKET
;
4555 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
4556 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
4558 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
4559 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
4560 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
4562 closesocket(acceptor
);
4564 /* Test closing with pending requests */
4566 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4567 if (acceptor
== INVALID_SOCKET
) {
4568 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4571 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4572 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4573 &bytesReturned
, &overlapped
);
4574 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4576 closesocket(acceptor
);
4578 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
4579 todo_wine
ok(dwret
== WAIT_OBJECT_0
|| broken(dwret
== WAIT_TIMEOUT
) /* NT4/2000 */,
4580 "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
4582 if (dwret
!= WAIT_TIMEOUT
) {
4583 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
4584 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
4587 bret
= CancelIo((HANDLE
) listener
);
4588 ok(bret
, "Failed to cancel failed test. Bailing...\n");
4590 WaitForSingleObject(overlapped
.hEvent
, 0);
4593 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4594 if (acceptor
== INVALID_SOCKET
) {
4595 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4598 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4599 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4600 &bytesReturned
, &overlapped
);
4601 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4603 CancelIo((HANDLE
) acceptor
);
4605 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
4606 ok(dwret
== WAIT_TIMEOUT
, "Waiting for timeout failed with %d + errno %d\n", dwret
, GetLastError());
4608 closesocket(acceptor
);
4610 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
4611 if (acceptor
== INVALID_SOCKET
) {
4612 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
4615 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
4616 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
4617 &bytesReturned
, &overlapped
);
4618 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
4620 closesocket(listener
);
4621 listener
= INVALID_SOCKET
;
4623 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
4624 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
4626 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
4627 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
4630 if (overlapped
.hEvent
)
4631 WSACloseEvent(overlapped
.hEvent
);
4632 if (listener
!= INVALID_SOCKET
)
4633 closesocket(listener
);
4634 if (acceptor
!= INVALID_SOCKET
)
4635 closesocket(acceptor
);
4636 if (connector
!= INVALID_SOCKET
)
4637 closesocket(connector
);
4638 if (connector2
!= INVALID_SOCKET
)
4639 closesocket(connector2
);
4642 static void test_getpeername(void)
4645 struct sockaddr_in sa
, sa_out
;
4647 const char buf
[] = "hello world";
4650 /* Test the parameter validation order. */
4651 ret
= getpeername(INVALID_SOCKET
, NULL
, NULL
);
4652 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
4653 ok(WSAGetLastError() == WSAENOTSOCK
,
4654 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
4656 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
4657 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
4658 if (sock
== INVALID_SOCKET
)
4660 skip("Socket creation failed with %d\n", WSAGetLastError());
4664 ret
= getpeername(sock
, NULL
, NULL
);
4665 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
4666 ok(WSAGetLastError() == WSAENOTCONN
||
4667 broken(WSAGetLastError() == WSAEFAULT
), /* Win9x and WinMe */
4668 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
4670 memset(&sa
, 0, sizeof(sa
));
4671 sa
.sin_family
= AF_INET
;
4672 sa
.sin_port
= htons(139);
4673 sa
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4675 /* sendto does not change a socket's connection state. */
4676 ret
= sendto(sock
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
4677 ok(ret
!= SOCKET_ERROR
,
4678 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
4680 ret
= getpeername(sock
, NULL
, NULL
);
4681 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
4682 ok(WSAGetLastError() == WSAENOTCONN
||
4683 broken(WSAGetLastError() == WSAEFAULT
), /* Win9x and WinMe */
4684 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
4686 ret
= connect(sock
, (struct sockaddr
*)&sa
, sizeof(sa
));
4688 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
4690 ret
= getpeername(sock
, NULL
, NULL
);
4691 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
4692 ok(WSAGetLastError() == WSAEFAULT
,
4693 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
4695 /* Test crashes on Wine. */
4698 ret
= getpeername(sock
, (void*)0xdeadbeef, (void*)0xcafebabe);
4699 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
4700 ok(WSAGetLastError() == WSAEFAULT
,
4701 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
4705 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, &sa_len
);
4706 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
4707 ok(WSAGetLastError() == WSAEFAULT
,
4708 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
4710 sa_len
= sizeof(sa_out
);
4711 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, &sa_len
);
4712 ok(ret
== 0, "Expected getpeername to return 0, got %d\n", ret
);
4713 ok(!memcmp(&sa
, &sa_out
, sizeof(sa
)),
4714 "Expected the returned structure to be identical to the connect structure\n");
4719 static void test_sioRoutingInterfaceQuery(void)
4723 SOCKADDR_IN sin
= { 0 }, sout
= { 0 };
4724 DWORD bytesReturned
;
4726 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
4727 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
4728 if (sock
== INVALID_SOCKET
)
4730 skip("Socket creation failed with %d\n", WSAGetLastError());
4733 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, NULL
, 0, NULL
, 0, NULL
,
4735 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
4736 "expected WSAEFAULT, got %d\n", WSAGetLastError());
4737 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
4738 NULL
, 0, NULL
, NULL
, NULL
);
4739 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
4740 "expected WSAEFAULT, got %d\n", WSAGetLastError());
4741 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
4742 NULL
, 0, &bytesReturned
, NULL
, NULL
);
4743 ok(ret
== SOCKET_ERROR
&&
4744 (WSAGetLastError() == WSAEFAULT
/* Win98 */ ||
4745 WSAGetLastError() == WSAEINVAL
/* NT4 */||
4746 WSAGetLastError() == WSAEAFNOSUPPORT
),
4747 "expected WSAEFAULT or WSAEINVAL or WSAEAFNOSUPPORT, got %d\n",
4749 sin
.sin_family
= AF_INET
;
4750 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
4751 NULL
, 0, &bytesReturned
, NULL
, NULL
);
4752 ok(ret
== SOCKET_ERROR
&&
4753 (WSAGetLastError() == WSAEFAULT
/* Win98 */ ||
4754 WSAGetLastError() == WSAEINVAL
),
4755 "expected WSAEFAULT or WSAEINVAL, got %d\n", WSAGetLastError());
4756 sin
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
4757 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
4758 NULL
, 0, &bytesReturned
, NULL
, NULL
);
4759 ok(ret
== SOCKET_ERROR
&&
4760 (WSAGetLastError() == WSAEINVAL
/* NT4 */ ||
4761 WSAGetLastError() == WSAEFAULT
),
4762 "expected WSAEINVAL or WSAEFAULT, got %d\n", WSAGetLastError());
4763 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
4764 &sout
, sizeof(sout
), &bytesReturned
, NULL
, NULL
);
4765 ok(!ret
|| broken(WSAGetLastError() == WSAEINVAL
/* NT4 */),
4766 "WSAIoctl failed: %d\n", WSAGetLastError());
4769 ok(sout
.sin_family
== AF_INET
, "expected AF_INET, got %d\n",
4771 /* We expect the source address to be INADDR_LOOPBACK as well, but
4772 * there's no guarantee that a route to the loopback address exists,
4773 * so rather than introduce spurious test failures we do not test the
4780 static void test_synchronous_WSAIoctl(void)
4782 HANDLE previous_port
, io_port
;
4783 WSAOVERLAPPED overlapped
, *olp
;
4791 previous_port
= CreateIoCompletionPort( INVALID_HANDLE_VALUE
, NULL
, 0, 0 );
4792 ok( previous_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
4794 socket
= WSASocketW( AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
4795 ok( socket
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError() );
4797 io_port
= CreateIoCompletionPort( (HANDLE
)socket
, previous_port
, 0, 0 );
4798 ok( io_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
4801 memset( &overlapped
, 0, sizeof(overlapped
) );
4802 res
= WSAIoctl( socket
, FIONBIO
, &on
, sizeof(on
), NULL
, 0, &num_bytes
, &overlapped
, NULL
);
4803 ok( !res
, "WSAIoctl failed %d\n", WSAGetLastError() );
4805 ret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 10000 );
4806 ok( ret
, "failed to get completion status %u\n", GetLastError() );
4808 CloseHandle( io_port
);
4809 closesocket( socket
);
4810 CloseHandle( previous_port
);
4813 /**************** Main program ***************/
4819 /* Leave these tests at the beginning. They depend on WSAStartup not having been
4820 * called, which is done by Init() below. */
4821 test_WithoutWSAStartup();
4822 test_WithWSAStartup();
4826 test_set_getsockopt();
4827 test_so_reuseaddr();
4829 test_extendedSocketOptions();
4831 for (i
= 0; i
< sizeof(tests
)/sizeof(tests
[0]); i
++)
4833 trace ( " **** STARTING TEST %d ****\n", i
);
4834 do_test ( &tests
[i
] );
4835 trace ( " **** TEST %d COMPLETE ****\n", i
);
4840 test_getservbyname();
4843 test_WSAAddressToStringA();
4844 test_WSAAddressToStringW();
4846 test_WSAStringToAddressA();
4847 test_WSAStringToAddressW();
4854 test_addr_to_print();
4857 test_gethostbyname_hack();
4866 test_GetAddrInfoW();
4871 test_sioRoutingInterfaceQuery();
4873 /* this is a io heavy test, do it at the end so the kernel doesn't start dropping packets */
4875 test_synchronous_WSAIoctl();