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
34 #include "wine/test.h"
36 #define MAX_CLIENTS 4 /* Max number of clients */
37 #define FIRST_CHAR 'A' /* First character in transferred pattern */
38 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
39 #define BIND_TRIES 6 /* Number of bind() attempts */
40 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
41 after server initialization, if something hangs */
43 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
45 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
46 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
48 #define SERVERIP "127.0.0.1" /* IP to bind to */
49 #define SERVERPORT 9374 /* Port number to bind to */
51 #define wsa_ok(op, cond, msg) \
55 if ( !(cond tmp) ) err = WSAGetLastError(); \
56 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
59 #define make_keepalive(k, enable, time, interval) \
61 k.keepalivetime = time; \
62 k.keepaliveinterval = interval;
64 /* Function pointers */
65 static void (WINAPI
*pfreeaddrinfo
)(struct addrinfo
*);
66 static int (WINAPI
*pgetaddrinfo
)(LPCSTR
,LPCSTR
,const struct addrinfo
*,struct addrinfo
**);
67 static void (WINAPI
*pFreeAddrInfoW
)(PADDRINFOW
);
68 static int (WINAPI
*pGetAddrInfoW
)(LPCWSTR
,LPCWSTR
,const ADDRINFOW
*,PADDRINFOW
*);
69 static PCSTR (WINAPI
*pInetNtop
)(INT
,LPVOID
,LPSTR
,ULONG
);
70 static int (WINAPI
*pWSALookupServiceBeginW
)(LPWSAQUERYSETW
,DWORD
,LPHANDLE
);
71 static int (WINAPI
*pWSALookupServiceEnd
)(HANDLE
);
72 static int (WINAPI
*pWSALookupServiceNextW
)(HANDLE
,DWORD
,LPDWORD
,LPWSAQUERYSETW
);
74 /**************** Structs and typedefs ***************/
76 typedef struct thread_info
82 /* Information in the server about open client connections */
83 typedef struct sock_info
86 struct sockaddr_in addr
;
87 struct sockaddr_in peer
;
93 /* Test parameters for both server & client */
94 typedef struct test_params
98 const char *inet_addr
;
105 /* server-specific test parameters */
106 typedef struct server_params
108 test_params
*general
;
113 /* client-specific test parameters */
114 typedef struct client_params
116 test_params
*general
;
121 /* This type combines all information for setting up a test scenario */
122 typedef struct test_setup
126 server_params srv_params
;
128 client_params clt_params
;
131 /* Thread local storage for server */
132 typedef struct server_memory
135 struct sockaddr_in addr
;
136 sock_info sock
[MAX_CLIENTS
];
139 /* Thread local storage for client */
140 typedef struct client_memory
143 struct sockaddr_in addr
;
148 /* SelectReadThread thread parameters */
149 typedef struct select_thread_params
153 } select_thread_params
;
155 /* Tests used in both getaddrinfo and GetAddrInfoW */
156 static const struct addr_hint_tests
158 int family
, socktype
, protocol
;
161 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_TCP
, 0 },
162 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_UDP
, 0 },
163 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_TCP
, 0 },
164 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_UDP
, 0 },
165 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, 0 },
166 {AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, 0 },
167 {AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, 0 },
168 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, 0 },
169 {AF_UNSPEC
, 0, IPPROTO_TCP
, 0 },
170 {AF_UNSPEC
, 0, IPPROTO_UDP
, 0 },
171 {AF_UNSPEC
, SOCK_STREAM
, 0, 0 },
172 {AF_UNSPEC
, SOCK_DGRAM
, 0, 0 },
173 {AF_INET
, 0, IPPROTO_TCP
, 0 },
174 {AF_INET
, 0, IPPROTO_UDP
, 0 },
175 {AF_INET
, SOCK_STREAM
, 0, 0 },
176 {AF_INET
, SOCK_DGRAM
, 0, 0 },
177 {AF_UNSPEC
, 999, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
178 {AF_UNSPEC
, 999, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
179 {AF_INET
, 999, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
180 {AF_INET
, 999, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
181 {AF_UNSPEC
, SOCK_STREAM
, 999, 0 },
182 {AF_UNSPEC
, SOCK_STREAM
, 999, 0 },
183 {AF_INET
, SOCK_DGRAM
, 999, 0 },
184 {AF_INET
, SOCK_DGRAM
, 999, 0 },
187 /**************** Static variables ***************/
189 static DWORD tls
; /* Thread local storage index */
190 static HANDLE thread
[1+MAX_CLIENTS
];
191 static DWORD thread_id
[1+MAX_CLIENTS
];
192 static HANDLE server_ready
;
193 static HANDLE client_ready
[MAX_CLIENTS
];
194 static int client_id
;
196 /**************** General utility functions ***************/
198 static int tcp_socketpair(SOCKET
*src
, SOCKET
*dst
)
200 SOCKET server
= INVALID_SOCKET
;
201 struct sockaddr_in addr
;
205 *src
= INVALID_SOCKET
;
206 *dst
= INVALID_SOCKET
;
208 *src
= socket(AF_INET
, SOCK_STREAM
, 0);
209 if (*src
== INVALID_SOCKET
)
212 server
= socket(AF_INET
, SOCK_STREAM
, 0);
213 if (server
== INVALID_SOCKET
)
216 memset(&addr
, 0, sizeof(addr
));
217 addr
.sin_family
= AF_INET
;
218 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
219 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
224 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
228 ret
= listen(server
, 1);
232 ret
= connect(*src
, (struct sockaddr
*)&addr
, sizeof(addr
));
237 *dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
240 if (server
!= INVALID_SOCKET
)
242 if (*src
!= INVALID_SOCKET
&& *dst
!= INVALID_SOCKET
)
249 static void set_so_opentype ( BOOL overlapped
)
251 int optval
= !overlapped
, newval
, len
= sizeof (int);
253 ok ( setsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
254 (LPVOID
) &optval
, sizeof (optval
) ) == 0,
255 "setting SO_OPENTYPE failed\n" );
256 ok ( getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
257 (LPVOID
) &newval
, &len
) == 0,
258 "getting SO_OPENTYPE failed\n" );
259 ok ( optval
== newval
, "failed to set SO_OPENTYPE\n" );
262 static int set_blocking ( SOCKET s
, BOOL blocking
)
264 u_long val
= !blocking
;
265 return ioctlsocket ( s
, FIONBIO
, &val
);
268 static void fill_buffer ( char *buf
, int chunk_size
, int n_chunks
)
271 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
272 memset ( p
, c
, chunk_size
);
275 static int test_buffer ( char *buf
, int chunk_size
, int n_chunks
)
279 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
281 for ( i
= 0; i
< chunk_size
; i
++ )
282 if ( p
[i
] != c
) return i
;
288 * This routine is called when a client / server does not expect any more data,
289 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
291 static void read_zero_bytes ( SOCKET s
)
295 while ( ( tmp
= recv ( s
, buf
, 256, 0 ) ) > 0 )
297 ok ( n
<= 0, "garbage data received: %d bytes\n", n
);
300 static int do_oob_send ( SOCKET s
, char *buf
, int buflen
, int sendlen
)
302 char* last
= buf
+ buflen
, *p
;
304 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
305 n
= send ( s
, p
, min ( sendlen
, last
- p
), MSG_OOB
);
306 wsa_ok ( n
, 0 <=, "do_oob_send (%x): error %d\n" );
310 static int do_synchronous_send ( SOCKET s
, char *buf
, int buflen
, int sendlen
)
312 char* last
= buf
+ buflen
, *p
;
314 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
315 n
= send ( s
, p
, min ( sendlen
, last
- p
), 0 );
316 wsa_ok ( n
, 0 <=, "do_synchronous_send (%x): error %d\n" );
320 static int do_synchronous_recv ( SOCKET s
, char *buf
, int buflen
, int recvlen
)
322 char* last
= buf
+ buflen
, *p
;
324 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
325 n
= recv ( s
, p
, min ( recvlen
, last
- p
), 0 );
326 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
330 static int do_synchronous_recvfrom ( SOCKET s
, char *buf
, int buflen
,int flags
,struct sockaddr
*from
, int *fromlen
, int recvlen
)
332 char* last
= buf
+ buflen
, *p
;
334 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
335 n
= recvfrom ( s
, p
, min ( recvlen
, last
- p
), 0, from
, fromlen
);
336 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
341 * Call this routine right after thread startup.
342 * SO_OPENTYPE must by 0, regardless what the server did.
344 static void check_so_opentype (void)
348 getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
, (LPVOID
) &tmp
, &len
);
349 ok ( tmp
== 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp
);
352 /**************** Server utility functions ***************/
355 * Even if we have closed our server socket cleanly,
356 * the OS may mark the address "in use" for some time -
357 * this happens with native Linux apps, too.
359 static void do_bind ( SOCKET s
, struct sockaddr
* addr
, int addrlen
)
361 int err
, wsaerr
= 0, n_try
= BIND_TRIES
;
363 while ( ( err
= bind ( s
, addr
, addrlen
) ) != 0 &&
364 ( wsaerr
= WSAGetLastError () ) == WSAEADDRINUSE
&&
367 trace ( "address in use, waiting ...\n" );
368 Sleep ( 1000 * BIND_SLEEP
);
370 ok ( err
== 0, "failed to bind: %d\n", wsaerr
);
373 static void server_start ( server_params
*par
)
376 test_params
*gen
= par
->general
;
377 server_memory
*mem
= LocalAlloc ( LPTR
, sizeof ( server_memory
) );
379 TlsSetValue ( tls
, mem
);
380 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
381 NULL
, 0, par
->sock_flags
);
382 ok ( mem
->s
!= INVALID_SOCKET
, "Server: WSASocket failed\n" );
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 for (i
= 0; i
< MAX_CLIENTS
; i
++)
390 mem
->sock
[i
].s
= INVALID_SOCKET
;
391 mem
->sock
[i
].buf
= LocalAlloc ( LPTR
, gen
->n_chunks
* gen
->chunk_size
);
392 mem
->sock
[i
].n_recvd
= 0;
393 mem
->sock
[i
].n_sent
= 0;
396 if ( gen
->sock_type
== SOCK_STREAM
)
397 do_bind ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof (mem
->addr
) );
400 static void server_stop (void)
403 server_memory
*mem
= TlsGetValue ( tls
);
405 for (i
= 0; i
< MAX_CLIENTS
; i
++ )
407 LocalFree ( mem
->sock
[i
].buf
);
408 if ( mem
->sock
[i
].s
!= INVALID_SOCKET
)
409 closesocket ( mem
->sock
[i
].s
);
411 ok ( closesocket ( mem
->s
) == 0, "closesocket failed\n" );
413 ExitThread ( GetCurrentThreadId () );
416 /**************** Client utilitiy functions ***************/
418 static void client_start ( client_params
*par
)
420 test_params
*gen
= par
->general
;
421 client_memory
*mem
= LocalAlloc (LPTR
, sizeof (client_memory
));
423 TlsSetValue ( tls
, mem
);
425 WaitForSingleObject ( server_ready
, INFINITE
);
427 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
428 NULL
, 0, par
->sock_flags
);
430 mem
->addr
.sin_family
= AF_INET
;
431 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
432 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
434 ok ( mem
->s
!= INVALID_SOCKET
, "Client: WSASocket failed\n" );
436 mem
->send_buf
= LocalAlloc ( LPTR
, 2 * gen
->n_chunks
* gen
->chunk_size
);
437 mem
->recv_buf
= mem
->send_buf
+ gen
->n_chunks
* gen
->chunk_size
;
438 fill_buffer ( mem
->send_buf
, gen
->chunk_size
, gen
->n_chunks
);
440 SetEvent ( client_ready
[client_id
] );
441 /* Wait for the other clients to come up */
442 WaitForMultipleObjects ( min ( gen
->n_clients
, MAX_CLIENTS
), client_ready
, TRUE
, INFINITE
);
445 static void client_stop (void)
447 client_memory
*mem
= TlsGetValue ( tls
);
448 wsa_ok ( closesocket ( mem
->s
), 0 ==, "closesocket error (%x): %d\n" );
449 LocalFree ( mem
->send_buf
);
454 /**************** Servers ***************/
457 * simple_server: A very basic server doing synchronous IO.
459 static VOID WINAPI
simple_server ( server_params
*par
)
461 test_params
*gen
= par
->general
;
463 int pos
, n_recvd
, n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
464 id
= GetCurrentThreadId();
466 trace ( "simple_server (%x) starting\n", id
);
468 set_so_opentype ( FALSE
); /* non-overlapped */
469 server_start ( par
);
470 mem
= TlsGetValue ( tls
);
472 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
473 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "simple_server (%x): listen failed: %d\n");
475 trace ( "simple_server (%x) ready\n", id
);
476 SetEvent ( server_ready
); /* notify clients */
478 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
480 trace ( "simple_server (%x): waiting for client\n", id
);
482 /* accept a single connection */
483 tmp
= sizeof ( mem
->sock
[0].peer
);
484 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
485 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "simple_server (%x): accept failed: %d\n" );
487 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
488 "simple_server (%x): strange peer address\n", id
);
490 /* Receive data & check it */
491 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
492 ok ( n_recvd
== n_expected
,
493 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
494 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
495 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
498 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
499 ok ( n_sent
== n_expected
,
500 "simple_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
503 read_zero_bytes ( mem
->sock
[0].s
);
504 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "simple_server (%x): closesocket error: %d\n" );
505 mem
->sock
[0].s
= INVALID_SOCKET
;
508 trace ( "simple_server (%x) exiting\n", id
);
513 * oob_server: A very basic server receiving out-of-band data.
515 static VOID WINAPI
oob_server ( server_params
*par
)
517 test_params
*gen
= par
->general
;
520 int pos
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
,
521 id
= GetCurrentThreadId();
523 trace ( "oob_server (%x) starting\n", id
);
525 set_so_opentype ( FALSE
); /* non-overlapped */
526 server_start ( par
);
527 mem
= TlsGetValue ( tls
);
529 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
530 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "oob_server (%x): listen failed: %d\n");
532 trace ( "oob_server (%x) ready\n", id
);
533 SetEvent ( server_ready
); /* notify clients */
535 trace ( "oob_server (%x): waiting for client\n", id
);
537 /* accept a single connection */
538 tmp
= sizeof ( mem
->sock
[0].peer
);
539 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
540 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "oob_server (%x): accept failed: %d\n" );
542 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
543 "oob_server (%x): strange peer address\n", id
);
545 /* check atmark state */
546 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
547 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
549 /* Receive normal data and check atmark state */
550 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
551 ok ( n_recvd
== n_expected
,
552 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
553 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
554 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
556 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
557 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
559 /* Receive a part of the out-of-band data and check atmark state */
560 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, 8, par
->buflen
);
562 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, 8 );
565 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
566 todo_wine
ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %i\n", id
, atmark
);
568 /* Receive the rest of the out-of-band data and check atmark state */
569 do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
571 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
572 todo_wine
ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %i\n", id
, atmark
);
575 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "oob_server (%x): closesocket error: %d\n" );
576 mem
->sock
[0].s
= INVALID_SOCKET
;
578 trace ( "oob_server (%x) exiting\n", id
);
583 * select_server: A non-blocking server.
585 static VOID WINAPI
select_server ( server_params
*par
)
587 test_params
*gen
= par
->general
;
589 int n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
590 id
= GetCurrentThreadId(), n_connections
= 0, n_sent
, n_recvd
,
591 n_set
, delta
, n_ready
;
592 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
593 fd_set fds_recv
, fds_send
, fds_openrecv
, fds_opensend
;
595 trace ( "select_server (%x) starting\n", id
);
597 set_so_opentype ( FALSE
); /* non-overlapped */
598 server_start ( par
);
599 mem
= TlsGetValue ( tls
);
601 wsa_ok ( set_blocking ( mem
->s
, FALSE
), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
602 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "select_server (%x): listen failed: %d\n");
604 trace ( "select_server (%x) ready\n", id
);
605 SetEvent ( server_ready
); /* notify clients */
607 FD_ZERO ( &fds_openrecv
);
608 FD_ZERO ( &fds_recv
);
609 FD_ZERO ( &fds_send
);
610 FD_ZERO ( &fds_opensend
);
612 FD_SET ( mem
->s
, &fds_openrecv
);
616 fds_recv
= fds_openrecv
;
617 fds_send
= fds_opensend
;
621 wsa_ok ( ( n_ready
= select ( 0, &fds_recv
, &fds_send
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
622 "select_server (%x): select() failed: %d\n" );
624 /* check for incoming requests */
625 if ( FD_ISSET ( mem
->s
, &fds_recv
) ) {
628 trace ( "select_server (%x): accepting client connection\n", id
);
630 /* accept a single connection */
631 tmp
= sizeof ( mem
->sock
[n_connections
].peer
);
632 mem
->sock
[n_connections
].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[n_connections
].peer
, &tmp
);
633 wsa_ok ( mem
->sock
[n_connections
].s
, INVALID_SOCKET
!=, "select_server (%x): accept() failed: %d\n" );
635 ok ( mem
->sock
[n_connections
].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
636 "select_server (%x): strange peer address\n", id
);
638 /* add to list of open connections */
639 FD_SET ( mem
->sock
[n_connections
].s
, &fds_openrecv
);
640 FD_SET ( mem
->sock
[n_connections
].s
, &fds_opensend
);
645 /* handle open requests */
647 for ( i
= 0; i
< n_connections
; i
++ )
649 if ( FD_ISSET( mem
->sock
[i
].s
, &fds_recv
) ) {
652 if ( mem
->sock
[i
].n_recvd
< n_expected
) {
653 /* Receive data & check it */
654 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 );
655 ok ( n_recvd
!= SOCKET_ERROR
, "select_server (%x): error in recv(): %d\n", id
, WSAGetLastError() );
656 mem
->sock
[i
].n_recvd
+= n_recvd
;
658 if ( mem
->sock
[i
].n_recvd
== n_expected
) {
659 int pos
= test_buffer ( mem
->sock
[i
].buf
, gen
->chunk_size
, gen
->n_chunks
);
660 ok ( pos
== -1, "select_server (%x): test pattern error: %d\n", id
, pos
);
661 FD_CLR ( mem
->sock
[i
].s
, &fds_openrecv
);
664 ok ( mem
->sock
[i
].n_recvd
<= n_expected
, "select_server (%x): received too many bytes: %d\n", id
, mem
->sock
[i
].n_recvd
);
668 /* only echo back what we've received */
669 delta
= mem
->sock
[i
].n_recvd
- mem
->sock
[i
].n_sent
;
671 if ( FD_ISSET ( mem
->sock
[i
].s
, &fds_send
) ) {
674 if ( ( delta
> 0 ) && ( mem
->sock
[i
].n_sent
< n_expected
) ) {
676 n_sent
= send ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_sent
, min ( delta
, par
->buflen
), 0 );
677 ok ( n_sent
!= SOCKET_ERROR
, "select_server (%x): error in send(): %d\n", id
, WSAGetLastError() );
678 mem
->sock
[i
].n_sent
+= n_sent
;
680 if ( mem
->sock
[i
].n_sent
== n_expected
) {
681 FD_CLR ( mem
->sock
[i
].s
, &fds_opensend
);
684 ok ( mem
->sock
[i
].n_sent
<= n_expected
, "select_server (%x): sent too many bytes: %d\n", id
, mem
->sock
[i
].n_sent
);
689 /* check that select returned the correct number of ready sockets */
690 ok ( ( n_set
== n_ready
), "select_server (%x): select() returns wrong number of ready sockets\n", id
);
692 /* check if all clients are done */
693 if ( ( fds_opensend
.fd_count
== 0 )
694 && ( fds_openrecv
.fd_count
== 1 ) /* initial socket that accepts clients */
695 && ( n_connections
== min ( gen
->n_clients
, MAX_CLIENTS
) ) ) {
700 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
703 read_zero_bytes ( mem
->sock
[i
].s
);
704 wsa_ok ( closesocket ( mem
->sock
[i
].s
), 0 ==, "select_server (%x): closesocket error: %d\n" );
705 mem
->sock
[i
].s
= INVALID_SOCKET
;
708 trace ( "select_server (%x) exiting\n", id
);
712 /**************** Clients ***************/
715 * simple_client: A very basic client doing synchronous IO.
717 static VOID WINAPI
simple_client ( client_params
*par
)
719 test_params
*gen
= par
->general
;
721 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
723 id
= GetCurrentThreadId();
724 trace ( "simple_client (%x): starting\n", id
);
725 /* wait here because we want to call set_so_opentype before creating a socket */
726 WaitForSingleObject ( server_ready
, INFINITE
);
727 trace ( "simple_client (%x): server ready\n", id
);
729 check_so_opentype ();
730 set_so_opentype ( FALSE
); /* non-overlapped */
731 client_start ( par
);
732 mem
= TlsGetValue ( tls
);
735 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
736 0 ==, "simple_client (%x): connect error: %d\n" );
737 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
738 "simple_client (%x): failed to set blocking mode\n", id
);
739 trace ( "simple_client (%x) connected\n", id
);
741 /* send data to server */
742 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
);
743 ok ( n_sent
== n_expected
,
744 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
746 /* shutdown send direction */
747 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
749 /* Receive data echoed back & check it */
750 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, par
->buflen
);
751 ok ( n_recvd
== n_expected
,
752 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
755 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
756 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
759 read_zero_bytes ( mem
->s
);
760 trace ( "simple_client (%x) exiting\n", id
);
765 * oob_client: A very basic client sending out-of-band data.
767 static VOID WINAPI
oob_client ( client_params
*par
)
769 test_params
*gen
= par
->general
;
771 int n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
773 id
= GetCurrentThreadId();
774 trace ( "oob_client (%x): starting\n", id
);
775 /* wait here because we want to call set_so_opentype before creating a socket */
776 WaitForSingleObject ( server_ready
, INFINITE
);
777 trace ( "oob_client (%x): server ready\n", id
);
779 check_so_opentype ();
780 set_so_opentype ( FALSE
); /* non-overlapped */
781 client_start ( par
);
782 mem
= TlsGetValue ( tls
);
785 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
786 0 ==, "oob_client (%x): connect error: %d\n" );
787 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
788 "oob_client (%x): failed to set blocking mode\n", id
);
789 trace ( "oob_client (%x) connected\n", id
);
791 /* send data to server */
792 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
);
793 ok ( n_sent
== n_expected
,
794 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
796 /* send out-of-band data to server */
797 n_sent
= do_oob_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
);
798 ok ( n_sent
== n_expected
,
799 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
801 /* shutdown send direction */
802 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
805 read_zero_bytes ( mem
->s
);
806 trace ( "oob_client (%x) exiting\n", id
);
811 * simple_mixed_client: mixing send and recvfrom
813 static VOID WINAPI
simple_mixed_client ( client_params
*par
)
815 test_params
*gen
= par
->general
;
817 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
818 int fromLen
= sizeof(mem
->addr
);
819 struct sockaddr test
;
821 id
= GetCurrentThreadId();
822 trace ( "simple_client (%x): starting\n", id
);
823 /* wait here because we want to call set_so_opentype before creating a socket */
824 WaitForSingleObject ( server_ready
, INFINITE
);
825 trace ( "simple_client (%x): server ready\n", id
);
827 check_so_opentype ();
828 set_so_opentype ( FALSE
); /* non-overlapped */
829 client_start ( par
);
830 mem
= TlsGetValue ( tls
);
833 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
834 0 ==, "simple_client (%x): connect error: %d\n" );
835 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
836 "simple_client (%x): failed to set blocking mode\n", id
);
837 trace ( "simple_client (%x) connected\n", id
);
839 /* send data to server */
840 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
);
841 ok ( n_sent
== n_expected
,
842 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
844 /* shutdown send direction */
845 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
847 /* this shouldn't change, since lpFrom, is not updated on
848 connection oriented sockets - exposed by bug 11640
850 ((struct sockaddr_in
*)&test
)->sin_addr
.s_addr
= inet_addr("0.0.0.0");
852 /* Receive data echoed back & check it */
853 n_recvd
= do_synchronous_recvfrom ( mem
->s
,
857 (struct sockaddr
*)&test
,
860 ok ( n_recvd
== n_expected
,
861 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
863 /* check that lpFrom was not updated */
866 inet_ntoa(((struct sockaddr_in
*)&test
)->sin_addr
),
867 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
870 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
871 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
874 read_zero_bytes ( mem
->s
);
875 trace ( "simple_client (%x) exiting\n", id
);
880 * event_client: An event-driven client
882 static void WINAPI
event_client ( client_params
*par
)
884 test_params
*gen
= par
->general
;
886 int id
= GetCurrentThreadId(), n_expected
= gen
->n_chunks
* gen
->chunk_size
,
889 WSANETWORKEVENTS wsa_events
;
890 char *send_last
, *recv_last
, *send_p
, *recv_p
;
891 LONG mask
= FD_READ
| FD_WRITE
| FD_CLOSE
;
893 trace ( "event_client (%x): starting\n", id
);
894 client_start ( par
);
895 trace ( "event_client (%x): server ready\n", id
);
897 mem
= TlsGetValue ( tls
);
899 /* Prepare event notification for connect, makes socket nonblocking */
900 event
= WSACreateEvent ();
901 WSAEventSelect ( mem
->s
, event
, FD_CONNECT
);
902 tmp
= connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) );
904 err
= WSAGetLastError ();
905 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): connect error: %d\n", id
, err
);
906 tmp
= WaitForSingleObject ( event
, INFINITE
);
907 ok ( tmp
== WAIT_OBJECT_0
, "event_client (%x): wait for connect event failed: %d\n", id
, tmp
);
908 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
909 ok ( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
910 err
= wsa_events
.iErrorCode
[ FD_CONNECT_BIT
];
911 ok ( err
== 0, "event_client (%x): connect error: %d\n", id
, err
);
915 trace ( "event_client (%x) connected\n", id
);
917 WSAEventSelect ( mem
->s
, event
, mask
);
919 recv_p
= mem
->recv_buf
;
920 recv_last
= mem
->recv_buf
+ n_expected
;
921 send_p
= mem
->send_buf
;
922 send_last
= mem
->send_buf
+ n_expected
;
926 err
= WaitForSingleObject ( event
, INFINITE
);
927 ok ( err
== WAIT_OBJECT_0
, "event_client (%x): wait failed\n", id
);
929 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
930 ok( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
932 if ( wsa_events
.lNetworkEvents
& FD_WRITE
)
934 err
= wsa_events
.iErrorCode
[ FD_WRITE_BIT
];
935 ok ( err
== 0, "event_client (%x): FD_WRITE error code: %d\n", id
, err
);
940 n
= send ( mem
->s
, send_p
, min ( send_last
- send_p
, par
->buflen
), 0 );
943 err
= WSAGetLastError ();
944 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): send error: %d\n", id
, err
);
949 while ( n
>= 0 && send_p
< send_last
);
951 if ( send_p
== send_last
)
953 trace ( "event_client (%x): all data sent - shutdown\n", id
);
954 shutdown ( mem
->s
, SD_SEND
);
956 WSAEventSelect ( mem
->s
, event
, mask
);
959 if ( wsa_events
.lNetworkEvents
& FD_READ
)
961 err
= wsa_events
.iErrorCode
[ FD_READ_BIT
];
962 ok ( err
== 0, "event_client (%x): FD_READ error code: %d\n", id
, err
);
963 if ( err
!= 0 ) break;
965 /* First read must succeed */
966 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
967 wsa_ok ( n
, 0 <=, "event_client (%x): recv error: %d\n" );
971 if ( recv_p
== recv_last
)
974 trace ( "event_client (%x): all data received\n", id
);
975 WSAEventSelect ( mem
->s
, event
, mask
);
978 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
979 if ( n
< 0 && ( err
= WSAGetLastError()) != WSAEWOULDBLOCK
)
980 ok ( 0, "event_client (%x): read error: %d\n", id
, err
);
984 if ( wsa_events
.lNetworkEvents
& FD_CLOSE
)
986 trace ( "event_client (%x): close event\n", id
);
987 err
= wsa_events
.iErrorCode
[ FD_CLOSE_BIT
];
988 ok ( err
== 0, "event_client (%x): FD_CLOSE error code: %d\n", id
, err
);
993 n
= send_p
- mem
->send_buf
;
994 ok ( send_p
== send_last
,
995 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n
, n_expected
);
996 n
= recv_p
- mem
->recv_buf
;
997 ok ( recv_p
== recv_last
,
998 "simple_client (%x): received less data than expected: %d of %d\n", id
, n
, n_expected
);
999 n
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
1000 ok ( n
== -1, "event_client (%x): test pattern error: %d\n", id
, n
);
1003 WSACloseEvent ( event
);
1004 trace ( "event_client (%x) exiting\n", id
);
1008 /* Tests for WSAStartup */
1009 static void test_WithoutWSAStartup(void)
1013 WSASetLastError(0xdeadbeef);
1014 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
, "WSASocketA should have failed\n");
1015 err
= WSAGetLastError();
1016 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
1018 WSASetLastError(0xdeadbeef);
1019 ok(gethostbyname("localhost") == NULL
, "gethostbyname() succeeded unexpectedly\n");
1020 err
= WSAGetLastError();
1021 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
1024 static void test_WithWSAStartup(void)
1027 WORD version
= MAKEWORD( 2, 2 );
1031 res
= WSAStartup( version
, &data
);
1032 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1034 ptr
= gethostbyname("localhost");
1035 ok(ptr
!= NULL
, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1040 /**************** Main program utility functions ***************/
1042 static void Init (void)
1044 WORD ver
= MAKEWORD (2, 2);
1046 HMODULE hws2_32
= GetModuleHandleA("ws2_32.dll");
1048 pfreeaddrinfo
= (void *)GetProcAddress(hws2_32
, "freeaddrinfo");
1049 pgetaddrinfo
= (void *)GetProcAddress(hws2_32
, "getaddrinfo");
1050 pFreeAddrInfoW
= (void *)GetProcAddress(hws2_32
, "FreeAddrInfoW");
1051 pGetAddrInfoW
= (void *)GetProcAddress(hws2_32
, "GetAddrInfoW");
1052 pInetNtop
= (void *)GetProcAddress(hws2_32
, "inet_ntop");
1053 pWSALookupServiceBeginW
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceBeginW");
1054 pWSALookupServiceEnd
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceEnd");
1055 pWSALookupServiceNextW
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceNextW");
1057 ok ( WSAStartup ( ver
, &data
) == 0, "WSAStartup failed\n" );
1061 static void Exit (void)
1066 err
= WSAGetLastError();
1067 ok ( ret
== 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret
, err
);
1069 err
= WSAGetLastError();
1070 ok ( (ret
== SOCKET_ERROR
&& err
== WSANOTINITIALISED
) ||
1071 broken(ret
== 0), /* WinME */
1072 "WSACleanup returned %d GetLastError is %d\n", ret
, err
);
1075 static void StartServer (LPTHREAD_START_ROUTINE routine
,
1076 test_params
*general
, server_params
*par
)
1078 par
->general
= general
;
1079 thread
[0] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[0] );
1080 ok ( thread
[0] != NULL
, "Failed to create server thread\n" );
1083 static void StartClients (LPTHREAD_START_ROUTINE routine
,
1084 test_params
*general
, client_params
*par
)
1087 par
->general
= general
;
1088 for ( i
= 1; i
<= min ( general
->n_clients
, MAX_CLIENTS
); i
++ )
1091 thread
[i
] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[i
] );
1092 ok ( thread
[i
] != NULL
, "Failed to create client thread\n" );
1093 /* Make sure the client is up and running */
1094 WaitForSingleObject ( client_ready
[client_id
], INFINITE
);
1098 static void do_test( test_setup
*test
)
1100 DWORD i
, n
= min (test
->general
.n_clients
, MAX_CLIENTS
);
1103 server_ready
= CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1104 for (i
= 0; i
<= n
; i
++)
1105 client_ready
[i
] = CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1107 StartServer ( test
->srv
, &test
->general
, &test
->srv_params
);
1108 StartClients ( test
->clt
, &test
->general
, &test
->clt_params
);
1109 WaitForSingleObject ( server_ready
, INFINITE
);
1111 wait
= WaitForMultipleObjects ( 1 + n
, thread
, TRUE
, 1000 * TEST_TIMEOUT
);
1112 ok ( wait
<= WAIT_OBJECT_0
+ n
,
1113 "some threads have not completed: %x\n", wait
);
1115 if ( ! ( wait
<= WAIT_OBJECT_0
+ n
) )
1117 for (i
= 0; i
<= n
; i
++)
1119 if ( WaitForSingleObject ( thread
[i
], 0 ) != WAIT_OBJECT_0
)
1121 trace ("terminating thread %08x\n", thread_id
[i
]);
1122 TerminateThread ( thread
[i
], 0 );
1126 CloseHandle ( server_ready
);
1127 for (i
= 0; i
<= n
; i
++)
1128 CloseHandle ( client_ready
[i
] );
1131 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1132 /* optname = SO_LINGER */
1133 static const LINGER linger_testvals
[] = {
1140 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1141 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1142 bug in the linux kernel (fixed in 2.6.8) */
1143 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1145 static void test_set_getsockopt(void)
1148 int i
, err
, lasterr
;
1152 WSAPROTOCOL_INFOA infoA
;
1153 WSAPROTOCOL_INFOW infoW
;
1154 char providername
[WSAPROTOCOL_LEN
+ 1];
1157 int family
, type
, proto
;
1159 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
1160 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
1161 {AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
},
1162 {AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
}
1165 s
= socket(AF_INET
, SOCK_STREAM
, 0);
1166 ok(s
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1167 if( s
== INVALID_SOCKET
) return;
1169 timeout
= SOCKTIMEOUT1
;
1170 size
= sizeof(timeout
);
1171 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1173 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1174 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1175 ok( timeout
== SOCKTIMEOUT1
, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1178 size
= sizeof(timeout
);
1179 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1181 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1182 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1183 ok( timeout
== 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1186 timeout
= SOCKTIMEOUT2
; /* 997 seconds. See remark above */
1187 size
= sizeof(timeout
);
1188 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, size
);
1190 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, &size
);
1191 ok( !err
, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1192 ok( timeout
== SOCKTIMEOUT2
, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout
);
1194 for( i
= 0; i
< sizeof(linger_testvals
)/sizeof(LINGER
);i
++) {
1195 size
= sizeof(lingval
);
1196 lingval
= linger_testvals
[i
];
1197 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, size
);
1199 err
= getsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, &size
);
1200 ok( !err
, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1201 ok( !lingval
.l_onoff
== !linger_testvals
[i
].l_onoff
&&
1202 (lingval
.l_linger
== linger_testvals
[i
].l_linger
||
1203 (!lingval
.l_linger
&& !linger_testvals
[i
].l_onoff
))
1204 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i
,
1205 lingval
.l_onoff
, lingval
.l_linger
,
1206 linger_testvals
[i
].l_onoff
, linger_testvals
[i
].l_linger
);
1209 size
= sizeof(lingval
);
1210 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, size
);
1211 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1212 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1213 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, 0);
1214 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1215 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1217 size
= sizeof(BOOL
);
1218 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, size
);
1219 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1220 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1221 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, 0);
1222 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1223 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1225 /* Test for erroneously passing a value instead of a pointer as optval */
1226 size
= sizeof(char);
1227 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTROUTE
, (char *)1, size
);
1228 ok(err
== SOCKET_ERROR
, "setsockopt with optval being a value passed "
1229 "instead of failing.\n");
1230 lasterr
= WSAGetLastError();
1231 ok(lasterr
== WSAEFAULT
, "setsockopt with optval being a value "
1232 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1233 lasterr
, WSAEFAULT
);
1235 /* SO_RCVTIMEO with invalid values for level */
1236 size
= sizeof(timeout
);
1237 timeout
= SOCKTIMEOUT1
;
1238 SetLastError(0xdeadbeef);
1239 err
= setsockopt(s
, 0xffffffff, SO_RCVTIMEO
, (char *) &timeout
, size
);
1240 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1241 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1242 err
, WSAGetLastError());
1244 timeout
= SOCKTIMEOUT1
;
1245 SetLastError(0xdeadbeef);
1246 err
= setsockopt(s
, 0x00008000, SO_RCVTIMEO
, (char *) &timeout
, size
);
1247 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1248 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1249 err
, WSAGetLastError());
1251 /* Test SO_ERROR set/get */
1252 SetLastError(0xdeadbeef);
1254 err
= setsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, size
);
1256 ok( !err
&& !WSAGetLastError(),
1257 "got %d with %d (expected 0 with 0)\n",
1258 err
, WSAGetLastError());
1260 SetLastError(0xdeadbeef);
1262 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1264 ok( !err
&& !WSAGetLastError(),
1265 "got %d with %d (expected 0 with 0)\n",
1266 err
, WSAGetLastError());
1268 ok (i
== 1234, "got %d (expected 1234)\n", i
);
1270 /* Test invalid optlen */
1271 SetLastError(0xdeadbeef);
1273 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1275 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEFAULT
),
1276 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1277 err
, WSAGetLastError());
1281 /* test SO_PROTOCOL_INFOA invalid parameters */
1282 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1283 "getsockopt should have failed\n");
1284 err
= WSAGetLastError();
1285 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1286 size
= sizeof(WSAPROTOCOL_INFOA
);
1287 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1288 "getsockopt should have failed\n");
1289 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1290 err
= WSAGetLastError();
1291 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1292 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1293 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1294 "getsockopt should have failed\n");
1295 err
= WSAGetLastError();
1296 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1297 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, NULL
),
1298 "getsockopt should have failed\n");
1299 err
= WSAGetLastError();
1300 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1301 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, &size
),
1302 "getsockopt should have failed\n");
1303 err
= WSAGetLastError();
1304 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1305 size
= sizeof(WSAPROTOCOL_INFOA
) / 2;
1306 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1307 "getsockopt should have failed\n");
1308 err
= WSAGetLastError();
1309 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1310 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1311 size
= sizeof(WSAPROTOCOL_INFOA
) * 2;
1312 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1313 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1314 ok(size
== sizeof(WSAPROTOCOL_INFOA
) * 2, "got size %d\n", size
);
1318 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1319 for (i
= 0; i
< sizeof(prottest
) / sizeof(prottest
[0]); i
++)
1321 s
= socket(prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1322 if (s
== INVALID_SOCKET
&& prottest
[i
].family
== AF_INET6
) continue;
1324 ok(s
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1327 /* compare both A and W version */
1328 infoA
.szProtocol
[0] = 0;
1329 size
= sizeof(WSAPROTOCOL_INFOA
);
1330 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1331 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1332 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1334 infoW
.szProtocol
[0] = 0;
1335 size
= sizeof(WSAPROTOCOL_INFOW
);
1336 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOW
, (char *) &infoW
, &size
);
1337 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1338 ok(size
== sizeof(WSAPROTOCOL_INFOW
), "got size %d\n", size
);
1340 trace("provider name '%s', family %d, type %d, proto %d\n",
1341 infoA
.szProtocol
, prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1343 ok(infoA
.szProtocol
[0] || broken(!infoA
.szProtocol
[0]) /* NT4 */,
1344 "WSAPROTOCOL_INFOA was not filled\n");
1345 ok(infoW
.szProtocol
[0] || broken(!infoA
.szProtocol
[0]) /* NT4 */,
1346 "WSAPROTOCOL_INFOW was not filled\n");
1348 WideCharToMultiByte(CP_ACP
, 0, infoW
.szProtocol
, -1,
1349 providername
, sizeof(providername
), NULL
, NULL
);
1350 ok(!strcmp(infoA
.szProtocol
,providername
),
1351 "different provider names '%s' != '%s'\n", infoA
.szProtocol
, providername
);
1353 ok(!memcmp(&infoA
, &infoW
, FIELD_OFFSET(WSAPROTOCOL_INFOA
, szProtocol
)),
1354 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1356 /* Remove IF when WSAEnumProtocols support IPV6 data */
1357 if (prottest
[i
].family
== AF_INET6
)
1360 ok(infoA
.iAddressFamily
== prottest
[i
].family
, "socket family invalid, expected %d received %d\n",
1361 prottest
[i
].family
, infoA
.iAddressFamily
);
1365 ok(infoA
.iAddressFamily
== prottest
[i
].family
, "socket family invalid, expected %d received %d\n",
1366 prottest
[i
].family
, infoA
.iAddressFamily
);
1367 } ok(infoA
.iSocketType
== prottest
[i
].type
, "socket type invalid, expected %d received %d\n",
1368 prottest
[i
].type
, infoA
.iSocketType
);
1369 ok(infoA
.iProtocol
== prottest
[i
].proto
, "socket protocol invalid, expected %d received %d\n",
1370 prottest
[i
].proto
, infoA
.iProtocol
);
1376 static void test_so_reuseaddr(void)
1378 struct sockaddr_in saddr
;
1380 unsigned int rc
,reuse
;
1383 saddr
.sin_family
= AF_INET
;
1384 saddr
.sin_port
= htons(9375);
1385 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1387 s1
=socket(AF_INET
, SOCK_STREAM
, 0);
1388 ok(s1
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1389 rc
= bind(s1
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1390 ok(rc
!=SOCKET_ERROR
, "bind(s1) failed error: %d\n", WSAGetLastError());
1392 s2
=socket(AF_INET
, SOCK_STREAM
, 0);
1393 ok(s2
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1397 rc
=getsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, &size
);
1398 ok(rc
==0 && reuse
==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc
,reuse
);
1400 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1401 ok(rc
==SOCKET_ERROR
, "bind() succeeded\n");
1404 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
1405 ok(rc
==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1407 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1408 * a port immediately after closing another socket on that port, so
1409 * basically following the BSD socket semantics here. */
1411 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1412 ok(rc
==0, "bind() failed error: %d\n", WSAGetLastError());
1417 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1419 static void test_ip_pktinfo(void)
1421 ULONG addresses
[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY
)};
1422 char recvbuf
[10], pktbuf
[512], msg
[] = "HELLO";
1423 struct sockaddr_in s1addr
, s2addr
, s3addr
;
1424 GUID WSARecvMsg_GUID
= WSAID_WSARECVMSG
;
1425 LPFN_WSARECVMSG pWSARecvMsg
= NULL
;
1426 unsigned int rc
, yes
= 1;
1428 DWORD dwBytes
, dwSize
, dwFlags
;
1437 memset(&ov
, 0, sizeof(ov
));
1438 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
1439 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
1441 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
1445 memset(&hdr
, 0x00, sizeof(hdr
));
1446 s1addr
.sin_family
= AF_INET
;
1447 s1addr
.sin_port
= htons(0);
1448 /* Note: s1addr.sin_addr is set below */
1449 iovec
[0].buf
= recvbuf
;
1450 iovec
[0].len
= sizeof(recvbuf
);
1451 hdr
.name
= (struct sockaddr
*)&s3addr
;
1452 hdr
.namelen
= sizeof(s3addr
);
1453 hdr
.lpBuffers
= &iovec
[0];
1454 hdr
.dwBufferCount
= 1;
1455 hdr
.Control
.buf
= pktbuf
;
1456 /* Note: hdr.Control.len is set below */
1459 for (i
=0;i
<sizeof(addresses
)/sizeof(UINT32
);i
++)
1461 s1addr
.sin_addr
.s_addr
= addresses
[i
];
1463 /* Build "server" side socket */
1464 s1
=socket(AF_INET
, SOCK_DGRAM
, 0);
1465 if (s1
== INVALID_SOCKET
)
1467 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1471 /* Obtain the WSARecvMsg function */
1472 WSAIoctl(s1
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
1473 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &dwBytes
, NULL
, NULL
);
1476 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
1481 /* Setup the server side socket */
1482 rc
=bind(s1
, (struct sockaddr
*)&s1addr
, sizeof(s1addr
));
1483 ok(rc
!= SOCKET_ERROR
, "bind() failed error: %d\n", WSAGetLastError());
1484 rc
=setsockopt(s1
, IPPROTO_IP
, IP_PKTINFO
, (const char*)&yes
, sizeof(yes
));
1485 ok(rc
== 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1487 /* Build "client" side socket */
1488 addrlen
= sizeof(s2addr
);
1489 if (getsockname(s1
, (struct sockaddr
*) &s2addr
, &addrlen
) != 0)
1491 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
1495 s2addr
.sin_addr
.s_addr
= addresses
[0]; /* Always target the local adapter address */
1496 s2
=socket(AF_INET
, SOCK_DGRAM
, 0);
1497 if (s2
== INVALID_SOCKET
)
1499 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1504 /* Test an empty message header */
1505 rc
=pWSARecvMsg(s1
, NULL
, NULL
, NULL
, NULL
);
1506 err
=WSAGetLastError();
1507 ok(rc
== SOCKET_ERROR
&& err
== WSAEFAULT
, "WSARecvMsg() failed error: %d (ret = %d)\n", err
, rc
);
1510 * Send a packet from the client to the server and test for specifying
1511 * a short control header.
1513 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1514 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1515 hdr
.Control
.len
= 1;
1516 rc
=pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
1517 err
=WSAGetLastError();
1518 ok(rc
== SOCKET_ERROR
&& err
== WSAEMSGSIZE
&& (hdr
.dwFlags
& MSG_CTRUNC
),
1519 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err
, rc
, hdr
.dwFlags
);
1520 hdr
.dwFlags
= 0; /* Reset flags */
1522 /* Perform another short control header test, this time with an overlapped receive */
1523 hdr
.Control
.len
= 1;
1524 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1525 err
=WSAGetLastError();
1526 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1527 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1528 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1529 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
1531 skip("Server side did not receive packet, some tests skipped.\n");
1537 WSAGetOverlappedResult(s1
, &ov
, NULL
, FALSE
, &dwFlags
);
1539 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags
);
1540 ok(hdr
.dwFlags
== MSG_CTRUNC
,
1541 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr
.dwFlags
);
1542 hdr
.dwFlags
= 0; /* Reset flags */
1545 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1546 * on the server end and check that the returned packet matches what was sent.
1548 hdr
.Control
.len
= sizeof(pktbuf
);
1549 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1550 err
=WSAGetLastError();
1551 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1552 ok(hdr
.Control
.len
== sizeof(pktbuf
),
1553 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr
.Control
.len
);
1554 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1555 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1556 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
1558 skip("Server side did not receive packet, some tests skipped.\n");
1564 WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, NULL
);
1565 ok(dwSize
== sizeof(msg
),
1566 "WSARecvMsg() buffer length does not match transmitted data!\n");
1567 ok(strncmp(iovec
[0].buf
, msg
, sizeof(msg
)) == 0,
1568 "WSARecvMsg() buffer does not match transmitted data!\n");
1569 ok(hdr
.Control
.len
== IP_PKTINFO_LEN
,
1570 "WSARecvMsg() control length mismatch (%d).\n", hdr
.Control
.len
);
1572 /* Test for the expected IP_PKTINFO return information. */
1574 for (cmsg
= WSA_CMSG_FIRSTHDR(&hdr
); cmsg
!= NULL
; cmsg
= WSA_CMSG_NXTHDR(&hdr
, cmsg
))
1576 if (cmsg
->cmsg_level
== IPPROTO_IP
&& cmsg
->cmsg_type
== IP_PKTINFO
)
1578 struct in_pktinfo
*pi
= (struct in_pktinfo
*)WSA_CMSG_DATA(cmsg
);
1580 ok(pi
->ipi_addr
.s_addr
== s2addr
.sin_addr
.s_addr
, "destination ip mismatch!\n");
1584 ok(foundhdr
, "IP_PKTINFO header information was not returned!\n");
1591 CloseHandle(ov
.hEvent
);
1594 /************* Array containing the tests to run **********/
1596 #define STD_STREAM_SOCKET \
1602 static test_setup tests
[] =
1604 /* Test 0: synchronous client and server */
1625 /* Test 1: event-driven client, synchronous server */
1642 WSA_FLAG_OVERLAPPED
,
1646 /* Test 2: synchronous client, non-blocking server via select() */
1667 /* Test 3: OOB client, OOB server */
1688 /* Test 4: synchronous mixed client and server */
1702 simple_mixed_client
,
1711 static void test_UDP(void)
1713 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
1714 possible that this test fails due to dropped packets. */
1716 /* peer 0 receives data from all other peers */
1717 struct sock_info peer
[NUM_UDP_PEERS
];
1719 int ss
, i
, n_recv
, n_sent
;
1721 memset (buf
,0,sizeof(buf
));
1722 for ( i
= NUM_UDP_PEERS
- 1; i
>= 0; i
-- ) {
1723 ok ( ( peer
[i
].s
= socket ( AF_INET
, SOCK_DGRAM
, 0 ) ) != INVALID_SOCKET
, "UDP: socket failed\n" );
1725 peer
[i
].addr
.sin_family
= AF_INET
;
1726 peer
[i
].addr
.sin_addr
.s_addr
= inet_addr ( SERVERIP
);
1729 peer
[i
].addr
.sin_port
= htons ( SERVERPORT
);
1731 peer
[i
].addr
.sin_port
= htons ( 0 );
1734 do_bind ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, sizeof( peer
[i
].addr
) );
1736 /* test getsockname() to get peer's port */
1737 ss
= sizeof ( peer
[i
].addr
);
1738 ok ( getsockname ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, &ss
) != SOCKET_ERROR
, "UDP: could not getsockname()\n" );
1739 ok ( peer
[i
].addr
.sin_port
!= htons ( 0 ), "UDP: bind() did not associate port\n" );
1742 /* test getsockname() */
1743 ok ( peer
[0].addr
.sin_port
== htons ( SERVERPORT
), "UDP: getsockname returned incorrect peer port\n" );
1745 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
1746 /* send client's ip */
1747 memcpy( buf
, &peer
[i
].addr
.sin_port
, sizeof(peer
[i
].addr
.sin_port
) );
1748 n_sent
= sendto ( peer
[i
].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*) &peer
[0].addr
, sizeof(peer
[0].addr
) );
1749 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
1752 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
1753 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0,(struct sockaddr
*) &peer
[0].peer
, &ss
);
1754 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
1755 ok ( memcmp ( &peer
[0].peer
.sin_port
, buf
, sizeof(peer
[0].addr
.sin_port
) ) == 0, "UDP: port numbers do not match\n" );
1759 static DWORD WINAPI
do_getservbyname( void *param
)
1765 } serv
[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
1767 HANDLE
*starttest
= param
;
1769 struct servent
*pserv
[2];
1771 ok ( WaitForSingleObject ( *starttest
, TEST_TIMEOUT
* 1000 ) != WAIT_TIMEOUT
, "test_getservbyname: timeout waiting for start signal\n");
1773 /* ensure that necessary buffer resizes are completed */
1774 for ( j
= 0; j
< 2; j
++) {
1775 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
1778 for ( i
= 0; i
< NUM_QUERIES
/ 2; i
++ ) {
1779 for ( j
= 0; j
< 2; j
++ ) {
1780 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
1781 ok ( pserv
[j
] != NULL
, "getservbyname could not retrieve information for %s: %d\n", serv
[j
].name
, WSAGetLastError() );
1782 if ( !pserv
[j
] ) continue;
1783 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
) );
1784 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
);
1785 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
);
1788 ok ( pserv
[0] == pserv
[1], "getservbyname: winsock resized servent buffer when not necessary\n" );
1794 static void test_getservbyname(void)
1797 HANDLE starttest
, thread
[NUM_THREADS
];
1798 DWORD thread_id
[NUM_THREADS
];
1800 starttest
= CreateEventA ( NULL
, 1, 0, "test_getservbyname_starttest" );
1802 /* create threads */
1803 for ( i
= 0; i
< NUM_THREADS
; i
++ ) {
1804 thread
[i
] = CreateThread ( NULL
, 0, do_getservbyname
, &starttest
, 0, &thread_id
[i
] );
1807 /* signal threads to start */
1808 SetEvent ( starttest
);
1810 for ( i
= 0; i
< NUM_THREADS
; i
++) {
1811 WaitForSingleObject ( thread
[i
], TEST_TIMEOUT
* 1000 );
1815 static void test_WSASocket(void)
1817 SOCKET sock
= INVALID_SOCKET
;
1818 WSAPROTOCOL_INFOA
*pi
;
1819 int wsaproviders
[] = {IPPROTO_TCP
, IPPROTO_IP
};
1820 int autoprotocols
[] = {IPPROTO_TCP
, IPPROTO_UDP
};
1821 int items
, err
, size
, socktype
, i
, j
;
1824 SetLastError(0xdeadbeef);
1825 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
,
1826 "WSASocketA should have failed\n");
1827 err
= WSAGetLastError();
1828 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
1830 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
1831 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
1834 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, NULL
, 0, 0);
1835 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
1838 SetLastError(0xdeadbeef);
1839 ok(WSASocketA(0, SOCK_STREAM
, -1, NULL
, 0, 0) == INVALID_SOCKET
,
1840 "WSASocketA should have failed\n");
1841 err
= WSAGetLastError();
1842 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
1844 SetLastError(0xdeadbeef);
1845 ok(WSASocketA(0, -1, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
1846 "WSASocketA should have failed\n");
1847 err
= WSAGetLastError();
1848 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
1850 SetLastError(0xdeadbeef);
1851 ok(WSASocketA(0, -1, 0, NULL
, 0, 0) == INVALID_SOCKET
,
1852 "WSASocketA should have failed\n");
1853 err
= WSAGetLastError();
1854 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
1856 SetLastError(0xdeadbeef);
1857 ok(WSASocketA(AF_INET
, -1, 0, NULL
, 0, 0) == INVALID_SOCKET
,
1858 "WSASocketA should have failed\n");
1859 err
= WSAGetLastError();
1860 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
1862 SetLastError(0xdeadbeef);
1863 ok(WSASocketA(AF_INET
, 0, -1, NULL
, 0, 0) == INVALID_SOCKET
,
1864 "WSASocketA should have failed\n");
1865 err
= WSAGetLastError();
1866 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
1868 SetLastError(0xdeadbeef);
1869 ok(WSASocketA(0, -1, -1, NULL
, 0, 0) == INVALID_SOCKET
,
1870 "WSASocketA should have failed\n");
1871 err
= WSAGetLastError();
1872 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
1874 SetLastError(0xdeadbeef);
1875 ok(WSASocketA(-1, SOCK_STREAM
, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
1876 "WSASocketA should have failed\n");
1877 err
= WSAGetLastError();
1878 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
1880 sock
= WSASocketA(AF_INET
, 0, IPPROTO_TCP
, NULL
, 0, 0);
1881 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
1884 SetLastError(0xdeadbeef);
1885 ok(WSASocketA(0, SOCK_STREAM
, 0, NULL
, 0, 0) == INVALID_SOCKET
,
1886 "WSASocketA should have failed\n");
1887 err
= WSAGetLastError();
1888 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
1890 SetLastError(0xdeadbeef);
1891 ok(WSASocketA(0, 0, 0xdead, NULL
, 0, 0) == INVALID_SOCKET
,
1892 "WSASocketA should have failed\n");
1893 err
= WSAGetLastError();
1894 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
1896 SetLastError(0xdeadbeef);
1897 ok(WSASocketA(AF_INET
, 0xdead, 0, NULL
, 0, 0) == INVALID_SOCKET
,
1898 "WSASocketA should have failed\n");
1899 err
= WSAGetLastError();
1900 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
1902 SetLastError(0xdeadbeef);
1903 ok(WSASocketA(0, 0xdead, 0, NULL
, 0, 0) == INVALID_SOCKET
,
1904 "WSASocketA should have failed\n");
1905 err
= WSAGetLastError();
1906 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
1908 sock
= WSASocketA(0, 0, IPPROTO_TCP
, NULL
, 0, 0);
1909 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
1912 /* SOCK_STREAM does not support IPPROTO_UDP */
1913 SetLastError(0xdeadbeef);
1914 ok(WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
1915 "WSASocketA should have failed\n");
1916 err
= WSAGetLastError();
1917 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
1919 /* SOCK_DGRAM does not support IPPROTO_TCP */
1920 SetLastError(0xdeadbeef);
1921 ok(WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, NULL
, 0, 0) == INVALID_SOCKET
,
1922 "WSASocketA should have failed\n");
1923 err
= WSAGetLastError();
1924 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
1926 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
1927 * to avoid a crash on win98.
1930 items
= WSAEnumProtocolsA(wsaproviders
, NULL
, &pi_size
);
1931 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
1933 err
= WSAGetLastError();
1934 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
1937 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
1938 ok(pi
!= NULL
, "Failed to allocate memory\n");
1940 skip("Can't continue without memory.\n");
1944 items
= WSAEnumProtocolsA(wsaproviders
, pi
, &pi_size
);
1945 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
1949 skip("No protocols enumerated.\n");
1950 HeapFree(GetProcessHeap(), 0, pi
);
1954 sock
= WSASocketA(FROM_PROTOCOL_INFO
, FROM_PROTOCOL_INFO
,
1955 FROM_PROTOCOL_INFO
, &pi
[0], 0, 0);
1956 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1960 /* find what parameters are used first: plain parameters or protocol info struct */
1961 pi
[0].iProtocol
= -1;
1962 pi
[0].iSocketType
= -1;
1963 pi
[0].iAddressFamily
= -1;
1964 ok(WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0) == INVALID_SOCKET
,
1965 "WSASocketA should have failed\n");
1966 err
= WSAGetLastError();
1967 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
1969 pi
[0].iProtocol
= 0;
1970 pi
[0].iSocketType
= 0;
1971 pi
[0].iAddressFamily
= 0;
1972 sock
= WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0);
1973 if(sock
!= INVALID_SOCKET
)
1975 win_skip("must work only in OS <= 2003\n");
1980 err
= WSAGetLastError();
1981 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
1984 pi
[0].iProtocol
= IPPROTO_UDP
;
1985 pi
[0].iSocketType
= SOCK_DGRAM
;
1986 pi
[0].iAddressFamily
= AF_INET
;
1987 sock
= WSASocketA(0, 0, 0, &pi
[0], 0, 0);
1988 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1990 size
= sizeof(socktype
);
1992 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
1993 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1994 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
1995 SOCK_DGRAM
, socktype
);
1998 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, &pi
[0], 0, 0);
1999 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2001 size
= sizeof(socktype
);
2003 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2004 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2005 ok(socktype
== SOCK_STREAM
, "Wrong socket type, expected %d received %d\n",
2006 SOCK_STREAM
, socktype
);
2009 HeapFree(GetProcessHeap(), 0, pi
);
2012 items
= WSAEnumProtocolsA(NULL
, NULL
, &pi_size
);
2013 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2015 err
= WSAGetLastError();
2016 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2019 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2020 ok(pi
!= NULL
, "Failed to allocate memory\n");
2022 skip("Can't continue without memory.\n");
2026 items
= WSAEnumProtocolsA(NULL
, pi
, &pi_size
);
2027 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2030 /* when no protocol and socket type are specified the first entry
2031 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2033 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
2034 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2037 size
= sizeof(socktype
);
2039 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2040 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2041 for(i
= 0; i
< items
; i
++)
2043 if(pi
[i
].dwProviderFlags
& PFL_MATCHES_PROTOCOL_ZERO
)
2045 ok(socktype
== pi
[i
].iSocketType
, "Wrong socket type, expected %d received %d\n",
2046 pi
[i
].iSocketType
, socktype
);
2050 ok(i
!= items
, "Creating a socket without protocol and socket type didn't work\n");
2053 /* when no socket type is specified the first entry from WSAEnumProtocols
2054 * that matches the protocol is returned */
2055 for (i
= 0; i
< sizeof(autoprotocols
) / sizeof(autoprotocols
[0]); i
++)
2057 sock
= WSASocketA(0, 0, autoprotocols
[i
], NULL
, 0, 0);
2058 ok(sock
!= INVALID_SOCKET
, "Failed to create socket for protocol %d, received %d\n",
2059 autoprotocols
[i
], WSAGetLastError());
2061 size
= sizeof(socktype
);
2063 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2064 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2066 for (err
= 1, j
= 0; j
< items
; j
++)
2068 if (pi
[j
].iProtocol
== autoprotocols
[i
])
2070 if (socktype
== pi
[j
].iSocketType
)
2073 ok(0, "Wrong socket type, expected %d received %d\n",
2074 pi
[j
].iSocketType
, socktype
);
2078 ok(!err
, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols
[i
]);
2083 HeapFree(GetProcessHeap(), 0, pi
);
2085 SetLastError(0xdeadbeef);
2086 /* starting on vista the socket function returns error during the socket
2087 creation and no longer in the socket operations (sendto, readfrom) */
2088 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_ICMP
, NULL
, 0, 0);
2089 if (sock
== INVALID_SOCKET
)
2091 err
= WSAGetLastError();
2092 ok(err
== WSAEACCES
, "Expected 10013, received %d\n", err
);
2093 skip("SOCK_RAW is not supported\n");
2097 trace("SOCK_RAW is supported\n");
2099 size
= sizeof(socktype
);
2101 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2102 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2103 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2104 SOCK_RAW
, socktype
);
2108 sock
= WSASocketA(0, 0, IPPROTO_RAW
, NULL
, 0, 0);
2109 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2111 size
= sizeof(socktype
);
2113 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2114 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2115 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2116 SOCK_RAW
, socktype
);
2120 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_TCP
, NULL
, 0, 0);
2121 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2123 size
= sizeof(socktype
);
2125 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2126 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2127 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2128 SOCK_RAW
, socktype
);
2132 /* IPX socket tests */
2134 SetLastError(0xdeadbeef);
2135 sock
= WSASocketA(AF_IPX
, SOCK_DGRAM
, NSPROTO_IPX
, NULL
, 0, 0);
2136 if (sock
== INVALID_SOCKET
)
2138 err
= WSAGetLastError();
2139 ok(err
== WSAEAFNOSUPPORT
|| broken(err
== WSAEPROTONOSUPPORT
), "Expected 10047, received %d\n", err
);
2140 skip("IPX is not supported\n");
2144 WSAPROTOCOL_INFOA info
;
2147 trace("IPX is supported\n");
2149 sock
= WSASocketA(0, 0, NSPROTO_IPX
, NULL
, 0, 0);
2150 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2153 size
= sizeof(socktype
);
2155 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2156 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2157 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2158 SOCK_DGRAM
, socktype
);
2160 /* check socket family, type and protocol */
2161 size
= sizeof(WSAPROTOCOL_INFOA
);
2162 err
= getsockopt(sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &info
, &size
);
2163 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2164 ok(info
.iProtocol
== NSPROTO_IPX
, "expected protocol %d, received %d\n",
2165 NSPROTO_IPX
, info
.iProtocol
);
2166 ok(info
.iAddressFamily
== AF_IPX
, "expected family %d, received %d\n",
2167 AF_IPX
, info
.iProtocol
);
2168 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2169 SOCK_DGRAM
, info
.iSocketType
);
2172 /* SOCK_STREAM does not support NSPROTO_IPX */
2173 SetLastError(0xdeadbeef);
2174 ok(WSASocketA(AF_IPX
, SOCK_STREAM
, NSPROTO_IPX
, NULL
, 0, 0) == INVALID_SOCKET
,
2175 "WSASocketA should have failed\n");
2176 err
= WSAGetLastError();
2177 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2179 /* test extended IPX support - that is adding any number between 0 and 255
2180 * to the IPX protocol value will make it be used as IPX packet type */
2181 for(i
= 0;i
<= 255;i
+= 17)
2183 SetLastError(0xdeadbeef);
2184 sock
= WSASocketA(0, 0, NSPROTO_IPX
+ i
, NULL
, 0, 0);
2185 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2190 err
= getsockopt(sock
, NSPROTO_IPX
, IPX_PTYPE
, (char *) &socktype
, &size
);
2191 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2192 ok(socktype
== i
, "Wrong IPX packet type, expected %d received %d\n",
2200 static void test_WSADuplicateSocket(void)
2202 SOCKET source
, dupsock
;
2203 WSAPROTOCOL_INFOA info
;
2205 struct sockaddr_in addr
;
2206 int socktype
, size
, addrsize
, ret
;
2207 char teststr
[] = "TEST", buffer
[16];
2209 source
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
2210 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2212 /* test invalid parameters */
2213 SetLastError(0xdeadbeef);
2214 ok(WSADuplicateSocketA(0, 0, NULL
), "WSADuplicateSocketA should have failed\n");
2215 err
= WSAGetLastError();
2216 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2218 SetLastError(0xdeadbeef);
2219 ok(WSADuplicateSocketA(source
, 0, NULL
),
2220 "WSADuplicateSocketA should have failed\n");
2221 err
= WSAGetLastError();
2222 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2224 SetLastError(0xdeadbeef);
2225 ok(WSADuplicateSocketA(source
, ~0, &info
),
2226 "WSADuplicateSocketA should have failed\n");
2227 err
= WSAGetLastError();
2228 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2230 SetLastError(0xdeadbeef);
2231 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info
),
2232 "WSADuplicateSocketA should have failed\n");
2233 err
= WSAGetLastError();
2234 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2236 SetLastError(0xdeadbeef);
2237 ok(WSADuplicateSocketA(source
, GetCurrentProcessId(), NULL
),
2238 "WSADuplicateSocketA should have failed\n");
2239 err
= WSAGetLastError();
2240 ok(err
== WSAEFAULT
, "expected 10014, received %d\n", err
);
2242 /* test returned structure */
2243 memset(&info
, 0, sizeof(info
));
2244 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2245 "WSADuplicateSocketA should have worked\n");
2247 ok(info
.iProtocol
== IPPROTO_TCP
, "expected protocol %d, received %d\n",
2248 IPPROTO_TCP
, info
.iProtocol
);
2249 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2250 AF_INET
, info
.iProtocol
);
2251 ok(info
.iSocketType
== SOCK_STREAM
, "expected type %d, received %d\n",
2252 SOCK_STREAM
, info
.iSocketType
);
2254 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2255 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2257 closesocket(dupsock
);
2258 closesocket(source
);
2260 /* create a socket, bind it, duplicate it then send data on source and
2261 * receve in the duplicated socket */
2262 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2263 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2265 memset(&info
, 0, sizeof(info
));
2266 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2267 "WSADuplicateSocketA should have worked\n");
2269 ok(info
.iProtocol
== IPPROTO_UDP
, "expected protocol %d, received %d\n",
2270 IPPROTO_UDP
, info
.iProtocol
);
2271 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2272 AF_INET
, info
.iProtocol
);
2273 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2274 SOCK_DGRAM
, info
.iSocketType
);
2276 memset(&addr
, 0, sizeof(addr
));
2277 addr
.sin_family
= AF_INET
;
2278 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2279 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2280 "bind should have worked\n");
2282 /* read address to find out the port number to be used in sendto */
2283 memset(&addr
, 0, sizeof(addr
));
2284 addrsize
= sizeof(addr
);
2285 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2286 "getsockname should have worked\n");
2287 ok(addr
.sin_port
, "socket port should be != 0\n");
2289 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2290 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2293 ret
= getsockopt(dupsock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2294 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
2295 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2296 SOCK_DGRAM
, socktype
);
2298 set_blocking(source
, TRUE
);
2300 /* send data on source socket */
2301 addrsize
= sizeof(addr
);
2302 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2303 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2305 /* receive on duplicated socket */
2306 addrsize
= sizeof(addr
);
2307 memset(buffer
, 0, sizeof(buffer
));
2308 size
= recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
);
2309 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2310 buffer
[sizeof(teststr
) - 1] = 0;
2311 ok(!strcmp(buffer
, teststr
), "expected '%s', received '%s'\n", teststr
, buffer
);
2313 closesocket(dupsock
);
2314 closesocket(source
);
2316 /* show that the source socket need to be bound before the duplicated
2317 * socket is created */
2318 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2319 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2321 memset(&info
, 0, sizeof(info
));
2322 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2323 "WSADuplicateSocketA should have worked\n");
2325 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2326 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2328 memset(&addr
, 0, sizeof(addr
));
2329 addr
.sin_family
= AF_INET
;
2330 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2331 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2332 "bind should have worked\n");
2334 /* read address to find out the port number to be used in sendto */
2335 memset(&addr
, 0, sizeof(addr
));
2336 addrsize
= sizeof(addr
);
2337 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2338 "getsockname should have worked\n");
2339 ok(addr
.sin_port
, "socket port should be != 0\n");
2341 set_blocking(source
, TRUE
);
2343 addrsize
= sizeof(addr
);
2344 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2345 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2347 SetLastError(0xdeadbeef);
2348 addrsize
= sizeof(addr
);
2349 memset(buffer
, 0, sizeof(buffer
));
2351 ok(recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
) == -1,
2352 "recvfrom should have failed\n");
2353 err
= WSAGetLastError();
2354 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2357 closesocket(dupsock
);
2358 closesocket(source
);
2361 static void test_WSAAddressToStringA(void)
2363 SOCKET v6
= INVALID_SOCKET
;
2367 SOCKADDR_IN sockaddr
;
2368 CHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2370 CHAR expect1
[] = "0.0.0.0";
2371 CHAR expect2
[] = "255.255.255.255";
2372 CHAR expect3
[] = "0.0.0.0:65535";
2373 CHAR expect4
[] = "255.255.255.255:65535";
2375 SOCKADDR_IN6 sockaddr6
;
2376 CHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2378 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2379 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2380 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2382 CHAR expect6_1
[] = "::1";
2383 CHAR expect6_2
[] = "20ab::1";
2384 CHAR expect6_3
[] = "[20ab::2001]:33274";
2385 CHAR expect6_3_nt
[] = "20ab::2001@33274";
2386 CHAR expect6_3_w2k
[] = "20ab::2001";
2387 CHAR expect6_3_2
[] = "[20ab::2001%4660]:33274";
2388 CHAR expect6_3_2_nt
[] = "4660/20ab::2001@33274";
2389 CHAR expect6_3_2_w2k
[] = "20ab::2001%4660";
2390 CHAR expect6_3_3
[] = "20ab::2001%4660";
2391 CHAR expect6_3_3_nt
[] = "4660/20ab::2001";
2395 sockaddr
.sin_family
= AF_INET
;
2396 sockaddr
.sin_port
= 0;
2397 sockaddr
.sin_addr
.s_addr
= 0;
2399 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2400 GLE
= WSAGetLastError();
2401 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
2402 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2405 len
= sizeof(address
);
2407 sockaddr
.sin_family
= AF_INET
;
2408 sockaddr
.sin_port
= 0;
2409 sockaddr
.sin_addr
.s_addr
= 0;
2411 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2412 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2414 ok( !strcmp( address
, expect1
), "Expected: %s, got: %s\n", expect1
, address
);
2415 ok( len
== sizeof( expect1
), "Got size %d\n", len
);
2417 len
= sizeof(address
);
2419 sockaddr
.sin_family
= AF_INET
;
2420 sockaddr
.sin_port
= 0;
2421 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
2423 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2424 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2426 ok( !strcmp( address
, expect2
), "Expected: %s, got: %s\n", expect2
, address
);
2428 len
= sizeof(address
);
2430 sockaddr
.sin_family
= AF_INET
;
2431 sockaddr
.sin_port
= 0xffff;
2432 sockaddr
.sin_addr
.s_addr
= 0;
2434 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2435 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2437 ok( !strcmp( address
, expect3
), "Expected: %s, got: %s\n", expect3
, address
);
2439 len
= sizeof(address
);
2441 sockaddr
.sin_family
= AF_INET
;
2442 sockaddr
.sin_port
= 0xffff;
2443 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
2445 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2446 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2448 ok( !strcmp( address
, expect4
), "Expected: %s, got: %s\n", expect4
, address
);
2449 ok( len
== sizeof( expect4
), "Got size %d\n", len
);
2451 /*check to see it IPv6 is available */
2452 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
2453 if (v6
== INVALID_SOCKET
) {
2454 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2455 WSAGetLastError(), WSAEAFNOSUPPORT
);
2458 /* Test a short IPv6 address */
2459 len
= sizeof(address6
);
2461 sockaddr6
.sin6_family
= AF_INET6
;
2462 sockaddr6
.sin6_port
= 0x0000;
2463 sockaddr6
.sin6_scope_id
= 0;
2464 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
2466 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2467 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2468 ok( !strcmp( address6
, expect6_1
), "Expected: %s, got: %s\n", expect6_1
, address6
);
2469 ok( len
== sizeof(expect6_1
), "Got size %d\n", len
);
2471 /* Test a longer IPv6 address */
2472 len
= sizeof(address6
);
2474 sockaddr6
.sin6_family
= AF_INET6
;
2475 sockaddr6
.sin6_port
= 0x0000;
2476 sockaddr6
.sin6_scope_id
= 0;
2477 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
2479 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2480 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2481 ok( !strcmp( address6
, expect6_2
), "Expected: %s, got: %s\n", expect6_2
, address6
);
2482 ok( len
== sizeof(expect6_2
), "Got size %d\n", len
);
2484 /* Test IPv6 address and port number */
2485 len
= sizeof(address6
);
2487 sockaddr6
.sin6_family
= AF_INET6
;
2488 sockaddr6
.sin6_port
= 0xfa81;
2489 sockaddr6
.sin6_scope_id
= 0;
2490 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2492 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2493 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2494 ok( !strcmp( address6
, expect6_3
) ||
2495 broken( !strcmp( address6
, expect6_3_nt
) ) || /* NT4 */
2496 broken( !strcmp( address6
, expect6_3_w2k
) ), /* Win2000 */
2497 "Expected: %s, got: %s\n", expect6_3
, address6
);
2498 ok( len
== sizeof(expect6_3
) ||
2499 broken( len
== sizeof(expect6_3_nt
) ) || /* NT4 */
2500 broken( len
== sizeof(expect6_3_w2k
) ), /* Win2000 */
2501 "Got size %d\n", len
);
2503 /* Test IPv6 address, port number and scope_id */
2504 len
= sizeof(address6
);
2506 sockaddr6
.sin6_family
= AF_INET6
;
2507 sockaddr6
.sin6_port
= 0xfa81;
2508 sockaddr6
.sin6_scope_id
= 0x1234;
2509 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2511 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2512 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2513 ok( !strcmp( address6
, expect6_3_2
) ||
2514 broken( !strcmp( address6
, expect6_3_2_nt
) ) || /* NT4 */
2515 broken( !strcmp( address6
, expect6_3_2_w2k
) ), /* Win2000 */
2516 "Expected: %s, got: %s\n", expect6_3_2
, address6
);
2517 ok( len
== sizeof(expect6_3_2
) ||
2518 broken( len
== sizeof(expect6_3_2_nt
) ) || /* NT4 */
2519 broken( len
== sizeof(expect6_3_2_w2k
) ), /* Win2000 */
2520 "Got size %d\n", len
);
2522 /* Test IPv6 address and scope_id */
2523 len
= sizeof(address6
);
2525 sockaddr6
.sin6_family
= AF_INET6
;
2526 sockaddr6
.sin6_port
= 0x0000;
2527 sockaddr6
.sin6_scope_id
= 0x1234;
2528 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2530 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2531 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2532 ok( !strcmp( address6
, expect6_3_3
) ||
2533 broken( !strcmp( address6
, expect6_3_3_nt
) ), /* NT4 */
2534 "Expected: %s, got: %s\n", expect6_3_3
, address6
);
2535 ok( len
== sizeof(expect6_3_3
) ||
2536 broken( len
== sizeof(expect6_3_3_nt
) ), /* NT4 */
2537 "Got size %d\n", len
);
2540 if (v6
!= INVALID_SOCKET
)
2544 static void test_WSAAddressToStringW(void)
2546 SOCKET v6
= INVALID_SOCKET
;
2550 SOCKADDR_IN sockaddr
;
2551 WCHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2553 WCHAR expect1
[] = { '0','.','0','.','0','.','0', 0 };
2554 WCHAR expect2
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
2555 WCHAR expect3
[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
2556 WCHAR expect4
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
2557 '6', '5', '5', '3', '5', 0 };
2559 SOCKADDR_IN6 sockaddr6
;
2560 WCHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2562 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2563 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2564 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2566 WCHAR expect6_1
[] = {':',':','1',0};
2567 WCHAR expect6_2
[] = {'2','0','a','b',':',':','1',0};
2568 WCHAR expect6_3
[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
2569 WCHAR expect6_3_nt
[] = {'2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
2570 WCHAR expect6_3_w2k
[] = {'2','0','a','b',':',':','2','0','0','1',0};
2571 WCHAR expect6_3_2
[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
2572 WCHAR expect6_3_2_nt
[] = {'4','6','6','0','/','2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
2573 WCHAR expect6_3_2_w2k
[] = {'2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',0};
2574 WCHAR expect6_3_3
[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
2575 WCHAR expect6_3_3_nt
[] = {'6','5','5','3','4','/','2','0','a','b',':',':','2','0','0','1',0};
2579 sockaddr
.sin_family
= AF_INET
;
2580 sockaddr
.sin_port
= 0;
2581 sockaddr
.sin_addr
.s_addr
= 0;
2583 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2584 GLE
= WSAGetLastError();
2585 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
2586 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2589 len
= sizeof(address
);
2591 sockaddr
.sin_family
= AF_INET
;
2592 sockaddr
.sin_port
= 0;
2593 sockaddr
.sin_addr
.s_addr
= 0;
2595 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2596 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2598 ok( !lstrcmpW( address
, expect1
), "Expected different address string\n" );
2599 ok( len
== sizeof( expect1
)/sizeof( WCHAR
), "Got size %d\n", len
);
2601 len
= sizeof(address
);
2603 sockaddr
.sin_family
= AF_INET
;
2604 sockaddr
.sin_port
= 0;
2605 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
2607 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2608 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2610 ok( !lstrcmpW( address
, expect2
), "Expected different address string\n" );
2612 len
= sizeof(address
);
2614 sockaddr
.sin_family
= AF_INET
;
2615 sockaddr
.sin_port
= 0xffff;
2616 sockaddr
.sin_addr
.s_addr
= 0;
2618 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2619 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2621 ok( !lstrcmpW( address
, expect3
), "Expected different address string\n" );
2623 len
= sizeof(address
);
2625 sockaddr
.sin_family
= AF_INET
;
2626 sockaddr
.sin_port
= 0xffff;
2627 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
2629 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2630 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2632 ok( !lstrcmpW( address
, expect4
), "Expected different address string\n" );
2633 ok( len
== sizeof( expect4
)/sizeof( WCHAR
), "Got %d\n", len
);
2635 /*check to see it IPv6 is available */
2636 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
2637 if (v6
== INVALID_SOCKET
) {
2638 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2639 WSAGetLastError(), WSAEAFNOSUPPORT
);
2643 /* Test a short IPv6 address */
2644 len
= sizeof(address6
)/sizeof(WCHAR
);
2646 sockaddr6
.sin6_family
= AF_INET6
;
2647 sockaddr6
.sin6_port
= 0x0000;
2648 sockaddr6
.sin6_scope_id
= 0;
2649 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
2651 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2652 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2653 ok( !lstrcmpW( address6
, expect6_1
), "Wrong string returned\n" );
2654 ok( len
== sizeof(expect6_1
)/sizeof(WCHAR
), "Got %d\n", len
);
2656 /* Test a longer IPv6 address */
2657 len
= sizeof(address6
)/sizeof(WCHAR
);
2659 sockaddr6
.sin6_family
= AF_INET6
;
2660 sockaddr6
.sin6_port
= 0x0000;
2661 sockaddr6
.sin6_scope_id
= 0;
2662 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
2664 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2665 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2667 ok( !lstrcmpW( address6
, expect6_2
), "Wrong string returned\n" );
2668 ok( len
== sizeof(expect6_2
)/sizeof(WCHAR
), "Got %d\n", len
);
2670 /* Test IPv6 address and port number */
2671 len
= sizeof(address6
)/sizeof(WCHAR
);
2673 sockaddr6
.sin6_family
= AF_INET6
;
2674 sockaddr6
.sin6_port
= 0xfa81;
2675 sockaddr6
.sin6_scope_id
= 0;
2676 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2678 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2679 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2680 ok( !lstrcmpW( address6
, expect6_3
) ||
2681 broken( !lstrcmpW( address6
, expect6_3_nt
) ) || /* NT4 */
2682 broken( !lstrcmpW( address6
, expect6_3_w2k
) ), /* Win2000 */
2683 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3
),
2684 wine_dbgstr_w(address6
) );
2685 ok( len
== sizeof(expect6_3
)/sizeof(WCHAR
) ||
2686 broken(len
== sizeof(expect6_3_nt
)/sizeof(WCHAR
) ) || /* NT4 */
2687 broken(len
== sizeof(expect6_3_w2k
)/sizeof(WCHAR
) ), /* Win2000 */
2690 /* Test IPv6 address, port number and scope_id */
2691 len
= sizeof(address6
)/sizeof(WCHAR
);
2693 sockaddr6
.sin6_family
= AF_INET6
;
2694 sockaddr6
.sin6_port
= 0xfa81;
2695 sockaddr6
.sin6_scope_id
= 0x1234;
2696 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2698 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2699 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2700 ok( !lstrcmpW( address6
, expect6_3_2
) ||
2701 broken( !lstrcmpW( address6
, expect6_3_2_nt
) ) || /* NT4 */
2702 broken( !lstrcmpW( address6
, expect6_3_2_w2k
) ), /* Win2000 */
2703 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2
),
2704 wine_dbgstr_w(address6
) );
2705 ok( len
== sizeof(expect6_3_2
)/sizeof(WCHAR
) ||
2706 broken( len
== sizeof(expect6_3_2_nt
)/sizeof(WCHAR
) ) || /* NT4 */
2707 broken( len
== sizeof(expect6_3_2_w2k
)/sizeof(WCHAR
) ), /* Win2000 */
2710 /* Test IPv6 address and scope_id */
2711 len
= sizeof(address6
)/sizeof(WCHAR
);
2713 sockaddr6
.sin6_family
= AF_INET6
;
2714 sockaddr6
.sin6_port
= 0x0000;
2715 sockaddr6
.sin6_scope_id
= 0xfffe;
2716 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2718 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2719 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2720 ok( !lstrcmpW( address6
, expect6_3_3
) ||
2721 broken( !lstrcmpW( address6
, expect6_3_3_nt
) ), /* NT4 */
2722 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3
),
2723 wine_dbgstr_w(address6
) );
2724 ok( len
== sizeof(expect6_3_3
)/sizeof(WCHAR
) ||
2725 broken( len
== sizeof(expect6_3_3_nt
)/sizeof(WCHAR
) ), /* NT4 */
2729 if (v6
!= INVALID_SOCKET
)
2733 static void test_WSAStringToAddressA(void)
2736 SOCKADDR_IN sockaddr
;
2737 SOCKADDR_IN6 sockaddr6
;
2740 CHAR address1
[] = "0.0.0.0";
2741 CHAR address2
[] = "127.127.127.127";
2742 CHAR address3
[] = "255.255.255.255";
2743 CHAR address4
[] = "127.127.127.127:65535";
2744 CHAR address5
[] = "255.255.255.255:65535";
2745 CHAR address6
[] = "::1";
2746 CHAR address7
[] = "[::1]";
2747 CHAR address8
[] = "[::1]:65535";
2750 sockaddr
.sin_family
= AF_INET
;
2752 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2753 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
2754 WSAGetLastError() );
2756 len
= sizeof(sockaddr
);
2757 sockaddr
.sin_port
= 0;
2758 sockaddr
.sin_addr
.s_addr
= 0;
2760 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2761 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
2762 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
2764 len
= sizeof(sockaddr
);
2765 sockaddr
.sin_port
= 0;
2766 sockaddr
.sin_addr
.s_addr
= 0;
2768 ret
= WSAStringToAddressA( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2769 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
2770 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
2772 len
= sizeof(sockaddr
);
2773 sockaddr
.sin_port
= 0;
2774 sockaddr
.sin_addr
.s_addr
= 0;
2776 ret
= WSAStringToAddressA( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2777 GLE
= WSAGetLastError();
2778 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
2779 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2780 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
2782 len
= sizeof(sockaddr
);
2783 sockaddr
.sin_port
= 0;
2784 sockaddr
.sin_addr
.s_addr
= 0;
2786 ret
= WSAStringToAddressA( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2787 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
2788 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
2790 len
= sizeof(sockaddr
);
2791 sockaddr
.sin_port
= 0;
2792 sockaddr
.sin_addr
.s_addr
= 0;
2794 ret
= WSAStringToAddressA( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2795 GLE
= WSAGetLastError();
2796 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
2797 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2798 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
2800 len
= sizeof(sockaddr6
);
2801 memset(&sockaddr6
, 0, len
);
2802 sockaddr6
.sin6_family
= AF_INET6
;
2804 ret
= WSAStringToAddressA( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2806 GLE
= WSAGetLastError();
2807 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2808 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
2810 len
= sizeof(sockaddr6
);
2811 memset(&sockaddr6
, 0, len
);
2812 sockaddr6
.sin6_family
= AF_INET6
;
2814 ret
= WSAStringToAddressA( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2816 GLE
= WSAGetLastError();
2817 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2818 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
2820 len
= sizeof(sockaddr6
);
2821 memset(&sockaddr6
, 0, len
);
2822 sockaddr6
.sin6_family
= AF_INET6
;
2824 ret
= WSAStringToAddressA( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2826 GLE
= WSAGetLastError();
2827 ok( (ret
== 0 && sockaddr6
.sin6_port
== 0xffff) ||
2828 (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2829 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
2833 static void test_WSAStringToAddressW(void)
2836 SOCKADDR_IN sockaddr
, *sin
;
2837 SOCKADDR_IN6 sockaddr6
;
2838 SOCKADDR_STORAGE sockaddr_storage
;
2841 WCHAR address1
[] = { '0','.','0','.','0','.','0', 0 };
2842 WCHAR address2
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
2843 WCHAR address3
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
2844 WCHAR address4
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
2845 ':', '6', '5', '5', '3', '5', 0 };
2846 WCHAR address5
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
2847 '6', '5', '5', '3', '5', 0 };
2848 WCHAR address6
[] = {':',':','1','\0'};
2849 WCHAR address7
[] = {'[',':',':','1',']','\0'};
2850 WCHAR address8
[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
2853 sockaddr
.sin_family
= AF_INET
;
2855 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2856 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressW() failed unexpectedly: %d\n",
2857 WSAGetLastError() );
2859 len
= sizeof(sockaddr
);
2860 sockaddr
.sin_port
= 0;
2861 sockaddr
.sin_addr
.s_addr
= 0;
2863 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2864 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
2865 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2867 len
= sizeof(sockaddr
);
2868 sockaddr
.sin_port
= 0;
2869 sockaddr
.sin_addr
.s_addr
= 0;
2871 ret
= WSAStringToAddressW( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2872 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
2873 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2875 len
= sizeof(sockaddr
);
2876 sockaddr
.sin_port
= 0;
2877 sockaddr
.sin_addr
.s_addr
= 0;
2879 ret
= WSAStringToAddressW( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2880 GLE
= WSAGetLastError();
2881 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
2882 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2883 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
2885 len
= sizeof(sockaddr
);
2886 sockaddr
.sin_port
= 0;
2887 sockaddr
.sin_addr
.s_addr
= 0;
2889 ret
= WSAStringToAddressW( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2890 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
2891 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2893 len
= sizeof(sockaddr
);
2894 sockaddr
.sin_port
= 0;
2895 sockaddr
.sin_addr
.s_addr
= 0;
2897 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2898 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
2899 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2900 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
2902 /* Test with a larger buffer than necessary */
2903 len
= sizeof(sockaddr_storage
);
2904 sin
= (SOCKADDR_IN
*)&sockaddr_storage
;
2906 sin
->sin_addr
.s_addr
= 0;
2908 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)sin
, &len
);
2909 ok( (ret
== 0 && sin
->sin_addr
.s_addr
== 0xffffffff && sin
->sin_port
== 0xffff) ||
2910 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2911 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
2912 ok( len
== sizeof(SOCKADDR_IN
) ||
2913 broken(len
== sizeof(SOCKADDR_STORAGE
)) /* NT4/2k */,
2914 "unexpected length %d\n", len
);
2916 len
= sizeof(sockaddr6
);
2917 memset(&sockaddr6
, 0, len
);
2918 sockaddr6
.sin6_family
= AF_INET6
;
2920 ret
= WSAStringToAddressW( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2922 GLE
= WSAGetLastError();
2923 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2924 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
2926 len
= sizeof(sockaddr6
);
2927 memset(&sockaddr6
, 0, len
);
2928 sockaddr6
.sin6_family
= AF_INET6
;
2930 ret
= WSAStringToAddressW( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2932 GLE
= WSAGetLastError();
2933 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2934 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
2936 len
= sizeof(sockaddr6
);
2937 memset(&sockaddr6
, 0, len
);
2938 sockaddr6
.sin6_family
= AF_INET6
;
2940 ret
= WSAStringToAddressW( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2942 GLE
= WSAGetLastError();
2943 ok( (ret
== 0 && sockaddr6
.sin6_port
== 0xffff) ||
2944 (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2945 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
2949 static DWORD WINAPI
SelectReadThread(void *param
)
2951 select_thread_params
*par
= param
;
2954 struct sockaddr_in addr
;
2955 struct timeval select_timeout
;
2958 FD_SET(par
->s
, &readfds
);
2959 select_timeout
.tv_sec
=5;
2960 select_timeout
.tv_usec
=0;
2961 addr
.sin_family
= AF_INET
;
2962 addr
.sin_addr
.s_addr
= inet_addr(SERVERIP
);
2963 addr
.sin_port
= htons(SERVERPORT
);
2965 do_bind(par
->s
, (struct sockaddr
*)&addr
, sizeof(addr
));
2966 wsa_ok(listen(par
->s
, SOMAXCONN
), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
2968 SetEvent(server_ready
);
2969 ret
= select(par
->s
+1, &readfds
, NULL
, NULL
, &select_timeout
);
2970 par
->ReadKilled
= (ret
== 1);
2975 static void test_errors(void)
2978 SOCKADDR_IN SockAddr
;
2981 WSASetLastError(NO_ERROR
);
2982 sock
= socket(PF_INET
, SOCK_STREAM
, 0);
2983 ok( (sock
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2984 memset(&SockAddr
, 0, sizeof(SockAddr
));
2985 SockAddr
.sin_family
= AF_INET
;
2986 SockAddr
.sin_port
= htons(6924);
2987 SockAddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2989 ret
= connect(sock
, (PSOCKADDR
)&SockAddr
, sizeof(SockAddr
));
2990 ok( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got: %d\n", ret
);
2991 if (ret
== SOCKET_ERROR
)
2993 err
= WSAGetLastError();
2994 ok( (err
== WSAECONNREFUSED
), "expected WSAECONNREFUSED, got: %d\n", err
);
2999 fd_set set
= {1, {sock
}};
3002 timeval
.tv_usec
= 50000;
3004 ret
= select(1, NULL
, &set
, NULL
, &timeval
);
3005 ok( (ret
== 0), "expected 0 (timeout), got: %d\n", ret
);
3008 ret
= closesocket(sock
);
3009 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3012 static void test_listen(void)
3015 int ret
, acceptc
, olen
= sizeof(acceptc
);
3016 struct sockaddr_in address
;
3018 memset(&address
, 0, sizeof(address
));
3019 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3020 address
.sin_family
= AF_INET
;
3021 address
.sin_port
= htons(SERVERPORT
);
3023 /* invalid socket tests */
3024 SetLastError(0xdeadbeef);
3025 ok ((listen(0, 0) == SOCKET_ERROR
), "listen did not fail\n");
3026 ret
= WSAGetLastError();
3027 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
3029 SetLastError(0xdeadbeef);
3030 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR
), "listen did not fail\n");
3031 ret
= WSAGetLastError();
3032 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
3035 fdA
= socket(AF_INET
, SOCK_STREAM
, 0);
3036 ok ((fdA
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3038 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
3039 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3041 SetLastError(0xdeadbeef);
3042 ok ((listen(fdA
, -2) == SOCKET_ERROR
), "listen did not fail\n");
3043 ret
= WSAGetLastError();
3044 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3046 SetLastError(0xdeadbeef);
3047 ok ((listen(fdA
, 1) == SOCKET_ERROR
), "listen did not fail\n");
3048 ret
= WSAGetLastError();
3049 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3051 SetLastError(0xdeadbeef);
3052 ok ((listen(fdA
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3053 ret
= WSAGetLastError();
3054 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3056 ok (!bind(fdA
, (struct sockaddr
*) &address
, sizeof(address
)), "bind failed\n");
3058 SetLastError(0xdeadbeef);
3059 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
3060 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3063 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
3064 ok (!ret
, "getsockopt failed\n");
3065 ok (acceptc
== 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc
);
3067 ok (!listen(fdA
, 0), "listen failed\n");
3068 ok (!listen(fdA
, SOMAXCONN
), "double listen failed\n");
3071 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
3072 ok (!ret
, "getsockopt failed\n");
3073 ok (acceptc
== 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc
);
3075 SetLastError(0xdeadbeef);
3076 ok ((listen(fdB
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3077 ret
= WSAGetLastError();
3078 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3080 ret
= closesocket(fdB
);
3081 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3083 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
3084 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3086 SetLastError(0xdeadbeef);
3087 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
3088 ret
= WSAGetLastError();
3089 ok (ret
== WSAEADDRINUSE
, "expected 10048, received %d\n", ret
);
3091 ret
= closesocket(fdA
);
3092 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3093 ret
= closesocket(fdB
);
3094 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3097 static void test_select(void)
3099 SOCKET fdRead
, fdWrite
;
3100 fd_set readfds
, writefds
, exceptfds
;
3104 struct timeval select_timeout
;
3105 select_thread_params thread_params
;
3106 HANDLE thread_handle
;
3109 fdRead
= socket(AF_INET
, SOCK_STREAM
, 0);
3110 ok( (fdRead
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3111 fdWrite
= socket(AF_INET
, SOCK_STREAM
, 0);
3112 ok( (fdWrite
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3116 FD_ZERO(&exceptfds
);
3117 FD_SET(fdRead
, &readfds
);
3118 FD_SET(fdWrite
, &writefds
);
3119 FD_SET(fdRead
, &exceptfds
);
3120 FD_SET(fdWrite
, &exceptfds
);
3121 select_timeout
.tv_sec
=0;
3122 select_timeout
.tv_usec
=500;
3125 if (fdWrite
> maxfd
)
3129 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3130 ok ( (ret
== 0), "select should not return any socket handles\n");
3131 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3133 ok ( !FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
3135 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3136 ok ( !FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
3138 ok ((listen(fdWrite
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3139 ret
= closesocket(fdWrite
);
3140 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3142 thread_params
.s
= fdRead
;
3143 thread_params
.ReadKilled
= FALSE
;
3144 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
3145 thread_handle
= CreateThread (NULL
, 0, SelectReadThread
, &thread_params
, 0, &id
);
3146 ok ( (thread_handle
!= NULL
), "CreateThread failed unexpectedly: %d\n", GetLastError());
3148 WaitForSingleObject (server_ready
, INFINITE
);
3150 ret
= closesocket(fdRead
);
3151 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3153 WaitForSingleObject (thread_handle
, 1000);
3154 ok ( (thread_params
.ReadKilled
) ||
3155 broken(thread_params
.ReadKilled
== 0), /*Win98*/
3156 "closesocket did not wakeup select\n");
3157 ret
= recv(fdRead
, &buffer
, 1, MSG_PEEK
);
3158 ok( (ret
== -1), "peek at closed socket expected -1 got %d\n", ret
);
3160 /* Test selecting invalid handles */
3163 FD_ZERO(&exceptfds
);
3166 ret
= select(maxfd
+1, 0, 0, 0, &select_timeout
);
3167 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3168 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3171 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3172 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3173 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3175 FD_SET(INVALID_SOCKET
, &readfds
);
3177 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3178 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3179 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3180 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3183 FD_SET(INVALID_SOCKET
, &writefds
);
3185 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3186 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3187 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3188 ok ( !FD_ISSET(fdRead
, &writefds
), "FD should not be set\n");
3191 FD_SET(INVALID_SOCKET
, &exceptfds
);
3193 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3194 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3195 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3196 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3199 static DWORD WINAPI
AcceptKillThread(void *param
)
3201 select_thread_params
*par
= param
;
3202 struct sockaddr_in address
;
3203 int len
= sizeof(address
);
3204 SOCKET client_socket
;
3206 SetEvent(server_ready
);
3207 client_socket
= accept(par
->s
, (struct sockaddr
*) &address
, &len
);
3208 if (client_socket
!= INVALID_SOCKET
)
3209 closesocket(client_socket
);
3210 par
->ReadKilled
= (client_socket
== INVALID_SOCKET
);
3215 static int CALLBACK
AlwaysDeferConditionFunc(LPWSABUF lpCallerId
, LPWSABUF lpCallerData
, LPQOS pQos
,
3216 LPQOS lpGQOS
, LPWSABUF lpCalleeId
, LPWSABUF lpCalleeData
,
3217 GROUP
*g
, DWORD_PTR dwCallbackData
)
3222 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
)
3225 SOCKET server_socket
;
3227 server_socket
= socket(AF_INET
, SOCK_STREAM
, 0);
3228 if (server_socket
== INVALID_SOCKET
)
3230 trace("error creating server socket: %d\n", WSAGetLastError());
3231 return INVALID_SOCKET
;
3235 ret
= setsockopt(server_socket
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
3238 trace("error setting SO_REUSEADDR: %d\n", WSAGetLastError());
3239 closesocket(server_socket
);
3240 return INVALID_SOCKET
;
3243 ret
= bind(server_socket
, (struct sockaddr
*)addr
, *len
);
3246 trace("error binding server socket: %d\n", WSAGetLastError());
3249 ret
= getsockname(server_socket
, (struct sockaddr
*)addr
, len
);
3252 skip("failed to lookup bind address: %d\n", WSAGetLastError());
3253 closesocket(server_socket
);
3254 return INVALID_SOCKET
;
3257 ret
= listen(server_socket
, 5);
3260 trace("error making server socket listen: %d\n", WSAGetLastError());
3261 closesocket(server_socket
);
3262 return INVALID_SOCKET
;
3265 return server_socket
;
3268 static SOCKET
setup_connector_socket(struct sockaddr_in
*addr
, int len
)
3273 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
3274 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket %d\n", WSAGetLastError());
3276 ret
= connect(connector
, (struct sockaddr
*)addr
, len
);
3277 ok(!ret
, "connecting to accepting socket failed %d\n", WSAGetLastError());
3282 static void test_accept(void)
3285 SOCKET server_socket
, accepted
= INVALID_SOCKET
, connector
;
3286 struct sockaddr_in address
;
3287 SOCKADDR_STORAGE ss
;
3289 select_thread_params thread_params
;
3290 HANDLE thread_handle
= NULL
;
3293 memset(&address
, 0, sizeof(address
));
3294 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3295 address
.sin_family
= AF_INET
;
3297 socklen
= sizeof(address
);
3298 server_socket
= setup_server_socket(&address
, &socklen
);
3299 if (server_socket
== INVALID_SOCKET
)
3301 trace("error creating server socket: %d\n", WSAGetLastError());
3305 connector
= setup_connector_socket(&address
, socklen
);
3306 if (connector
== INVALID_SOCKET
) goto done
;
3308 trace("Blocking accept next\n");
3310 accepted
= WSAAccept(server_socket
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
3311 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
3313 accepted
= accept(server_socket
, NULL
, 0);
3314 ok(accepted
!= INVALID_SOCKET
, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
3316 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
3317 if (server_ready
== INVALID_HANDLE_VALUE
)
3319 trace("error creating event: %d\n", GetLastError());
3323 thread_params
.s
= server_socket
;
3324 thread_params
.ReadKilled
= FALSE
;
3325 thread_handle
= CreateThread(NULL
, 0, AcceptKillThread
, &thread_params
, 0, &id
);
3326 if (thread_handle
== NULL
)
3328 trace("error creating thread: %d\n", GetLastError());
3332 WaitForSingleObject(server_ready
, INFINITE
);
3334 ret
= closesocket(server_socket
);
3337 trace("closesocket failed: %d\n", WSAGetLastError());
3341 WaitForSingleObject(thread_handle
, 1000);
3342 ok(thread_params
.ReadKilled
|| broken(!thread_params
.ReadKilled
) /* Win98/ME, after accept */,
3343 "closesocket did not wakeup accept\n");
3345 closesocket(accepted
);
3346 closesocket(connector
);
3347 accepted
= connector
= server_socket
= INVALID_SOCKET
;
3349 socklen
= sizeof(address
);
3350 server_socket
= setup_server_socket(&address
, &socklen
);
3351 if (server_socket
== INVALID_SOCKET
) goto done
;
3353 connector
= setup_connector_socket(&address
, socklen
);
3354 if (connector
== INVALID_SOCKET
) goto done
;
3357 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
3358 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
3359 ok(!socklen
, "got %d\n", socklen
);
3360 closesocket(connector
);
3361 connector
= INVALID_SOCKET
;
3363 socklen
= sizeof(address
);
3364 connector
= setup_connector_socket(&address
, socklen
);
3365 if (connector
== INVALID_SOCKET
) goto done
;
3367 accepted
= WSAAccept(server_socket
, NULL
, NULL
, NULL
, 0);
3368 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3369 closesocket(accepted
);
3370 closesocket(connector
);
3371 accepted
= connector
= INVALID_SOCKET
;
3373 socklen
= sizeof(address
);
3374 connector
= setup_connector_socket(&address
, socklen
);
3375 if (connector
== INVALID_SOCKET
) goto done
;
3377 socklen
= sizeof(ss
);
3378 memset(&ss
, 0, sizeof(ss
));
3379 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
3380 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3381 ok(socklen
!= sizeof(ss
), "unexpected length\n");
3382 ok(ss
.ss_family
, "family not set\n");
3383 closesocket(accepted
);
3384 closesocket(connector
);
3385 accepted
= connector
= INVALID_SOCKET
;
3387 socklen
= sizeof(address
);
3388 connector
= setup_connector_socket(&address
, socklen
);
3389 if (connector
== INVALID_SOCKET
) goto done
;
3392 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
3393 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
3394 ok(!socklen
, "got %d\n", socklen
);
3395 closesocket(connector
);
3396 accepted
= connector
= INVALID_SOCKET
;
3398 socklen
= sizeof(address
);
3399 connector
= setup_connector_socket(&address
, socklen
);
3400 if (connector
== INVALID_SOCKET
) goto done
;
3402 accepted
= accept(server_socket
, NULL
, NULL
);
3403 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3404 closesocket(accepted
);
3405 closesocket(connector
);
3406 accepted
= connector
= INVALID_SOCKET
;
3408 socklen
= sizeof(address
);
3409 connector
= setup_connector_socket(&address
, socklen
);
3410 if (connector
== INVALID_SOCKET
) goto done
;
3412 socklen
= sizeof(ss
);
3413 memset(&ss
, 0, sizeof(ss
));
3414 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
3415 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3416 ok(socklen
!= sizeof(ss
), "unexpected length\n");
3417 ok(ss
.ss_family
, "family not set\n");
3420 if (accepted
!= INVALID_SOCKET
)
3421 closesocket(accepted
);
3422 if (connector
!= INVALID_SOCKET
)
3423 closesocket(connector
);
3424 if (thread_handle
!= NULL
)
3425 CloseHandle(thread_handle
);
3426 if (server_ready
!= INVALID_HANDLE_VALUE
)
3427 CloseHandle(server_ready
);
3428 if (server_socket
!= INVALID_SOCKET
)
3429 closesocket(server_socket
);
3432 static void test_extendedSocketOptions(void)
3436 struct sockaddr_in sa
;
3437 int sa_len
= sizeof(struct sockaddr_in
);
3438 int optval
, optlen
= sizeof(int), ret
;
3442 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
3443 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
3447 memset(&sa
, 0, sa_len
);
3449 sa
.sin_family
= AF_INET
;
3450 sa
.sin_port
= htons(0);
3451 sa
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
3453 if((sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
3454 trace("Creating the socket failed: %d\n", WSAGetLastError());
3459 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
3460 trace("Failed to bind socket: %d\n", WSAGetLastError());
3466 ret
= getsockopt(sock
, SOL_SOCKET
, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3468 ok(ret
== 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret
);
3469 ok((optval
== 65507) || (optval
== 65527),
3470 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval
);
3472 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
3473 SetLastError(0xdeadbeef);
3474 optval
= 0xdeadbeef;
3475 optlen
= sizeof(int);
3476 ret
= getsockopt(sock
, 0xffffffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3477 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3478 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3479 ret
, WSAGetLastError(), optval
, optval
);
3481 /* more invalid values for level */
3482 SetLastError(0xdeadbeef);
3483 optval
= 0xdeadbeef;
3484 optlen
= sizeof(int);
3485 ret
= getsockopt(sock
, 0x1234ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3486 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3487 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3488 ret
, WSAGetLastError(), optval
, optval
);
3490 SetLastError(0xdeadbeef);
3491 optval
= 0xdeadbeef;
3492 optlen
= sizeof(int);
3493 ret
= getsockopt(sock
, 0x8000ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3494 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3495 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3496 ret
, WSAGetLastError(), optval
, optval
);
3498 SetLastError(0xdeadbeef);
3499 optval
= 0xdeadbeef;
3500 optlen
= sizeof(int);
3501 ret
= getsockopt(sock
, 0x00008000, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3502 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3503 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3504 ret
, WSAGetLastError(), optval
, optval
);
3506 SetLastError(0xdeadbeef);
3507 optval
= 0xdeadbeef;
3508 optlen
= sizeof(int);
3509 ret
= getsockopt(sock
, 0x00000800, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3510 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3511 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3512 ret
, WSAGetLastError(), optval
, optval
);
3514 SetLastError(0xdeadbeef);
3515 optlen
= sizeof(LINGER
);
3516 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
3517 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOPROTOOPT
),
3518 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
3519 ret
, WSAGetLastError());
3522 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
3523 trace("Creating the socket failed: %d\n", WSAGetLastError());
3528 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
3529 trace("Failed to bind socket: %d\n", WSAGetLastError());
3535 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
3536 ok(ret
== 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret
);
3538 optlen
= sizeof(BOOL
);
3539 ret
= getsockopt(sock
, SOL_SOCKET
, SO_DONTLINGER
, (char *)&bool_opt_val
, &optlen
);
3540 ok(ret
== 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret
);
3541 ok((linger_val
.l_onoff
&& !bool_opt_val
) || (!linger_val
.l_onoff
&& bool_opt_val
),
3542 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
3543 bool_opt_val
, linger_val
.l_onoff
);
3549 static void test_getsockname(void)
3553 struct sockaddr_in sa_set
, sa_get
;
3554 int sa_set_len
= sizeof(struct sockaddr_in
);
3555 int sa_get_len
= sa_set_len
;
3556 static const unsigned char null_padding
[] = {0,0,0,0,0,0,0,0};
3559 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
3560 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
3564 memset(&sa_set
, 0, sa_set_len
);
3566 sa_set
.sin_family
= AF_INET
;
3567 sa_set
.sin_port
= htons(0);
3568 sa_set
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
3570 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
3571 trace("Creating the socket failed: %d\n", WSAGetLastError());
3577 if (getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) == 0)
3578 ok(0, "getsockname on unbound socket should fail\n");
3580 ok(WSAGetLastError() == WSAEINVAL
, "getsockname on unbound socket "
3581 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL
);
3582 ok(memcmp(&sa_get
, &sa_set
, sizeof(sa_get
)) == 0,
3583 "failed getsockname modified sockaddr when it shouldn't\n");
3586 if(bind(sock
, (struct sockaddr
*) &sa_set
, sa_set_len
) < 0){
3587 trace("Failed to bind socket: %d\n", WSAGetLastError());
3593 if(getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) != 0){
3594 trace("Failed to call getsockname: %d\n", WSAGetLastError());
3600 ret
= memcmp(sa_get
.sin_zero
, null_padding
, 8);
3601 ok(ret
== 0 || broken(ret
!= 0), /* NT4 */
3602 "getsockname did not zero the sockaddr_in structure\n");
3608 static void test_dns(void)
3619 h
= gethostbyname("");
3620 ok(h
!= NULL
, "gethostbyname(\"\") failed with %d\n", h_errno
);
3622 /* Use an address with valid alias names if possible */
3623 h
= gethostbyname("source.winehq.org");
3626 skip("Can't test the hostent structure because gethostbyname failed\n");
3630 /* The returned struct must be allocated in a very strict way. First we need to
3631 * count how many aliases there are because they must be located right after
3632 * the struct hostent size. Knowing the amount of aliases we know the exact
3633 * location of the first IP returned. Rule valid for >= XP, for older OS's
3634 * it's somewhat the opposite. */
3636 if(h
->h_addr_list
== addr
.mem
) /* <= W2K */
3638 win_skip("Skipping hostent tests since this OS is unsupported\n");
3642 ok(h
->h_aliases
== addr
.mem
,
3643 "hostent->h_aliases should be in %p, it is in %p\n", addr
.mem
, h
->h_aliases
);
3645 for(ptr
= h
->h_aliases
, acount
= 1; *ptr
; ptr
++) acount
++;
3646 addr
.chr
+= sizeof(*ptr
) * acount
;
3647 ok(h
->h_addr_list
== addr
.mem
,
3648 "hostent->h_addr_list should be in %p, it is in %p\n", addr
.mem
, h
->h_addr_list
);
3650 for(ptr
= h
->h_addr_list
, acount
= 1; *ptr
; ptr
++) acount
++;
3652 addr
.chr
+= sizeof(*ptr
) * acount
;
3653 ok(h
->h_addr_list
[0] == addr
.mem
,
3654 "hostent->h_addr_list[0] should be in %p, it is in %p\n", addr
.mem
, h
->h_addr_list
[0]);
3657 /* Our winsock headers don't define gethostname because it conflicts with the
3658 * definition in unistd.h. Define it here to get rid of the warning. */
3660 int WINAPI
gethostname(char *name
, int namelen
);
3662 static void test_gethostbyname_hack(void)
3666 static BYTE loopback
[] = {127, 0, 0, 1};
3667 static BYTE magic_loopback
[] = {127, 12, 34, 56};
3670 ret
= gethostname(name
, 256);
3671 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
3673 he
= gethostbyname("localhost");
3674 ok(he
!= NULL
, "gethostbyname(\"localhost\") failed: %d\n", h_errno
);
3677 if(he
->h_length
!= 4)
3679 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
3683 ok(memcmp(he
->h_addr_list
[0], loopback
, he
->h_length
) == 0,
3684 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
3685 he
->h_addr_list
[0][0], he
->h_addr_list
[0][1], he
->h_addr_list
[0][2],
3686 he
->h_addr_list
[0][3]);
3689 if(strcmp(name
, "localhost") == 0)
3691 skip("hostname seems to be \"localhost\", skipping test.\n");
3696 he
= gethostbyname(name
);
3697 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, h_errno
);
3700 if(he
->h_length
!= 4)
3702 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
3706 if (he
->h_addr_list
[0][0] == 127)
3708 ok(memcmp(he
->h_addr_list
[0], magic_loopback
, he
->h_length
) == 0,
3709 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
3710 name
, he
->h_addr_list
[0][0], he
->h_addr_list
[0][1],
3711 he
->h_addr_list
[0][2], he
->h_addr_list
[0][3]);
3715 gethostbyname("nonexistent.winehq.org");
3716 /* Don't check for the return value, as some braindead ISPs will kindly
3717 * resolve nonexistent host names to addresses of the ISP's spam pages. */
3720 static void test_inet_addr(void)
3724 addr
= inet_addr(NULL
);
3725 ok(addr
== INADDR_NONE
, "inet_addr succeeded unexpectedly\n");
3728 static void test_addr_to_print(void)
3734 struct in6_addr in6
;
3736 u_long addr0_Num
= 0x00000000;
3737 PCSTR addr0_Str
= "0.0.0.0";
3738 u_long addr1_Num
= 0x20201015;
3739 PCSTR addr1_Str
= "21.16.32.32";
3740 u_char addr2_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
3741 PCSTR addr2_Str
= "::fffe:cc98:bd74";
3742 u_char addr3_Num
[16] = {0x20,0x30,0xa4,0xb1};
3743 PCSTR addr3_Str
= "2030:a4b1::";
3744 u_char addr4_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
3745 PCSTR addr4_Str
= "::204.152.189.116";
3747 /* Test IPv4 addresses */
3748 in
.s_addr
= addr0_Num
;
3750 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
3751 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
3752 ok(!strcmp(pdst
, addr0_Str
),"Address %s != %s\n", pdst
, addr0_Str
);
3754 /* Test that inet_ntoa and inet_ntop return the same value */
3755 in
.S_un
.S_addr
= addr1_Num
;
3756 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
3757 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
3758 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
3760 /* InetNtop became available in Vista and Win2008 */
3763 win_skip("InetNtop not present, not executing tests\n");
3767 /* Second part of test */
3768 pdst
= pInetNtop(AF_INET
,(void*)&in
.s_addr
, dst
, sizeof(dst
));
3769 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst
);
3770 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
3772 /* Test invalid parm conditions */
3773 pdst
= pInetNtop(1, (void*)&in
.s_addr
, dst
, sizeof(dst
));
3774 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3775 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "Should be WSAEAFNOSUPPORT\n");
3777 /* Test Null destination */
3779 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, NULL
, sizeof(dst
));
3780 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3781 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
3782 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3784 /* Test zero length passed */
3787 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 0);
3788 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3789 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
3790 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3792 /* Test length one shorter than the address length */
3795 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 6);
3796 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3797 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
3798 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3800 /* Test longer length is ok */
3803 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, sizeof(dst
)+1);
3804 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
3805 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
3807 /* Test the IPv6 addresses */
3809 /* Test an zero prefixed IPV6 address */
3810 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
3811 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
3812 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
3813 ok(!strcmp(pdst
, addr2_Str
),"Address %s != %s\n", pdst
, addr2_Str
);
3815 /* Test an zero suffixed IPV6 address */
3816 memcpy(in6
.s6_addr
, addr3_Num
, sizeof(addr3_Num
));
3817 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
3818 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
3819 ok(!strcmp(pdst
, addr3_Str
),"Address %s != %s\n", pdst
, addr3_Str
);
3821 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
3822 memcpy(in6
.s6_addr
, addr4_Num
, sizeof(addr4_Num
));
3823 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
3824 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
3825 ok(!strcmp(pdst
, addr4_Str
),"Address %s != %s\n", pdst
, addr4_Str
);
3827 /* Test invalid parm conditions */
3828 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
3830 /* Test Null destination */
3832 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, NULL
, sizeof(dst6
));
3833 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3834 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
3835 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3837 /* Test zero length passed */
3840 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 0);
3841 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3842 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
3843 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3845 /* Test length one shorter than the address length */
3848 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 16);
3849 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3850 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
3851 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3853 /* Test longer length is ok */
3856 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 18);
3857 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
3860 static void test_ioctlsocket(void)
3863 struct tcp_keepalive kalive
;
3865 static const LONG cmds
[] = {FIONBIO
, FIONREAD
, SIOCATMARK
};
3869 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3870 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
3871 if(sock
== INVALID_SOCKET
)
3873 skip("Can't continue without a socket.\n");
3877 for(i
= 0; i
< sizeof(cmds
)/sizeof(cmds
[0]); i
++)
3879 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
3880 ret
= ioctlsocket(sock
, cmds
[i
], (u_long
*)1);
3881 ok(ret
== SOCKET_ERROR
, "ioctlsocket succeeded unexpectedly\n");
3882 ret
= WSAGetLastError();
3883 ok(ret
== WSAEFAULT
, "expected WSAEFAULT, got %d instead\n", ret
);
3886 /* A fresh and not connected socket has no urgent data, this test shows
3887 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
3889 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
3890 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
3891 ok(arg
, "SIOCATMARK expected a non-zero value\n");
3893 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
3895 ret
= setsockopt(sock
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
3896 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
3898 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
3899 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
3900 ok(arg
, "SIOCATMARK expected a non-zero value\n");
3902 /* disable SO_OOBINLINE and get the same old behavior */
3904 ret
= setsockopt(sock
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
3905 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
3907 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
3908 ok(arg
, "SIOCATMARK expected a non-zero value\n");
3910 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &arg
, 0, NULL
, 0, &arg
, NULL
, NULL
);
3911 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
3912 ret
= WSAGetLastError();
3913 ok(ret
== WSAEFAULT
|| broken(ret
== WSAEINVAL
), "expected WSAEFAULT, got %d instead\n", ret
);
3915 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, NULL
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3916 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
3917 ret
= WSAGetLastError();
3918 ok(ret
== WSAEFAULT
|| broken(ret
== WSAEINVAL
), "expected WSAEFAULT, got %d instead\n", ret
);
3920 /* broken used to catch W95, W98, NT4 */
3921 make_keepalive(kalive
, 0, 0, 0);
3922 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3923 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
3925 make_keepalive(kalive
, 1, 0, 0);
3926 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3927 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
3929 make_keepalive(kalive
, 1, 1000, 1000);
3930 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3931 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
3933 make_keepalive(kalive
, 1, 10000, 10000);
3934 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3935 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
3937 make_keepalive(kalive
, 1, 100, 100);
3938 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3939 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
3941 make_keepalive(kalive
, 0, 100, 100);
3942 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
3943 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
3948 static BOOL drain_pause
= FALSE
;
3949 static DWORD WINAPI
drain_socket_thread(LPVOID arg
)
3952 SOCKET sock
= *(SOCKET
*)arg
;
3955 while ((ret
= recv(sock
, buffer
, sizeof(buffer
), 0)) != 0)
3959 if (WSAGetLastError() == WSAEWOULDBLOCK
)
3963 FD_SET(sock
, &readset
);
3964 select(sock
+1, &readset
, NULL
, NULL
, NULL
);
3975 static void test_send(void)
3977 SOCKET src
= INVALID_SOCKET
;
3978 SOCKET dst
= INVALID_SOCKET
;
3979 HANDLE hThread
= NULL
;
3980 const int buflen
= 1024*1024;
3981 char *buffer
= NULL
;
3982 int ret
, i
, zero
= 0;
3986 DWORD id
, bytes_sent
, dwRet
;
3988 memset(&ov
, 0, sizeof(ov
));
3990 if (tcp_socketpair(&src
, &dst
) != 0)
3992 ok(0, "creating socket pair failed, skipping test\n");
3996 set_blocking(dst
, FALSE
);
3997 /* force disable buffering so we can get a pending overlapped request */
3998 ret
= setsockopt(dst
, SOL_SOCKET
, SO_SNDBUF
, (char *) &zero
, sizeof(zero
));
3999 ok(!ret
, "setsockopt SO_SNDBUF failed: %d - %d\n", ret
, GetLastError());
4001 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
4002 if (hThread
== NULL
)
4004 ok(0, "CreateThread failed, error %d\n", GetLastError());
4008 buffer
= HeapAlloc(GetProcessHeap(), 0, buflen
);
4011 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
4015 /* fill the buffer with some nonsense */
4016 for (i
= 0; i
< buflen
; ++i
)
4018 buffer
[i
] = (char) i
;
4021 ret
= send(src
, buffer
, buflen
, 0);
4023 ok(ret
== buflen
, "send should have sent %d bytes, but it only sent %d\n", buflen
, ret
);
4025 ok(0, "send failed, error %d\n", WSAGetLastError());
4030 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
4031 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
4036 WSASetLastError(12345);
4037 ret
= WSASend(dst
, &buf
, 1, &bytes_sent
, 0, &ov
, NULL
);
4038 ok((ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
) || broken(bytes_sent
== buflen
),
4039 "Failed to start overlapped send %d - %d - %d/%d\n", ret
, WSAGetLastError(), bytes_sent
, buflen
);
4041 /* don't check for completion yet, we may need to drain the buffer while still sending */
4042 set_blocking(src
, FALSE
);
4043 for (i
= 0; i
< buflen
; ++i
)
4047 ret
= recv(src
, buffer
, 1, 0);
4048 while (ret
== SOCKET_ERROR
&& GetLastError() == WSAEWOULDBLOCK
&& j
< 100)
4052 ret
= recv(src
, buffer
, 1, 0);
4055 ok(ret
== 1, "Failed to receive data %d - %d (got %d/%d)\n", ret
, GetLastError(), i
, buflen
);
4059 ok(buffer
[0] == (char) i
, "Received bad data at position %d\n", i
);
4062 dwRet
= WaitForSingleObject(ov
.hEvent
, 1000);
4063 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
4064 if (dwRet
== WAIT_OBJECT_0
)
4066 bret
= GetOverlappedResult((HANDLE
)dst
, &ov
, &bytes_sent
, FALSE
);
4067 ok((bret
&& bytes_sent
== buflen
) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
4068 "Got %d instead of %d (%d - %d)\n", bytes_sent
, buflen
, bret
, GetLastError());
4071 WSASetLastError(12345);
4072 ret
= WSASend(INVALID_SOCKET
, &buf
, 1, NULL
, 0, &ov
, NULL
);
4073 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
4074 "WSASend failed %d - %d\n", ret
, WSAGetLastError());
4076 WSASetLastError(12345);
4077 ret
= WSASend(dst
, &buf
, 1, NULL
, 0, &ov
, NULL
);
4078 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
,
4079 "Failed to start overlapped send %d - %d\n", ret
, WSAGetLastError());
4082 if (src
!= INVALID_SOCKET
)
4084 if (dst
!= INVALID_SOCKET
)
4086 if (hThread
!= NULL
)
4087 CloseHandle(hThread
);
4089 CloseHandle(ov
.hEvent
);
4090 HeapFree(GetProcessHeap(), 0, buffer
);
4093 typedef struct async_message
4097 struct async_message
*next
;
4100 static struct async_message
*messages_received
;
4102 #define WM_SOCKET (WM_USER+100)
4103 static LRESULT CALLBACK
ws2_test_WndProc(HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
4105 struct async_message
*message
;
4110 message
= HeapAlloc(GetProcessHeap(), 0, sizeof(*message
));
4111 message
->socket
= (SOCKET
) wparam
;
4112 message
->lparam
= lparam
;
4113 message
->next
= NULL
;
4115 if (messages_received
)
4117 struct async_message
*last
= messages_received
;
4118 while (last
->next
) last
= last
->next
;
4119 last
->next
= message
;
4122 messages_received
= message
;
4126 return DefWindowProcA(hwnd
, msg
, wparam
, lparam
);
4129 static void get_event_details(int event
, int *bit
, char *name
)
4134 if (bit
) *bit
= FD_ACCEPT_BIT
;
4135 if (name
) strcpy(name
, "FD_ACCEPT");
4138 if (bit
) *bit
= FD_CONNECT_BIT
;
4139 if (name
) strcpy(name
, "FD_CONNECT");
4142 if (bit
) *bit
= FD_READ_BIT
;
4143 if (name
) strcpy(name
, "FD_READ");
4146 if (bit
) *bit
= FD_OOB_BIT
;
4147 if (name
) strcpy(name
, "FD_OOB");
4150 if (bit
) *bit
= FD_WRITE_BIT
;
4151 if (name
) strcpy(name
, "FD_WRITE");
4154 if (bit
) *bit
= FD_CLOSE_BIT
;
4155 if (name
) strcpy(name
, "FD_CLOSE");
4159 if (name
) sprintf(name
, "bad%x", event
);
4163 static const char *dbgstr_event_seq(const LPARAM
*seq
)
4165 static char message
[1024];
4173 get_event_details(WSAGETSELECTEVENT(*seq
), NULL
, name
);
4174 len
+= sprintf(message
+ len
, "%s(%d) ", name
, WSAGETSELECTERROR(*seq
));
4178 strcpy( message
+ len
, "]" );
4182 static char *dbgstr_event_seq_result(SOCKET s
, WSANETWORKEVENTS
*netEvents
)
4184 static char message
[1024];
4185 struct async_message
*curr
= messages_received
;
4186 int index
, error
, bit
= 0;
4196 if (bit
>= FD_MAX_EVENTS
) break;
4197 if ( !(netEvents
->lNetworkEvents
& (1 << bit
)) )
4202 get_event_details(1 << bit
, &index
, name
);
4203 error
= netEvents
->iErrorCode
[index
];
4209 if (curr
->socket
!= s
)
4214 get_event_details(WSAGETSELECTEVENT(curr
->lparam
), NULL
, name
);
4215 error
= WSAGETSELECTERROR(curr
->lparam
);
4219 len
+= sprintf(message
+ len
, "%s(%d) ", name
, error
);
4222 strcpy( message
+ len
, "]" );
4226 static void flush_events(SOCKET s
, HANDLE hEvent
)
4228 WSANETWORKEVENTS netEvents
;
4229 struct async_message
*prev
= NULL
, *curr
= messages_received
;
4233 if (hEvent
!= INVALID_HANDLE_VALUE
)
4235 dwRet
= WaitForSingleObject(hEvent
, 100);
4236 if (dwRet
== WAIT_OBJECT_0
)
4238 ret
= WSAEnumNetworkEvents(s
, hEvent
, &netEvents
);
4240 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
4247 if (curr
->socket
== s
)
4249 if (prev
) prev
->next
= curr
->next
;
4250 else messages_received
= curr
->next
;
4252 HeapFree(GetProcessHeap(), 0, curr
);
4254 if (prev
) curr
= prev
->next
;
4255 else curr
= messages_received
;
4266 static int match_event_sequence(SOCKET s
, WSANETWORKEVENTS
*netEvents
, const LPARAM
*seq
)
4268 int event
, index
, error
, events
;
4269 struct async_message
*curr
;
4273 events
= netEvents
->lNetworkEvents
;
4276 event
= WSAGETSELECTEVENT(*seq
);
4277 error
= WSAGETSELECTERROR(*seq
);
4278 get_event_details(event
, &index
, NULL
);
4280 if (!(events
& event
) && index
!= -1)
4282 if (events
& event
&& index
!= -1)
4284 if (netEvents
->iErrorCode
[index
] != error
)
4295 curr
= messages_received
;
4298 if (curr
->socket
== s
)
4300 if (!*seq
) return 0;
4301 if (*seq
!= curr
->lparam
) return 0;
4312 /* checks for a sequence of events, (order only checked if window is used) */
4313 static void ok_event_sequence(SOCKET s
, HANDLE hEvent
, const LPARAM
*seq
, const LPARAM
**broken_seqs
, int completelyBroken
)
4316 WSANETWORKEVENTS events
, *netEvents
= NULL
;
4320 if (hEvent
!= INVALID_HANDLE_VALUE
)
4322 netEvents
= &events
;
4324 dwRet
= WaitForSingleObject(hEvent
, 200);
4325 if (dwRet
== WAIT_OBJECT_0
)
4327 ret
= WSAEnumNetworkEvents(s
, hEvent
, netEvents
);
4330 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
4335 memset(netEvents
, 0, sizeof(*netEvents
));
4340 /* Run the message loop a little */
4341 while (PeekMessageA( &msg
, 0, 0, 0, PM_REMOVE
))
4343 DispatchMessageA(&msg
);
4347 if (match_event_sequence(s
, netEvents
, seq
))
4349 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq
));
4350 flush_events(s
, hEvent
);
4356 for (; *broken_seqs
; broken_seqs
++)
4358 if (match_event_sequence(s
, netEvents
, *broken_seqs
))
4360 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s
, netEvents
), dbgstr_event_seq(seq
));
4361 flush_events(s
, hEvent
);
4367 winetest_ok(broken(completelyBroken
), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq
),
4368 dbgstr_event_seq_result(s
, netEvents
));
4369 flush_events(s
, hEvent
);
4372 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
4374 static void test_events(int useMessages
)
4376 SOCKET server
= INVALID_SOCKET
;
4377 SOCKET src
= INVALID_SOCKET
, src2
= INVALID_SOCKET
;
4378 SOCKET dst
= INVALID_SOCKET
, dst2
= INVALID_SOCKET
;
4379 struct sockaddr_in addr
;
4380 HANDLE hThread
= NULL
;
4381 HANDLE hEvent
= INVALID_HANDLE_VALUE
, hEvent2
= INVALID_HANDLE_VALUE
;
4382 WNDCLASSEXA wndclass
;
4384 char *buffer
= NULL
;
4385 int bufferSize
= 1024*1024;
4389 DWORD bytesReturned
;
4395 static char szClassName
[] = "wstestclass";
4396 const LPARAM
*broken_seq
[3];
4397 static const LPARAM empty_seq
[] = { 0 };
4398 static const LPARAM close_seq
[] = { WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
4399 static const LPARAM write_seq
[] = { WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
4400 static const LPARAM read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
4401 static const LPARAM oob_seq
[] = { WSAMAKESELECTREPLY(FD_OOB
, 0), 0 };
4402 static const LPARAM connect_seq
[] = { WSAMAKESELECTREPLY(FD_CONNECT
, 0),
4403 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
4404 static const LPARAM read_read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
4405 WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
4406 static const LPARAM read_write_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
4407 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
4408 static const LPARAM read_close_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
4409 WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
4411 memset(&ov
, 0, sizeof(ov
));
4412 memset(&ov2
, 0, sizeof(ov2
));
4414 /* don't use socketpair, we want connection event */
4415 src
= socket(AF_INET
, SOCK_STREAM
, 0);
4416 if (src
== INVALID_SOCKET
)
4418 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4422 ret
= set_blocking(src
, TRUE
);
4423 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
4425 src2
= socket(AF_INET
, SOCK_STREAM
, 0);
4426 if (src2
== INVALID_SOCKET
)
4428 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4432 ret
= set_blocking(src2
, TRUE
);
4433 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
4436 if (getsockopt(src
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&bret
, &len
) == SOCKET_ERROR
)
4438 ok(0, "failed to get oobinline status, %d\n", GetLastError());
4441 ok(bret
== FALSE
, "OOB not inline\n");
4445 trace("Event test using messages\n");
4447 wndclass
.cbSize
= sizeof(wndclass
);
4448 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
4449 wndclass
.lpfnWndProc
= ws2_test_WndProc
;
4450 wndclass
.cbClsExtra
= 0;
4451 wndclass
.cbWndExtra
= 0;
4452 wndclass
.hInstance
= GetModuleHandleA(NULL
);
4453 wndclass
.hIcon
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
4454 wndclass
.hIconSm
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
4455 wndclass
.hCursor
= LoadCursorA(NULL
, (LPCSTR
)IDC_ARROW
);
4456 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
4457 wndclass
.lpszClassName
= szClassName
;
4458 wndclass
.lpszMenuName
= NULL
;
4459 RegisterClassExA(&wndclass
);
4461 hWnd
= CreateWindowA(szClassName
, "WS2Test", WS_OVERLAPPEDWINDOW
,
4462 0, 0, 500, 500, NULL
, NULL
, GetModuleHandleA(NULL
), NULL
);
4465 ok(0, "failed to create window: %d\n", GetLastError());
4469 ret
= WSAAsyncSelect(src
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
4472 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
4476 ok(set_blocking(src
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
4477 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
4479 ret
= WSAAsyncSelect(src2
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
4482 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
4486 ok(set_blocking(src2
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
4487 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
4491 trace("Event test using events\n");
4493 hEvent
= WSACreateEvent();
4494 if (hEvent
== INVALID_HANDLE_VALUE
)
4496 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
4500 hEvent2
= WSACreateEvent();
4501 if (hEvent2
== INVALID_HANDLE_VALUE
)
4503 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
4507 ret
= WSAEventSelect(src
, hEvent
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
4510 ok(0, "WSAEventSelect failed, error %d\n", ret
);
4514 ok(set_blocking(src
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
4515 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
4517 ret
= WSAEventSelect(src2
, hEvent2
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
4520 ok(0, "WSAEventSelect failed, error %d\n", ret
);
4524 ok(set_blocking(src2
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
4525 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
4528 server
= socket(AF_INET
, SOCK_STREAM
, 0);
4529 if (server
== INVALID_SOCKET
)
4531 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4535 memset(&addr
, 0, sizeof(addr
));
4536 addr
.sin_family
= AF_INET
;
4537 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4538 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
4541 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4546 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
4549 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4553 ret
= listen(server
, 2);
4556 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4560 ret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
4561 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
4563 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4567 ret
= connect(src2
, (struct sockaddr
*)&addr
, sizeof(addr
));
4568 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
4570 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4575 dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
4576 if (dst
== INVALID_SOCKET
)
4578 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4583 dst2
= accept(server
, (struct sockaddr
*)&addr
, &len
);
4584 if (dst2
== INVALID_SOCKET
)
4586 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4590 closesocket(server
);
4591 server
= INVALID_SOCKET
;
4593 /* On Windows it seems when a non-blocking socket sends to a
4594 blocking socket on the same host, the send() is BLOCKING,
4595 so make both sockets non-blocking. src is already non-blocking
4596 from the async select */
4598 if (set_blocking(dst
, FALSE
))
4600 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
4604 buffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, bufferSize
);
4607 ok(0, "could not allocate memory for test\n");
4611 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
4612 if (ov
.hEvent
== NULL
)
4614 ok(0, "could not create event object, errno = %d\n", GetLastError());
4618 ov2
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
4619 if (ov2
.hEvent
== NULL
)
4621 ok(0, "could not create event object, errno = %d\n", GetLastError());
4625 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
4626 ok_event_seq(src
, hEvent
, connect_seq
, NULL
, 1);
4627 ok_event_seq(src2
, hEvent2
, connect_seq
, NULL
, 1);
4628 /* broken on all windows - FD_CONNECT error is garbage */
4630 /* Test simple send/recv */
4631 ret
= send(dst
, buffer
, 100, 0);
4632 ok(ret
== 100, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4633 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
4635 ret
= recv(src
, buffer
, 1, MSG_PEEK
);
4636 ok(ret
== 1, "Failed to peek at recv buffer %d err %d\n", ret
, GetLastError());
4637 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
4639 ret
= recv(src
, buffer
, 50, 0);
4640 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
4641 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
4643 ret
= recv(src
, buffer
, 50, 0);
4644 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
4645 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
4647 /* fun fact - events are re-enabled even on failure, but only for messages */
4648 ret
= send(dst
, "1", 1, 0);
4649 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4650 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
4652 ret
= recv(src
, buffer
, -1, 0);
4653 ok(ret
== SOCKET_ERROR
&& (GetLastError() == WSAEFAULT
|| GetLastError() == WSAENOBUFS
),
4654 "Failed to recv buffer %d err %d\n", ret
, GetLastError());
4657 broken_seq
[0] = empty_seq
; /* win9x */
4658 broken_seq
[1] = NULL
;
4659 todo_wine
ok_event_seq(src
, hEvent
, read_seq
, broken_seq
, 0);
4662 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
4664 ret
= recv(src
, buffer
, 1, 0);
4665 ok(ret
== 1, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
4666 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
4668 /* Interaction with overlapped */
4669 bufs
.len
= sizeof(char);
4671 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
4672 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
4673 "WSARecv failed - %d error %d\n", ret
, GetLastError());
4675 bufs
.len
= sizeof(char);
4676 bufs
.buf
= buffer
+1;
4677 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov2
, NULL
);
4678 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
4679 "WSARecv failed - %d error %d\n", ret
, GetLastError());
4681 ret
= send(dst
, "12", 2, 0);
4682 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4683 broken_seq
[0] = read_read_seq
; /* win9x */
4684 broken_seq
[1] = NULL
;
4685 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
4687 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
4688 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
4689 if (dwRet
== WAIT_OBJECT_0
)
4691 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
4692 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
4693 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
4694 ok(buffer
[0] == '1', "Got %c instead of 1\n", buffer
[0]);
4697 dwRet
= WaitForSingleObject(ov2
.hEvent
, 100);
4698 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
4699 if (dwRet
== WAIT_OBJECT_0
)
4701 bret
= GetOverlappedResult((HANDLE
)src
, &ov2
, &bytesReturned
, FALSE
);
4702 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
4703 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
4704 ok(buffer
[1] == '2', "Got %c instead of 2\n", buffer
[1]);
4707 ret
= send(dst
, "1", 1, 0);
4708 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4709 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
4711 ret
= recv(src
, buffer
, 1, 0);
4712 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
4713 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
4715 /* Notifications are delivered as soon as possible, blocked only on
4716 * async requests on the same type */
4717 bufs
.len
= sizeof(char);
4719 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
4720 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
4721 "WSARecv failed - %d error %d\n", ret
, GetLastError());
4724 ret
= send(dst
, "1", 1, MSG_OOB
);
4725 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4726 ok_event_seq(src
, hEvent
, oob_seq
, NULL
, 0);
4729 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
4730 ok(dwRet
== WAIT_TIMEOUT
, "OOB message activated read?: %d - %d\n", dwRet
, GetLastError());
4732 ret
= send(dst
, "2", 1, 0);
4733 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4734 broken_seq
[0] = read_seq
; /* win98 */
4735 broken_seq
[1] = NULL
;
4736 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
4738 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
4739 ok(dwRet
== WAIT_OBJECT_0
|| broken(dwRet
== WAIT_TIMEOUT
),
4740 "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
4741 if (dwRet
== WAIT_OBJECT_0
)
4743 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
4744 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
4745 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
4746 ok(buffer
[0] == '2', "Got %c instead of 2\n", buffer
[0]);
4748 else if (dwRet
== WAIT_TIMEOUT
)
4750 /* this happens on win98. We get an FD_READ later on the next test */
4751 CancelIo((HANDLE
) src
);
4755 ret
= recv(src
, buffer
, 1, MSG_OOB
);
4756 todo_wine
ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
4757 /* We get OOB notification, but no data on wine */
4758 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
4761 /* Flood the send queue */
4762 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
4763 if (hThread
== NULL
)
4765 ok(0, "CreateThread failed, error %d\n", GetLastError());
4769 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
4770 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
4772 /* Now if we send a ton of data and the 'server' does not drain it fast
4773 * enough (set drain_pause to be sure), the socket send buffer will only
4774 * take some of it, and we will get a short write. This will trigger
4775 * another FD_WRITE event as soon as data is sent and more space becomes
4776 * available, but not any earlier. */
4780 ret
= send(src
, buffer
, bufferSize
, 0);
4781 } while (ret
== bufferSize
);
4782 drain_pause
= FALSE
;
4783 if (ret
>= 0 || WSAGetLastError() == WSAEWOULDBLOCK
)
4785 Sleep(400); /* win9x */
4786 broken_seq
[0] = read_write_seq
;
4787 broken_seq
[1] = NULL
;
4788 ok_event_seq(src
, hEvent
, write_seq
, broken_seq
, 0);
4792 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
4795 /* Test how FD_CLOSE is handled */
4796 ret
= send(dst
, "12", 2, 0);
4797 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4799 /* Wait a little and let the send complete */
4802 dst
= INVALID_SOCKET
;
4805 /* We can never implement this in wine, best we can hope for is
4806 sending FD_CLOSE after the reads complete */
4807 broken_seq
[0] = read_seq
; /* win9x */
4808 broken_seq
[1] = NULL
;
4809 todo_wine
ok_event_seq(src
, hEvent
, read_close_seq
, broken_seq
, 0);
4811 ret
= recv(src
, buffer
, 1, 0);
4812 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
4813 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
4815 ret
= recv(src
, buffer
, 1, 0);
4816 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
4817 /* want it? it's here, but you can't have it */
4818 broken_seq
[0] = close_seq
; /* win9x */
4819 broken_seq
[1] = NULL
;
4820 todo_wine
ok_event_seq(src
, hEvent
, empty_seq
, /* wine sends FD_CLOSE here */
4823 /* Test how FD_CLOSE is handled */
4824 ret
= send(dst2
, "12", 2, 0);
4825 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4828 shutdown(dst2
, SD_SEND
);
4831 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
4832 regressions, don't mark them as todo_wine, and mark windows as broken */
4833 broken_seq
[0] = read_close_seq
;
4834 broken_seq
[1] = close_seq
;
4835 broken_seq
[2] = NULL
;
4836 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
4838 ret
= recv(src2
, buffer
, 1, 0);
4839 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
4840 broken_seq
[0] = close_seq
; /* win98 */
4841 broken_seq
[1] = NULL
;
4842 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
4844 ret
= recv(src2
, buffer
, 1, 0);
4845 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
4846 broken_seq
[0] = empty_seq
;
4847 broken_seq
[1] = NULL
;
4848 ok_event_seq(src2
, hEvent2
, close_seq
, broken_seq
, 0);
4850 ret
= send(src2
, "1", 1, 0);
4851 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
4852 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
4854 ret
= send(src2
, "1", 1, 0);
4855 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
4856 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
4860 ret
= WSAAsyncSelect(src
, hWnd
, WM_SOCKET
, 0);
4863 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
4867 ret
= set_blocking(src
, TRUE
);
4868 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
4870 ret
= WSAAsyncSelect(src2
, hWnd
, WM_SOCKET
, 0);
4873 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
4877 ret
= set_blocking(src2
, TRUE
);
4878 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
4882 ret
= WSAEventSelect(src
, hEvent2
, 0);
4885 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
4889 ret
= set_blocking(src
, TRUE
);
4890 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
4892 ret
= WSAEventSelect(src2
, hEvent2
, 0);
4895 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
4899 ret
= set_blocking(src2
, TRUE
);
4900 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
4904 if (src
!= INVALID_SOCKET
)
4906 flush_events(src
, hEvent
);
4909 if (src2
!= INVALID_SOCKET
)
4911 flush_events(src2
, hEvent2
);
4914 HeapFree(GetProcessHeap(), 0, buffer
);
4915 if (server
!= INVALID_SOCKET
)
4916 closesocket(server
);
4917 if (dst
!= INVALID_SOCKET
)
4919 if (dst2
!= INVALID_SOCKET
)
4921 if (hThread
!= NULL
)
4922 CloseHandle(hThread
);
4924 DestroyWindow(hWnd
);
4926 CloseHandle(hEvent
);
4927 if (hEvent2
!= NULL
)
4928 CloseHandle(hEvent2
);
4929 if (ov
.hEvent
!= NULL
)
4930 CloseHandle(ov
.hEvent
);
4931 if (ov2
.hEvent
!= NULL
)
4932 CloseHandle(ov2
.hEvent
);
4935 static void test_ipv6only(void)
4937 SOCKET v4
= INVALID_SOCKET
,
4938 v6
= INVALID_SOCKET
;
4939 struct sockaddr_in sin4
;
4940 struct sockaddr_in6 sin6
;
4943 memset(&sin4
, 0, sizeof(sin4
));
4944 sin4
.sin_family
= AF_INET
;
4945 sin4
.sin_port
= htons(SERVERPORT
);
4947 memset(&sin6
, 0, sizeof(sin6
));
4948 sin6
.sin6_family
= AF_INET6
;
4949 sin6
.sin6_port
= htons(SERVERPORT
);
4951 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
4952 if (v6
== INVALID_SOCKET
) {
4953 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
4954 WSAGetLastError(), WSAEAFNOSUPPORT
);
4957 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
4959 skip("Could not bind IPv6 address (LastError: %d).\n",
4964 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4965 if (v4
== INVALID_SOCKET
) {
4966 skip("Could not create IPv4 socket (LastError: %d).\n",
4970 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
4971 ok(!ret
, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
4972 WSAGetLastError(), WSAEADDRINUSE
);
4975 if (v4
!= INVALID_SOCKET
)
4977 if (v6
!= INVALID_SOCKET
)
4981 static void test_WSASendMsg(void)
4984 struct sockaddr_in sendaddr
, sockaddr
;
4985 GUID WSASendMsg_GUID
= WSAID_WSASENDMSG
;
4986 LPFN_WSASENDMSG pWSASendMsg
= NULL
;
4987 char teststr
[12] = "hello world", buffer
[32];
4990 DWORD bytesSent
, err
;
4993 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
4995 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
4996 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
4998 /* Obtain the WSASendMsg function */
4999 WSAIoctl(sock
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSASendMsg_GUID
, sizeof(WSASendMsg_GUID
),
5000 &pWSASendMsg
, sizeof(pWSASendMsg
), &err
, NULL
, NULL
);
5004 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
5008 /* fake address for now */
5009 sendaddr
.sin_family
= AF_INET
;
5010 sendaddr
.sin_port
= htons(139);
5011 sendaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5013 memset(&msg
, 0, sizeof(msg
));
5014 iovec
[0].buf
= teststr
;
5015 iovec
[0].len
= sizeof(teststr
);
5016 iovec
[1].buf
= teststr
;
5017 iovec
[1].len
= sizeof(teststr
) / 2;
5018 msg
.name
= (struct sockaddr
*) &sendaddr
;
5019 msg
.namelen
= sizeof(sendaddr
);
5020 msg
.lpBuffers
= iovec
;
5021 msg
.dwBufferCount
= 1; /* send only one buffer for now */
5023 WSASetLastError(0xdeadbeef);
5024 ret
= pWSASendMsg(INVALID_SOCKET
, &msg
, 0, NULL
, NULL
, NULL
);
5025 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5026 err
= WSAGetLastError();
5027 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
5029 WSASetLastError(0xdeadbeef);
5030 ret
= pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
);
5031 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5032 err
= WSAGetLastError();
5033 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
5035 WSASetLastError(0xdeadbeef);
5036 ret
= pWSASendMsg(sock
, NULL
, 0, &bytesSent
, NULL
, NULL
);
5037 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5038 err
= WSAGetLastError();
5039 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
5041 WSASetLastError(0xdeadbeef);
5042 ret
= pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
);
5043 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5044 err
= WSAGetLastError();
5045 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
5049 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5050 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5052 dst
= socket(AF_INET
, SOCK_DGRAM
, 0);
5053 ok(dst
!= INVALID_SOCKET
, "socket() failed\n");
5055 memset(&sockaddr
, 0, sizeof(sockaddr
));
5056 sockaddr
.sin_family
= AF_INET
;
5057 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5058 ok(!bind(dst
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
)),
5059 "bind should have worked\n");
5061 /* read address to find out the port number to be used in send */
5062 memset(&sendaddr
, 0, sizeof(sendaddr
));
5063 addrlen
= sizeof(sendaddr
);
5064 ok(!getsockname(dst
, (struct sockaddr
*) &sendaddr
, &addrlen
),
5065 "getsockname should have worked\n");
5066 ok(sendaddr
.sin_port
, "socket port should be != 0\n");
5068 /* ensure the sending socket is not bound */
5069 WSASetLastError(0xdeadbeef);
5070 addrlen
= sizeof(sockaddr
);
5071 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
5072 ok(ret
== SOCKET_ERROR
, "getsockname should have failed\n");
5073 err
= WSAGetLastError();
5074 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
5076 set_blocking(sock
, TRUE
);
5079 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
5080 ok(!ret
, "WSASendMsg should have worked\n");
5081 ok(bytesSent
== iovec
[0].len
, "incorret bytes sent, expected %d, sent %d\n",
5082 iovec
[0].len
, bytesSent
);
5085 addrlen
= sizeof(sockaddr
);
5086 memset(buffer
, 0, sizeof(buffer
));
5087 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
5088 ok(ret
== bytesSent
, "got %d, expected %d\n",
5091 /* A successful call to WSASendMsg must have bound the socket */
5092 addrlen
= sizeof(sockaddr
);
5093 sockaddr
.sin_port
= 0;
5094 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5095 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
5096 ok(!ret
, "getsockname should have worked\n");
5097 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
5098 inet_ntoa(sockaddr
.sin_addr
));
5099 ok(sockaddr
.sin_port
, "sin_port should be != 0\n");
5101 msg
.dwBufferCount
= 2; /* send both buffers */
5104 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
5105 ok(!ret
, "WSASendMsg should have worked\n");
5106 ok(bytesSent
== iovec
[0].len
+ iovec
[1].len
, "incorret bytes sent, expected %d, sent %d\n",
5107 iovec
[0].len
+ iovec
[1].len
, bytesSent
);
5110 addrlen
= sizeof(sockaddr
);
5111 memset(buffer
, 0, sizeof(buffer
));
5112 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
5113 ok(ret
== bytesSent
, "got %d, expected %d\n",
5119 /* a bad call to WSASendMsg will also bind the socket */
5120 addrlen
= sizeof(sockaddr
);
5121 sockaddr
.sin_port
= 0;
5122 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5123 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5124 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5125 ok(pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
5127 ok(!getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have worked\n");
5128 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
5129 inet_ntoa(sockaddr
.sin_addr
));
5130 ok(sockaddr
.sin_port
, "sin_port should be > 0\n");
5134 /* a bad call without msg parameter will not trigger the auto-bind */
5135 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5136 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5137 ok(pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
5138 ok(getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have failed\n");
5139 err
= WSAGetLastError();
5140 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
5143 /* SOCK_STREAM sockets are not supported */
5145 sock
= socket(AF_INET
, SOCK_STREAM
, 0);
5146 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5147 SetLastError(0xdeadbeef);
5148 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
5149 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5150 err
= WSAGetLastError();
5152 ok(err
== WSAEINVAL
, "expected 10014, got %d instead\n", err
);
5156 static void test_WSASendTo(void)
5159 struct sockaddr_in addr
;
5160 char buf
[12] = "hello world";
5165 addr
.sin_family
= AF_INET
;
5166 addr
.sin_port
= htons(139);
5167 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5168 data_buf
.len
= sizeof(buf
);
5171 if( (s
= socket(AF_INET
, SOCK_DGRAM
, 0)) == INVALID_SOCKET
) {
5172 ok(0, "socket() failed error: %d\n", WSAGetLastError());
5176 WSASetLastError(12345);
5177 ret
= WSASendTo(INVALID_SOCKET
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
5178 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
5179 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
5181 WSASetLastError(12345);
5182 ret
= WSASendTo(s
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
5183 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
5184 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
5186 WSASetLastError(12345);
5187 if(WSASendTo(s
, &data_buf
, 1, &bytesSent
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
)) {
5188 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
5191 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
5192 "a successful call to WSASendTo()\n");
5195 static DWORD WINAPI
recv_thread(LPVOID arg
)
5197 SOCKET sock
= *(SOCKET
*)arg
;
5204 wsa
.len
= sizeof(buffer
);
5205 ov
.hEvent
= WSACreateEvent();
5206 WSARecv(sock
, &wsa
, 1, NULL
, &flags
, &ov
, NULL
);
5208 WaitForSingleObject(ov
.hEvent
, 1000);
5209 WSACloseEvent(ov
.hEvent
);
5213 static void test_WSARecv(void)
5215 SOCKET src
, dest
, server
= INVALID_SOCKET
;
5219 DWORD bytesReturned
, flags
, id
;
5221 struct sockaddr_in addr
;
5227 memset(&ov
, 0, sizeof(ov
));
5229 tcp_socketpair(&src
, &dest
);
5230 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
5232 skip("failed to create sockets\n");
5236 bufs
.len
= sizeof(buf
);
5240 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5241 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
5247 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
5248 ok(!iret
, "Failed to set linger %d\n", GetLastError());
5250 iret
= WSARecv(dest
, &bufs
, 1, NULL
, &flags
, &ov
, NULL
);
5251 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5253 iret
= WSARecv(dest
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
5254 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5257 src
= INVALID_SOCKET
;
5259 dwret
= WaitForSingleObject(ov
.hEvent
, 1000);
5260 ok(dwret
== WAIT_OBJECT_0
, "Waiting for disconnect event failed with %d + errno %d\n", dwret
, GetLastError());
5262 bret
= GetOverlappedResult((HANDLE
)dest
, &ov
, &bytesReturned
, FALSE
);
5263 todo_wine
ok(!bret
&& (GetLastError() == ERROR_NETNAME_DELETED
|| broken(GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */),
5264 "Did not get disconnect event: %d, error %d\n", bret
, GetLastError());
5265 ok(bytesReturned
== 0, "Bytes received is %d\n", bytesReturned
);
5267 dest
= INVALID_SOCKET
;
5269 src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
5270 ok(src
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5271 if (src
== INVALID_SOCKET
) goto end
;
5273 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
5274 ok(server
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5275 if (server
== INVALID_SOCKET
) goto end
;
5277 memset(&addr
, 0, sizeof(addr
));
5278 addr
.sin_family
= AF_INET
;
5279 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5280 iret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
5284 iret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
5287 iret
= listen(server
, 1);
5290 iret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
5294 dest
= accept(server
, (struct sockaddr
*)&addr
, &len
);
5295 ok(dest
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5296 if (dest
== INVALID_SOCKET
) goto end
;
5298 send(src
, "test message", sizeof("test message"), 0);
5299 thread
= CreateThread(NULL
, 0, recv_thread
, &dest
, 0, &id
);
5300 CloseHandle(thread
);
5303 if (server
!= INVALID_SOCKET
)
5304 closesocket(server
);
5305 if (dest
!= INVALID_SOCKET
)
5307 if (src
!= INVALID_SOCKET
)
5310 WSACloseEvent(ov
.hEvent
);
5313 static void test_GetAddrInfoW(void)
5315 static const WCHAR port
[] = {'8','0',0};
5316 static const WCHAR empty
[] = {0};
5317 static const WCHAR localhost
[] = {'l','o','c','a','l','h','o','s','t',0};
5318 static const WCHAR nxdomain
[] =
5319 {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
5320 static const WCHAR zero
[] = {'0',0};
5322 ADDRINFOW
*result
, *p
, hint
;
5324 if (!pGetAddrInfoW
|| !pFreeAddrInfoW
)
5326 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
5329 memset(&hint
, 0, sizeof(ADDRINFOW
));
5331 result
= (ADDRINFOW
*)0xdeadbeef;
5332 ret
= pGetAddrInfoW(NULL
, NULL
, NULL
, &result
);
5333 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
5334 ok(result
== NULL
, "got %p\n", result
);
5337 ret
= pGetAddrInfoW(empty
, NULL
, NULL
, &result
);
5338 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5339 ok(result
!= NULL
, "GetAddrInfoW failed\n");
5340 pFreeAddrInfoW(result
);
5343 ret
= pGetAddrInfoW(NULL
, zero
, NULL
, &result
);
5344 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5345 ok(result
!= NULL
, "GetAddrInfoW failed\n");
5346 pFreeAddrInfoW(result
);
5349 ret
= pGetAddrInfoW(empty
, zero
, NULL
, &result
);
5350 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5351 ok(result
!= NULL
, "GetAddrInfoW failed\n");
5352 pFreeAddrInfoW(result
);
5355 ret
= pGetAddrInfoW(localhost
, NULL
, NULL
, &result
);
5356 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5357 pFreeAddrInfoW(result
);
5360 ret
= pGetAddrInfoW(localhost
, empty
, NULL
, &result
);
5361 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5362 pFreeAddrInfoW(result
);
5365 ret
= pGetAddrInfoW(localhost
, zero
, NULL
, &result
);
5366 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5367 pFreeAddrInfoW(result
);
5370 ret
= pGetAddrInfoW(localhost
, port
, NULL
, &result
);
5371 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5372 pFreeAddrInfoW(result
);
5375 ret
= pGetAddrInfoW(localhost
, NULL
, &hint
, &result
);
5376 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5377 pFreeAddrInfoW(result
);
5380 ret
= pGetAddrInfoW(localhost
, port
, &hint
, &result
);
5381 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5382 pFreeAddrInfoW(result
);
5384 result
= (ADDRINFOW
*)0xdeadbeef;
5385 ret
= pGetAddrInfoW(NULL
, NULL
, NULL
, &result
);
5386 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
5387 ok(result
== NULL
, "got %p\n", result
);
5389 result
= (ADDRINFOW
*)0xdeadbeef;
5390 ret
= pGetAddrInfoW(nxdomain
, NULL
, NULL
, &result
);
5391 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
5392 ok(result
== NULL
, "got %p\n", result
);
5394 for (i
= 0;i
< (sizeof(hinttests
) / sizeof(hinttests
[0]));i
++)
5396 hint
.ai_family
= hinttests
[i
].family
;
5397 hint
.ai_socktype
= hinttests
[i
].socktype
;
5398 hint
.ai_protocol
= hinttests
[i
].protocol
;
5401 SetLastError(0xdeadbeef);
5402 ret
= pGetAddrInfoW(localhost
, NULL
, &hint
, &result
);
5405 if (hinttests
[i
].error
)
5406 ok(0, "test %d: GetAddrInfoW succeeded unexpectedly\n", i
);
5412 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
5413 if (hinttests
[i
].family
== AF_UNSPEC
)
5414 ok(p
->ai_family
== AF_INET
|| p
->ai_family
== AF_INET6
,
5415 "test %d: expected AF_INET or AF_INET6, got %d\n",
5418 ok(p
->ai_family
== hinttests
[i
].family
,
5419 "test %d: expected family %d, got %d\n",
5420 i
, hinttests
[i
].family
, p
->ai_family
);
5422 ok(p
->ai_socktype
== hinttests
[i
].socktype
,
5423 "test %d: expected type %d, got %d\n",
5424 i
, hinttests
[i
].socktype
, p
->ai_socktype
);
5425 ok(p
->ai_protocol
== hinttests
[i
].protocol
,
5426 "test %d: expected protocol %d, got %d\n",
5427 i
, hinttests
[i
].protocol
, p
->ai_protocol
);
5432 pFreeAddrInfoW(result
);
5436 DWORD err
= WSAGetLastError();
5437 if (hinttests
[i
].error
)
5438 ok(hinttests
[i
].error
== err
, "test %d: GetAddrInfoW failed with error %d, expected %d\n",
5439 i
, err
, hinttests
[i
].error
);
5441 ok(0, "test %d: GetAddrInfoW failed with %d (err %d)\n", i
, ret
, err
);
5446 static void test_getaddrinfo(void)
5449 ADDRINFOA
*result
, *p
, hint
;
5451 if (!pgetaddrinfo
|| !pfreeaddrinfo
)
5453 win_skip("getaddrinfo and/or freeaddrinfo not present\n");
5456 memset(&hint
, 0, sizeof(ADDRINFOA
));
5458 result
= (ADDRINFOA
*)0xdeadbeef;
5459 ret
= pgetaddrinfo(NULL
, NULL
, NULL
, &result
);
5460 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
5461 ok(result
== NULL
, "got %p\n", result
);
5464 ret
= pgetaddrinfo("", NULL
, NULL
, &result
);
5465 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5466 ok(result
!= NULL
, "getaddrinfo failed\n");
5467 pfreeaddrinfo(result
);
5470 ret
= pgetaddrinfo(NULL
, "0", NULL
, &result
);
5471 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5472 ok(result
!= NULL
, "getaddrinfo failed\n");
5473 pfreeaddrinfo(result
);
5476 ret
= pgetaddrinfo("", "0", NULL
, &result
);
5477 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5478 ok(result
!= NULL
, "getaddrinfo failed\n");
5479 pfreeaddrinfo(result
);
5482 ret
= pgetaddrinfo("localhost", NULL
, NULL
, &result
);
5483 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5484 pfreeaddrinfo(result
);
5487 ret
= pgetaddrinfo("localhost", "", NULL
, &result
);
5488 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5489 pfreeaddrinfo(result
);
5492 ret
= pgetaddrinfo("localhost", "0", NULL
, &result
);
5493 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5494 pfreeaddrinfo(result
);
5497 ret
= pgetaddrinfo("localhost", "80", NULL
, &result
);
5498 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5499 pfreeaddrinfo(result
);
5502 ret
= pgetaddrinfo("localhost", NULL
, &hint
, &result
);
5503 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5504 pfreeaddrinfo(result
);
5507 ret
= pgetaddrinfo("localhost", "80", &hint
, &result
);
5508 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5509 pfreeaddrinfo(result
);
5511 result
= (ADDRINFOA
*)0xdeadbeef;
5512 ret
= pgetaddrinfo("nxdomain.codeweavers.com", NULL
, NULL
, &result
);
5513 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
5514 ok(result
== NULL
, "got %p\n", result
);
5516 for (i
= 0;i
< (sizeof(hinttests
) / sizeof(hinttests
[0]));i
++)
5518 hint
.ai_family
= hinttests
[i
].family
;
5519 hint
.ai_socktype
= hinttests
[i
].socktype
;
5520 hint
.ai_protocol
= hinttests
[i
].protocol
;
5523 SetLastError(0xdeadbeef);
5524 ret
= pgetaddrinfo("localhost", NULL
, &hint
, &result
);
5527 if (hinttests
[i
].error
)
5528 ok(0, "test %d: getaddrinfo succeeded unexpectedly\n", i
);
5534 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
5535 if (hinttests
[i
].family
== AF_UNSPEC
)
5536 ok(p
->ai_family
== AF_INET
|| p
->ai_family
== AF_INET6
,
5537 "test %d: expected AF_INET or AF_INET6, got %d\n",
5540 ok(p
->ai_family
== hinttests
[i
].family
,
5541 "test %d: expected family %d, got %d\n",
5542 i
, hinttests
[i
].family
, p
->ai_family
);
5544 ok(p
->ai_socktype
== hinttests
[i
].socktype
,
5545 "test %d: expected type %d, got %d\n",
5546 i
, hinttests
[i
].socktype
, p
->ai_socktype
);
5547 ok(p
->ai_protocol
== hinttests
[i
].protocol
,
5548 "test %d: expected protocol %d, got %d\n",
5549 i
, hinttests
[i
].protocol
, p
->ai_protocol
);
5554 pfreeaddrinfo(result
);
5558 DWORD err
= WSAGetLastError();
5559 if (hinttests
[i
].error
)
5560 ok(hinttests
[i
].error
== err
, "test %d: getaddrinfo failed with error %d, expected %d\n",
5561 i
, err
, hinttests
[i
].error
);
5563 ok(0, "test %d: getaddrinfo failed with %d (err %d)\n", i
, ret
, err
);
5568 static void test_ConnectEx(void)
5570 SOCKET listener
= INVALID_SOCKET
;
5571 SOCKET acceptor
= INVALID_SOCKET
;
5572 SOCKET connector
= INVALID_SOCKET
;
5573 struct sockaddr_in address
, conaddress
;
5575 OVERLAPPED overlapped
;
5576 LPFN_CONNECTEX pConnectEx
;
5577 GUID connectExGuid
= WSAID_CONNECTEX
;
5578 DWORD bytesReturned
;
5584 memset(&overlapped
, 0, sizeof(overlapped
));
5586 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
5587 if (listener
== INVALID_SOCKET
) {
5588 skip("could not create listener socket, error %d\n", WSAGetLastError());
5592 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5593 if (connector
== INVALID_SOCKET
) {
5594 skip("could not create connector socket, error %d\n", WSAGetLastError());
5598 memset(&address
, 0, sizeof(address
));
5599 address
.sin_family
= AF_INET
;
5600 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5601 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
5603 skip("failed to bind, error %d\n", WSAGetLastError());
5607 addrlen
= sizeof(address
);
5608 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
5610 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
5614 if (set_blocking(listener
, TRUE
)) {
5615 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
5619 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectExGuid
, sizeof(connectExGuid
),
5620 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
5622 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret
, WSAGetLastError());
5626 bret
= pConnectEx(INVALID_SOCKET
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
5627 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "ConnectEx on invalid socket "
5628 "returned %d + errno %d\n", bret
, WSAGetLastError());
5630 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
5631 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "ConnectEx on a unbound socket "
5632 "returned %d + errno %d\n", bret
, WSAGetLastError());
5633 if (bret
== TRUE
|| WSAGetLastError() != WSAEINVAL
)
5635 acceptor
= accept(listener
, NULL
, NULL
);
5636 if (acceptor
!= INVALID_SOCKET
) {
5637 closesocket(acceptor
);
5638 acceptor
= INVALID_SOCKET
;
5641 closesocket(connector
);
5642 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5643 if (connector
== INVALID_SOCKET
) {
5644 skip("could not create connector socket, error %d\n", WSAGetLastError());
5649 /* ConnectEx needs a bound socket */
5650 memset(&conaddress
, 0, sizeof(conaddress
));
5651 conaddress
.sin_family
= AF_INET
;
5652 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5653 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
5655 skip("failed to bind, error %d\n", WSAGetLastError());
5659 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, NULL
);
5660 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "ConnectEx on a NULL overlapped "
5661 "returned %d + errno %d\n", bret
, WSAGetLastError());
5663 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5664 if (overlapped
.hEvent
== NULL
) {
5665 skip("could not create event object, errno = %d\n", GetLastError());
5669 iret
= listen(listener
, 1);
5671 skip("listening failed, errno = %d\n", WSAGetLastError());
5675 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
5676 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
5677 "returned %d + errno %d\n", bret
, WSAGetLastError());
5678 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
5679 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
5681 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
5682 ok(bret
, "Connecting failed, error %d\n", GetLastError());
5683 ok(bytesReturned
== 0, "Bytes sent is %d\n", bytesReturned
);
5685 closesocket(connector
);
5686 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5687 if (connector
== INVALID_SOCKET
) {
5688 skip("could not create connector socket, error %d\n", WSAGetLastError());
5691 /* ConnectEx needs a bound socket */
5692 memset(&conaddress
, 0, sizeof(conaddress
));
5693 conaddress
.sin_family
= AF_INET
;
5694 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5695 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
5697 skip("failed to bind, error %d\n", WSAGetLastError());
5701 acceptor
= accept(listener
, NULL
, NULL
);
5702 if (acceptor
!= INVALID_SOCKET
) {
5703 closesocket(acceptor
);
5709 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, buffer
, 3, &bytesReturned
, &overlapped
);
5710 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
5711 "returned %d + errno %d\n", bret
, WSAGetLastError());
5712 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
5713 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
5715 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
5716 ok(bret
, "Connecting failed, error %d\n", GetLastError());
5717 ok(bytesReturned
== 3, "Bytes sent is %d\n", bytesReturned
);
5719 acceptor
= accept(listener
, NULL
, NULL
);
5720 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket error %d\n", WSAGetLastError());
5722 bytesReturned
= recv(acceptor
, buffer
, 3, 0);
5724 ok(bytesReturned
== 3, "Didn't get all sent data, got only %d\n", bytesReturned
);
5725 ok(buffer
[0] == '1' && buffer
[1] == '2' && buffer
[2] == '3',
5726 "Failed to get the right data, expected '123', got '%s'\n", buffer
);
5728 closesocket(connector
);
5729 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5730 if (connector
== INVALID_SOCKET
) {
5731 skip("could not create connector socket, error %d\n", WSAGetLastError());
5734 /* ConnectEx needs a bound socket */
5735 memset(&conaddress
, 0, sizeof(conaddress
));
5736 conaddress
.sin_family
= AF_INET
;
5737 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5738 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
5740 skip("failed to bind, error %d\n", WSAGetLastError());
5744 if (acceptor
!= INVALID_SOCKET
) {
5745 closesocket(acceptor
);
5746 acceptor
= INVALID_SOCKET
;
5749 /* Connect with error */
5750 closesocket(listener
);
5751 listener
= INVALID_SOCKET
;
5753 address
.sin_port
= htons(1);
5755 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
5756 ok(bret
== FALSE
&& GetLastError(), "ConnectEx to bad destination failed: "
5757 "returned %d + errno %d\n", bret
, GetLastError());
5759 if (GetLastError() == ERROR_IO_PENDING
)
5761 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
5762 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
5764 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
5765 ok(bret
== FALSE
&& GetLastError() == ERROR_CONNECTION_REFUSED
,
5766 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
5769 ok(GetLastError() == WSAECONNREFUSED
,
5770 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
5774 if (overlapped
.hEvent
)
5775 WSACloseEvent(overlapped
.hEvent
);
5776 if (listener
!= INVALID_SOCKET
)
5777 closesocket(listener
);
5778 if (acceptor
!= INVALID_SOCKET
)
5779 closesocket(acceptor
);
5780 if (connector
!= INVALID_SOCKET
)
5781 closesocket(connector
);
5784 static void test_AcceptEx(void)
5786 SOCKET listener
= INVALID_SOCKET
;
5787 SOCKET acceptor
= INVALID_SOCKET
;
5788 SOCKET connector
= INVALID_SOCKET
;
5789 SOCKET connector2
= INVALID_SOCKET
;
5790 struct sockaddr_in bindAddress
, peerAddress
, *readBindAddress
, *readRemoteAddress
;
5791 int socklen
, optlen
;
5792 GUID acceptExGuid
= WSAID_ACCEPTEX
, getAcceptExGuid
= WSAID_GETACCEPTEXSOCKADDRS
;
5793 LPFN_ACCEPTEX pAcceptEx
= NULL
;
5794 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs
= NULL
;
5795 fd_set fds_accept
, fds_send
;
5796 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
5798 DWORD bytesReturned
, connect_time
;
5799 char buffer
[1024], ipbuffer
[32];
5800 OVERLAPPED overlapped
;
5801 int iret
, localSize
= sizeof(struct sockaddr_in
), remoteSize
= localSize
;
5805 memset(&overlapped
, 0, sizeof(overlapped
));
5807 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
5808 if (listener
== INVALID_SOCKET
) {
5809 skip("could not create listener socket, error %d\n", WSAGetLastError());
5813 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
5814 if (acceptor
== INVALID_SOCKET
) {
5815 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
5819 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5820 if (connector
== INVALID_SOCKET
) {
5821 skip("could not create connector socket, error %d\n", WSAGetLastError());
5825 memset(&bindAddress
, 0, sizeof(bindAddress
));
5826 bindAddress
.sin_family
= AF_INET
;
5827 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5828 iret
= bind(listener
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
5830 skip("failed to bind, error %d\n", WSAGetLastError());
5834 socklen
= sizeof(bindAddress
);
5835 iret
= getsockname(listener
, (struct sockaddr
*)&bindAddress
, &socklen
);
5837 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
5841 if (set_blocking(listener
, FALSE
)) {
5842 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
5846 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
5847 &pAcceptEx
, sizeof(pAcceptEx
), &bytesReturned
, NULL
, NULL
);
5849 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret
, WSAGetLastError());
5853 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &getAcceptExGuid
, sizeof(getAcceptExGuid
),
5854 &pGetAcceptExSockaddrs
, sizeof(pGetAcceptExSockaddrs
), &bytesReturned
, NULL
, NULL
);
5856 skip("WSAIoctl failed to get GetAcceptExSockaddrs with ret %d + errno %d\n", iret
, WSAGetLastError());
5860 bret
= pAcceptEx(INVALID_SOCKET
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
5861 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5862 &bytesReturned
, &overlapped
);
5863 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid listening socket "
5864 "returned %d + errno %d\n", bret
, WSAGetLastError());
5866 bret
= pAcceptEx(listener
, INVALID_SOCKET
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
5867 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5868 &bytesReturned
, &overlapped
);
5869 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on invalid accepting socket "
5870 "returned %d + errno %d\n", bret
, WSAGetLastError());
5872 bret
= pAcceptEx(listener
, acceptor
, NULL
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
5873 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5874 &bytesReturned
, &overlapped
);
5876 (WSAGetLastError() == WSAEINVAL
||
5877 broken(WSAGetLastError() == WSAEFAULT
)), /* NT4 */
5878 "AcceptEx on NULL buffer returned %d + errno %d\n", bret
, WSAGetLastError());
5880 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
5881 &bytesReturned
, &overlapped
);
5882 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on too small local address size "
5883 "returned %d + errno %d\n", bret
, WSAGetLastError());
5885 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 15,
5886 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
5887 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on too small local address size "
5888 "returned %d + errno %d\n", bret
, WSAGetLastError());
5890 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16, 0,
5891 &bytesReturned
, &overlapped
);
5892 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on too small remote address size "
5893 "returned %d + errno %d\n", bret
, WSAGetLastError());
5895 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
5896 sizeof(struct sockaddr_in
) + 15, &bytesReturned
, &overlapped
);
5897 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on too small remote address size "
5898 "returned %d + errno %d\n", bret
, WSAGetLastError());
5900 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
5901 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5902 &bytesReturned
, NULL
);
5903 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
5904 "returned %d + errno %d\n", bret
, WSAGetLastError());
5906 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, 0, &bytesReturned
, NULL
);
5907 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
5908 "returned %d + errno %d\n", bret
, WSAGetLastError());
5910 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
5911 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5912 &bytesReturned
, &overlapped
);
5913 todo_wine
ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on a non-listening socket "
5914 "returned %d + errno %d\n", bret
, WSAGetLastError());
5916 iret
= listen(listener
, 5);
5918 skip("listening failed, errno = %d\n", WSAGetLastError());
5922 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5923 if (overlapped
.hEvent
== NULL
) {
5924 skip("could not create event object, errno = %d\n", GetLastError());
5928 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
5929 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5930 &bytesReturned
, &overlapped
);
5931 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
5933 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
5934 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5935 &bytesReturned
, &overlapped
);
5936 todo_wine
ok((bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
) || broken(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) /* NT4 */,
5937 "AcceptEx on already pending socket returned %d + errno %d\n", bret
, WSAGetLastError());
5938 if (bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) {
5939 /* We need to cancel this call, otherwise things fail */
5940 bret
= CancelIo((HANDLE
) listener
);
5941 ok(bret
, "Failed to cancel failed test. Bailing...\n");
5943 WaitForSingleObject(overlapped
.hEvent
, 0);
5945 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
5946 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5947 &bytesReturned
, &overlapped
);
5948 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
5951 iret
= connect(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
5952 todo_wine
ok((iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
) || broken(!iret
) /* NT4 */,
5953 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret
, WSAGetLastError());
5954 if (!iret
|| (iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
)) {
5955 /* We need to cancel this call, otherwise things fail */
5956 closesocket(acceptor
);
5957 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
5958 if (acceptor
== INVALID_SOCKET
) {
5959 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
5963 bret
= CancelIo((HANDLE
) listener
);
5964 ok(bret
, "Failed to cancel failed test. Bailing...\n");
5967 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
5968 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
5969 &bytesReturned
, &overlapped
);
5970 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
5973 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
5974 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
5976 dwret
= WaitForSingleObject(overlapped
.hEvent
, INFINITE
);
5977 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
5979 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
5980 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
5981 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
5983 closesocket(connector
);
5984 connector
= INVALID_SOCKET
;
5985 closesocket(acceptor
);
5987 /* Test short reads */
5989 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
5990 if (acceptor
== INVALID_SOCKET
) {
5991 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
5994 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5995 if (connector
== INVALID_SOCKET
) {
5996 skip("could not create connector socket, error %d\n", WSAGetLastError());
5999 bret
= pAcceptEx(listener
, acceptor
, buffer
, 2,
6000 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6001 &bytesReturned
, &overlapped
);
6002 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6004 connect_time
= 0xdeadbeef;
6005 optlen
= sizeof(connect_time
);
6006 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
6007 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
6008 ok(connect_time
== ~0u, "unexpected connect time %u\n", connect_time
);
6010 /* AcceptEx() still won't complete until we send data */
6011 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6012 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6014 connect_time
= 0xdeadbeef;
6015 optlen
= sizeof(connect_time
);
6016 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
6017 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
6018 ok(connect_time
< 0xdeadbeef, "unexpected connect time %u\n", connect_time
);
6020 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
6021 ok(dwret
== WAIT_TIMEOUT
, "Waiting for accept event timeout failed with %d + errno %d\n", dwret
, GetLastError());
6023 iret
= getsockname( connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
6024 ok( !iret
, "getsockname failed.\n");
6026 /* AcceptEx() could complete any time now */
6027 iret
= send(connector
, buffer
, 1, 0);
6028 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
6030 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6031 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6033 /* Check if the buffer from AcceptEx is decoded correctly */
6034 pGetAcceptExSockaddrs(buffer
, 2, sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6035 (struct sockaddr
**)&readBindAddress
, &localSize
,
6036 (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
6037 strcpy( ipbuffer
, inet_ntoa(readBindAddress
->sin_addr
));
6038 ok( readBindAddress
->sin_addr
.s_addr
== bindAddress
.sin_addr
.s_addr
,
6039 "Local socket address is different %s != %s\n",
6040 ipbuffer
, inet_ntoa(bindAddress
.sin_addr
));
6041 ok( readBindAddress
->sin_port
== bindAddress
.sin_port
,
6042 "Local socket port is different: %d != %d\n",
6043 readBindAddress
->sin_port
, bindAddress
.sin_port
);
6044 strcpy( ipbuffer
, inet_ntoa(readRemoteAddress
->sin_addr
));
6045 ok( readRemoteAddress
->sin_addr
.s_addr
== peerAddress
.sin_addr
.s_addr
,
6046 "Remote socket address is different %s != %s\n",
6047 ipbuffer
, inet_ntoa(peerAddress
.sin_addr
));
6048 ok( readRemoteAddress
->sin_port
== peerAddress
.sin_port
,
6049 "Remote socket port is different: %d != %d\n",
6050 readRemoteAddress
->sin_port
, peerAddress
.sin_port
);
6052 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6053 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6054 ok(bytesReturned
== 1, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6056 closesocket(connector
);
6057 connector
= INVALID_SOCKET
;
6058 closesocket(acceptor
);
6060 /* Test CF_DEFER & AcceptEx interaction */
6062 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6063 if (acceptor
== INVALID_SOCKET
) {
6064 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6067 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6068 if (connector
== INVALID_SOCKET
) {
6069 skip("could not create connector socket, error %d\n", WSAGetLastError());
6072 connector2
= socket(AF_INET
, SOCK_STREAM
, 0);
6073 if (connector
== INVALID_SOCKET
) {
6074 skip("could not create connector socket, error %d\n", WSAGetLastError());
6078 if (set_blocking(connector
, FALSE
)) {
6079 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
6083 if (set_blocking(connector2
, FALSE
)) {
6084 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
6088 /* Connect socket #1 */
6089 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6090 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6092 FD_ZERO ( &fds_accept
);
6093 FD_ZERO ( &fds_send
);
6095 FD_SET ( listener
, &fds_accept
);
6096 FD_SET ( connector
, &fds_send
);
6102 for (i
= 0; i
< 4000; ++i
)
6104 fd_set fds_openaccept
= fds_accept
, fds_opensend
= fds_send
;
6106 wsa_ok ( ( select ( 0, &fds_openaccept
, &fds_opensend
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
6107 "acceptex test(%d): could not select on socket, errno %d\n" );
6109 /* check for incoming requests */
6110 if ( FD_ISSET ( listener
, &fds_openaccept
) ) {
6113 SOCKET tmp
= WSAAccept(listener
, NULL
, NULL
, (LPCONDITIONPROC
) AlwaysDeferConditionFunc
, 0);
6114 ok(tmp
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
6115 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6116 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6117 &bytesReturned
, &overlapped
);
6118 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6120 else if (got
== 2) {
6121 /* this should be socket #2 */
6122 SOCKET tmp
= accept(listener
, NULL
, NULL
);
6123 ok(tmp
!= INVALID_SOCKET
, "accept failed %d\n", WSAGetLastError());
6127 ok(FALSE
, "Got more than 2 connections?\n");
6130 if ( conn1
&& FD_ISSET ( connector2
, &fds_opensend
) ) {
6131 /* Send data on second socket, and stop */
6132 send(connector2
, "2", 1, 0);
6133 FD_CLR ( connector2
, &fds_send
);
6137 if ( FD_ISSET ( connector
, &fds_opensend
) ) {
6138 /* Once #1 is connected, allow #2 to connect */
6141 send(connector
, "1", 1, 0);
6142 FD_CLR ( connector
, &fds_send
);
6144 iret
= connect(connector2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6145 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6146 FD_SET ( connector2
, &fds_send
);
6150 ok (got
== 2 || broken(got
== 1) /* NT4 */,
6151 "Did not get both connections, got %d\n", got
);
6153 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
6154 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6156 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6157 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6158 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6160 set_blocking(acceptor
, TRUE
);
6161 iret
= recv( acceptor
, buffer
, 2, 0);
6162 ok(iret
== 1, "Failed to get data, %d, errno: %d\n", iret
, WSAGetLastError());
6164 ok(buffer
[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer
[0]);
6166 closesocket(connector
);
6167 connector
= INVALID_SOCKET
;
6168 closesocket(acceptor
);
6170 /* clean up in case of failures */
6171 while ((acceptor
= accept(listener
, NULL
, NULL
)) != INVALID_SOCKET
)
6172 closesocket(acceptor
);
6174 /* Disconnect during receive? */
6176 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6177 if (acceptor
== INVALID_SOCKET
) {
6178 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6181 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6182 if (connector
== INVALID_SOCKET
) {
6183 skip("could not create connector socket, error %d\n", WSAGetLastError());
6186 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6187 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6188 &bytesReturned
, &overlapped
);
6189 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6191 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6192 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6194 closesocket(connector
);
6195 connector
= INVALID_SOCKET
;
6197 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6198 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6200 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6201 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6202 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6204 closesocket(acceptor
);
6206 /* Test closing with pending requests */
6208 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6209 if (acceptor
== INVALID_SOCKET
) {
6210 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6213 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6214 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6215 &bytesReturned
, &overlapped
);
6216 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6218 closesocket(acceptor
);
6220 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6221 todo_wine
ok(dwret
== WAIT_OBJECT_0
|| broken(dwret
== WAIT_TIMEOUT
) /* NT4/2000 */,
6222 "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6224 if (dwret
!= WAIT_TIMEOUT
) {
6225 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6226 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
6229 bret
= CancelIo((HANDLE
) listener
);
6230 ok(bret
, "Failed to cancel failed test. Bailing...\n");
6232 WaitForSingleObject(overlapped
.hEvent
, 0);
6235 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6236 if (acceptor
== INVALID_SOCKET
) {
6237 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6240 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6241 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6242 &bytesReturned
, &overlapped
);
6243 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6245 CancelIo((HANDLE
) acceptor
);
6247 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6248 ok(dwret
== WAIT_TIMEOUT
, "Waiting for timeout failed with %d + errno %d\n", dwret
, GetLastError());
6250 closesocket(acceptor
);
6252 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6253 if (acceptor
== INVALID_SOCKET
) {
6254 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6257 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6258 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6259 &bytesReturned
, &overlapped
);
6260 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6262 closesocket(listener
);
6263 listener
= INVALID_SOCKET
;
6265 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6266 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6268 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6269 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
6272 if (overlapped
.hEvent
)
6273 WSACloseEvent(overlapped
.hEvent
);
6274 if (listener
!= INVALID_SOCKET
)
6275 closesocket(listener
);
6276 if (acceptor
!= INVALID_SOCKET
)
6277 closesocket(acceptor
);
6278 if (connector
!= INVALID_SOCKET
)
6279 closesocket(connector
);
6280 if (connector2
!= INVALID_SOCKET
)
6281 closesocket(connector2
);
6284 static void test_getpeername(void)
6287 struct sockaddr_in sa
, sa_out
;
6288 SOCKADDR_STORAGE ss
;
6290 const char buf
[] = "hello world";
6293 /* Test the parameter validation order. */
6294 ret
= getpeername(INVALID_SOCKET
, NULL
, NULL
);
6295 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
6296 ok(WSAGetLastError() == WSAENOTSOCK
,
6297 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
6299 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
6300 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
6301 if (sock
== INVALID_SOCKET
)
6303 skip("Socket creation failed with %d\n", WSAGetLastError());
6307 ret
= getpeername(sock
, NULL
, NULL
);
6308 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
6309 ok(WSAGetLastError() == WSAENOTCONN
||
6310 broken(WSAGetLastError() == WSAEFAULT
), /* Win9x and WinMe */
6311 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
6313 memset(&sa
, 0, sizeof(sa
));
6314 sa
.sin_family
= AF_INET
;
6315 sa
.sin_port
= htons(139);
6316 sa
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6318 /* sendto does not change a socket's connection state. */
6319 ret
= sendto(sock
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
6320 ok(ret
!= SOCKET_ERROR
,
6321 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
6323 ret
= getpeername(sock
, NULL
, NULL
);
6324 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
6325 ok(WSAGetLastError() == WSAENOTCONN
||
6326 broken(WSAGetLastError() == WSAEFAULT
), /* Win9x and WinMe */
6327 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
6329 ret
= connect(sock
, (struct sockaddr
*)&sa
, sizeof(sa
));
6331 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
6333 ret
= getpeername(sock
, NULL
, NULL
);
6334 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
6335 ok(WSAGetLastError() == WSAEFAULT
,
6336 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6338 /* Test crashes on Wine. */
6341 ret
= getpeername(sock
, (void*)0xdeadbeef, (void*)0xcafebabe);
6342 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
6343 ok(WSAGetLastError() == WSAEFAULT
,
6344 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6347 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, NULL
);
6348 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
6349 ok(WSAGetLastError() == WSAEFAULT
,
6350 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6353 ret
= getpeername(sock
, NULL
, &sa_len
);
6354 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
6355 ok(WSAGetLastError() == WSAEFAULT
,
6356 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6357 ok(!sa_len
, "got %d\n", sa_len
);
6360 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
6361 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
6362 ok(WSAGetLastError() == WSAEFAULT
,
6363 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6364 ok(!sa_len
, "got %d\n", sa_len
);
6366 sa_len
= sizeof(ss
);
6367 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
6368 ok(ret
== 0, "Expected getpeername to return 0, got %d\n", ret
);
6369 ok(!memcmp(&sa
, &ss
, sizeof(sa
)),
6370 "Expected the returned structure to be identical to the connect structure\n");
6371 ok(sa_len
== sizeof(sa
), "got %d\n", sa_len
);
6376 static void test_sioRoutingInterfaceQuery(void)
6380 SOCKADDR_IN sin
= { 0 }, sout
= { 0 };
6381 DWORD bytesReturned
;
6383 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
6384 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
6385 if (sock
== INVALID_SOCKET
)
6387 skip("Socket creation failed with %d\n", WSAGetLastError());
6390 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, NULL
, 0, NULL
, 0, NULL
,
6392 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
6393 "expected WSAEFAULT, got %d\n", WSAGetLastError());
6394 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
6395 NULL
, 0, NULL
, NULL
, NULL
);
6396 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
6397 "expected WSAEFAULT, got %d\n", WSAGetLastError());
6398 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
6399 NULL
, 0, &bytesReturned
, NULL
, NULL
);
6400 ok(ret
== SOCKET_ERROR
&&
6401 (WSAGetLastError() == WSAEFAULT
/* Win98 */ ||
6402 WSAGetLastError() == WSAEINVAL
/* NT4 */||
6403 WSAGetLastError() == WSAEAFNOSUPPORT
),
6404 "expected WSAEFAULT or WSAEINVAL or WSAEAFNOSUPPORT, got %d\n",
6406 sin
.sin_family
= AF_INET
;
6407 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
6408 NULL
, 0, &bytesReturned
, NULL
, NULL
);
6409 ok(ret
== SOCKET_ERROR
&&
6410 (WSAGetLastError() == WSAEFAULT
/* Win98 */ ||
6411 WSAGetLastError() == WSAEINVAL
),
6412 "expected WSAEFAULT or WSAEINVAL, got %d\n", WSAGetLastError());
6413 sin
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
6414 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
6415 NULL
, 0, &bytesReturned
, NULL
, NULL
);
6416 ok(ret
== SOCKET_ERROR
&&
6417 (WSAGetLastError() == WSAEINVAL
/* NT4 */ ||
6418 WSAGetLastError() == WSAEFAULT
),
6419 "expected WSAEINVAL or WSAEFAULT, got %d\n", WSAGetLastError());
6420 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
6421 &sout
, sizeof(sout
), &bytesReturned
, NULL
, NULL
);
6422 ok(!ret
|| broken(WSAGetLastError() == WSAEINVAL
/* NT4 */),
6423 "WSAIoctl failed: %d\n", WSAGetLastError());
6426 ok(sout
.sin_family
== AF_INET
, "expected AF_INET, got %d\n",
6428 /* We expect the source address to be INADDR_LOOPBACK as well, but
6429 * there's no guarantee that a route to the loopback address exists,
6430 * so rather than introduce spurious test failures we do not test the
6437 static void test_synchronous_WSAIoctl(void)
6439 HANDLE previous_port
, io_port
;
6440 WSAOVERLAPPED overlapped
, *olp
;
6448 previous_port
= CreateIoCompletionPort( INVALID_HANDLE_VALUE
, NULL
, 0, 0 );
6449 ok( previous_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
6451 socket
= WSASocketW( AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
6452 ok( socket
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError() );
6454 io_port
= CreateIoCompletionPort( (HANDLE
)socket
, previous_port
, 0, 0 );
6455 ok( io_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
6458 memset( &overlapped
, 0, sizeof(overlapped
) );
6459 res
= WSAIoctl( socket
, FIONBIO
, &on
, sizeof(on
), NULL
, 0, &num_bytes
, &overlapped
, NULL
);
6460 ok( !res
, "WSAIoctl failed %d\n", WSAGetLastError() );
6462 ret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 10000 );
6463 ok( ret
, "failed to get completion status %u\n", GetLastError() );
6465 CloseHandle( io_port
);
6466 closesocket( socket
);
6467 CloseHandle( previous_port
);
6470 #define WM_ASYNCCOMPLETE (WM_USER + 100)
6471 static HWND
create_async_message_window(void)
6473 static const char class_name
[] = "ws2_32 async message window class";
6475 WNDCLASSEXA wndclass
;
6478 wndclass
.cbSize
= sizeof(wndclass
);
6479 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
6480 wndclass
.lpfnWndProc
= DefWindowProcA
;
6481 wndclass
.cbClsExtra
= 0;
6482 wndclass
.cbWndExtra
= 0;
6483 wndclass
.hInstance
= GetModuleHandleA(NULL
);
6484 wndclass
.hIcon
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
6485 wndclass
.hIconSm
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
6486 wndclass
.hCursor
= LoadCursorA(NULL
, (LPCSTR
)IDC_ARROW
);
6487 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
6488 wndclass
.lpszClassName
= class_name
;
6489 wndclass
.lpszMenuName
= NULL
;
6491 RegisterClassExA(&wndclass
);
6493 hWnd
= CreateWindowA(class_name
, "ws2_32 async message window", WS_OVERLAPPEDWINDOW
,
6494 0, 0, 500, 500, NULL
, NULL
, GetModuleHandleA(NULL
), NULL
);
6497 ok(0, "failed to create window: %u\n", GetLastError());
6504 static void test_WSAAsyncGetServByPort(void)
6506 HWND hwnd
= create_async_message_window();
6508 char buffer
[MAXGETHOSTSTRUCT
];
6513 /* FIXME: The asynchronous window messages should be tested. */
6515 /* Parameters are not checked when initiating the asynchronous operation. */
6516 ret
= WSAAsyncGetServByPort(NULL
, 0, 0, NULL
, NULL
, 0);
6517 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
6519 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, 0, NULL
, NULL
, 0);
6520 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
6522 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, htons(80), NULL
, NULL
, 0);
6523 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
6525 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, htons(80), NULL
, buffer
, MAXGETHOSTSTRUCT
);
6526 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
6528 DestroyWindow(hwnd
);
6531 static void test_WSAAsyncGetServByName(void)
6533 HWND hwnd
= create_async_message_window();
6535 char buffer
[MAXGETHOSTSTRUCT
];
6540 /* FIXME: The asynchronous window messages should be tested. */
6542 /* Parameters are not checked when initiating the asynchronous operation. */
6543 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "", NULL
, NULL
, 0);
6544 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
6546 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "", "", buffer
, MAXGETHOSTSTRUCT
);
6547 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
6549 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "http", NULL
, NULL
, 0);
6550 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
6552 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "http", "tcp", buffer
, MAXGETHOSTSTRUCT
);
6553 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
6555 DestroyWindow(hwnd
);
6559 * Provide consistent initialization for the AcceptEx IOCP tests.
6561 static SOCKET
setup_iocp_src(struct sockaddr_in
*bindAddress
)
6563 SOCKET src
, ret
= INVALID_SOCKET
;
6566 src
= socket(AF_INET
, SOCK_STREAM
, 0);
6567 if (src
== INVALID_SOCKET
)
6569 skip("could not create listener socket, error %d\n", WSAGetLastError());
6573 memset(bindAddress
, 0, sizeof(*bindAddress
));
6574 bindAddress
->sin_family
= AF_INET
;
6575 bindAddress
->sin_addr
.s_addr
= inet_addr("127.0.0.1");
6576 iret
= bind(src
, (struct sockaddr
*)bindAddress
, sizeof(*bindAddress
));
6579 skip("failed to bind, error %d\n", WSAGetLastError());
6583 socklen
= sizeof(*bindAddress
);
6584 iret
= getsockname(src
, (struct sockaddr
*)bindAddress
, &socklen
);
6586 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
6590 if (set_blocking(src
, FALSE
))
6592 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
6596 iret
= listen(src
, 5);
6599 skip("listening failed, errno = %d\n", WSAGetLastError());
6605 if (src
!= ret
&& ret
== INVALID_SOCKET
)
6610 static void test_completion_port(void)
6612 HANDLE previous_port
, io_port
;
6613 WSAOVERLAPPED ov
, *olp
;
6614 SOCKET src
, dest
, dup
, connector
= INVALID_SOCKET
;
6615 WSAPROTOCOL_INFOA info
;
6618 DWORD num_bytes
, flags
;
6623 struct sockaddr_in bindAddress
;
6624 GUID acceptExGuid
= WSAID_ACCEPTEX
;
6625 LPFN_ACCEPTEX pAcceptEx
= NULL
;
6627 previous_port
= CreateIoCompletionPort(INVALID_HANDLE_VALUE
, NULL
, 0, 0);
6628 ok( previous_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
6630 memset(&ov
, 0, sizeof(ov
));
6632 tcp_socketpair(&src
, &dest
);
6633 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
6635 skip("failed to create sockets\n");
6639 bufs
.len
= sizeof(buf
);
6645 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
6646 ok(!iret
, "Failed to set linger %d\n", GetLastError());
6648 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, previous_port
, 125, 0 );
6649 ok(io_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
6651 SetLastError(0xdeadbeef);
6653 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
6654 ok(iret
== SOCKET_ERROR
, "WSARecv returned %d\n", iret
);
6655 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
6660 src
= INVALID_SOCKET
;
6662 SetLastError(0xdeadbeef);
6664 num_bytes
= 0xdeadbeef;
6665 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6667 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
6668 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
6669 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
, "Last error was %d\n", GetLastError());
6670 ok(key
== 125, "Key is %lu\n", key
);
6671 ok(num_bytes
== 0, "Number of bytes received is %u\n", num_bytes
);
6672 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
6674 SetLastError(0xdeadbeef);
6676 num_bytes
= 0xdeadbeef;
6677 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6679 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
6680 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
6681 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6682 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6683 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6684 ok(!olp
, "Overlapped structure is at %p\n", olp
);
6686 if (dest
!= INVALID_SOCKET
)
6689 memset(&ov
, 0, sizeof(ov
));
6691 tcp_socketpair(&src
, &dest
);
6692 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
6694 skip("failed to create sockets\n");
6698 bufs
.len
= sizeof(buf
);
6704 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
6705 ok(!iret
, "Failed to set linger %d\n", GetLastError());
6707 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 125, 0);
6708 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
6710 set_blocking(dest
, FALSE
);
6713 src
= INVALID_SOCKET
;
6717 num_bytes
= 0xdeadbeef;
6718 SetLastError(0xdeadbeef);
6720 iret
= WSASend(dest
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
6721 ok(iret
== SOCKET_ERROR
, "WSASend failed - %d\n", iret
);
6722 ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
6723 ok(num_bytes
== 0xdeadbeef, "Managed to send %d\n", num_bytes
);
6725 SetLastError(0xdeadbeef);
6727 num_bytes
= 0xdeadbeef;
6728 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6730 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
6731 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
6732 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6733 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6734 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6735 ok(!olp
, "Overlapped structure is at %p\n", olp
);
6737 if (dest
!= INVALID_SOCKET
)
6740 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
6741 if (dest
== INVALID_SOCKET
)
6743 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6747 iret
= WSAIoctl(dest
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
6748 &pAcceptEx
, sizeof(pAcceptEx
), &num_bytes
, NULL
, NULL
);
6751 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret
, WSAGetLastError());
6755 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
6757 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
6760 SetLastError(0xdeadbeef);
6762 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
6763 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6765 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
6766 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
6768 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
6769 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
6772 src
= INVALID_SOCKET
;
6774 SetLastError(0xdeadbeef);
6776 num_bytes
= 0xdeadbeef;
6777 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6779 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
6780 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6781 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
6782 ok(key
== 125, "Key is %lu\n", key
);
6783 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
6784 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
6785 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
6787 SetLastError(0xdeadbeef);
6789 num_bytes
= 0xdeadbeef;
6790 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6791 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
6792 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6793 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6794 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6795 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6796 ok(!olp
, "Overlapped structure is at %p\n", olp
);
6798 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
6800 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
6803 SetLastError(0xdeadbeef);
6805 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
6806 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
6808 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
6809 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6811 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
6812 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
6815 src
= INVALID_SOCKET
;
6817 SetLastError(0xdeadbeef);
6819 num_bytes
= 0xdeadbeef;
6820 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6822 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
6823 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6824 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
6825 ok(key
== 125, "Key is %lu\n", key
);
6826 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
6827 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
6828 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
6830 SetLastError(0xdeadbeef);
6832 num_bytes
= 0xdeadbeef;
6833 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6834 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
6835 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6836 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6837 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6838 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6839 ok(!olp
, "Overlapped structure is at %p\n", olp
);
6841 /* Test IOCP with duplicated handle */
6843 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
6846 SetLastError(0xdeadbeef);
6848 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
6849 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
6851 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
6852 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
6853 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
6855 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
6856 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6858 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
6859 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
6861 SetLastError(0xdeadbeef);
6863 num_bytes
= 0xdeadbeef;
6864 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6865 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
6866 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6867 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6868 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6869 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6870 ok(!olp
, "Overlapped structure is at %p\n", olp
);
6873 src
= INVALID_SOCKET
;
6875 dup
= INVALID_SOCKET
;
6877 SetLastError(0xdeadbeef);
6879 num_bytes
= 0xdeadbeef;
6880 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6881 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
6882 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6883 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
6884 ok(key
== 125, "Key is %lu\n", key
);
6885 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
6886 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
6887 ok(olp
&& olp
->Internal
== (ULONG
)STATUS_CANCELLED
, "Internal status is %lx\n", olp
? olp
->Internal
: 0);
6889 SetLastError(0xdeadbeef);
6891 num_bytes
= 0xdeadbeef;
6892 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6893 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
6894 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6895 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6896 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6897 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6898 ok(!olp
, "Overlapped structure is at %p\n", olp
);
6900 /* Test IOCP with duplicated handle (closing duplicated handle) */
6902 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
6905 SetLastError(0xdeadbeef);
6907 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
6908 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
6910 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
6911 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
6912 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
6914 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
6915 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6917 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
6918 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
6921 dup
= INVALID_SOCKET
;
6923 SetLastError(0xdeadbeef);
6925 num_bytes
= 0xdeadbeef;
6926 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6927 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
6928 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6929 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6930 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6931 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6932 ok(!olp
, "Overlapped structure is at %p\n", olp
);
6934 SetLastError(0xdeadbeef);
6936 num_bytes
= 0xdeadbeef;
6937 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6938 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
6939 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6940 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6941 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6942 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6943 ok(!olp
, "Overlapped structure is at %p\n", olp
);
6946 src
= INVALID_SOCKET
;
6948 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
6949 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6950 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
6951 ok(key
== 125, "Key is %lu\n", key
);
6952 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
6953 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
6954 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
6956 SetLastError(0xdeadbeef);
6958 num_bytes
= 0xdeadbeef;
6959 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6960 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
6961 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6962 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6963 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6964 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6965 ok(!olp
, "Overlapped structure is at %p\n", olp
);
6967 /* Test IOCP with duplicated handle (closing original handle) */
6969 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
6972 SetLastError(0xdeadbeef);
6974 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
6975 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
6977 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
6978 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
6979 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
6981 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
6982 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6984 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
6985 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
6988 src
= INVALID_SOCKET
;
6990 SetLastError(0xdeadbeef);
6992 num_bytes
= 0xdeadbeef;
6993 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6994 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
6995 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6996 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6997 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6998 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6999 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7002 dup
= INVALID_SOCKET
;
7004 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7005 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7006 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
7007 ok(key
== 125, "Key is %lu\n", key
);
7008 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7009 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7010 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7012 SetLastError(0xdeadbeef);
7014 num_bytes
= 0xdeadbeef;
7015 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7016 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7017 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7018 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7019 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7020 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7021 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7023 /* Test IOCP without AcceptEx */
7025 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
7028 SetLastError(0xdeadbeef);
7030 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
7031 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7034 src
= INVALID_SOCKET
;
7036 SetLastError(0xdeadbeef);
7038 num_bytes
= 0xdeadbeef;
7039 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7040 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7041 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7042 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7043 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7044 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7045 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7049 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
7052 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7053 if (connector
== INVALID_SOCKET
) {
7054 skip("could not create connector socket, error %d\n", WSAGetLastError());
7058 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
7059 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7061 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
7062 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7064 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7065 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7067 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7068 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7070 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7071 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
7073 closesocket(connector
);
7074 connector
= INVALID_SOCKET
;
7076 SetLastError(0xdeadbeef);
7078 num_bytes
= 0xdeadbeef;
7079 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7081 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7082 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
7083 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
7084 ok(key
== 125, "Key is %lu\n", key
);
7085 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7086 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7087 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7089 SetLastError(0xdeadbeef);
7091 num_bytes
= 0xdeadbeef;
7092 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7093 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7094 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7095 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7096 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7097 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7098 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7100 if (dest
!= INVALID_SOCKET
)
7102 if (src
!= INVALID_SOCKET
)
7107 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
7110 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
7111 if (dest
== INVALID_SOCKET
)
7113 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7117 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7118 if (connector
== INVALID_SOCKET
) {
7119 skip("could not create connector socket, error %d\n", WSAGetLastError());
7123 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
7124 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7126 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
7127 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7129 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7130 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7132 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7133 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7135 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7136 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
7138 iret
= send(connector
, buf
, 1, 0);
7139 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
7144 dest
= INVALID_SOCKET
;
7146 SetLastError(0xdeadbeef);
7148 num_bytes
= 0xdeadbeef;
7149 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7151 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7152 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
7153 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
7154 ok(key
== 125, "Key is %lu\n", key
);
7155 ok(num_bytes
== 1, "Number of bytes transferred is %u\n", num_bytes
);
7156 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7157 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7159 SetLastError(0xdeadbeef);
7161 num_bytes
= 0xdeadbeef;
7162 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7163 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7164 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7165 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7166 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7167 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7168 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7170 if (src
!= INVALID_SOCKET
)
7172 if (connector
!= INVALID_SOCKET
)
7173 closesocket(connector
);
7177 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
7180 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
7181 if (dest
== INVALID_SOCKET
)
7183 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7187 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7188 if (connector
== INVALID_SOCKET
) {
7189 skip("could not create connector socket, error %d\n", WSAGetLastError());
7193 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
7194 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7196 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
7197 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7199 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7200 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7202 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7203 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7205 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7206 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
7209 dest
= INVALID_SOCKET
;
7211 SetLastError(0xdeadbeef);
7213 num_bytes
= 0xdeadbeef;
7214 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7216 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7217 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7218 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
||
7219 GetLastError() == ERROR_OPERATION_ABORTED
||
7220 GetLastError() == ERROR_CONNECTION_ABORTED
, "Last error was %d\n", GetLastError());
7221 ok(key
== 125, "Key is %lu\n", key
);
7222 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7223 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7224 todo_wine
ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
||
7225 olp
->Internal
== (ULONG
)STATUS_CANCELLED
||
7226 olp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7228 SetLastError(0xdeadbeef);
7230 num_bytes
= 0xdeadbeef;
7231 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7232 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7233 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7234 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7235 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7236 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7237 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7241 if (dest
!= INVALID_SOCKET
)
7243 if (src
!= INVALID_SOCKET
)
7245 if (connector
!= INVALID_SOCKET
)
7246 closesocket(connector
);
7247 CloseHandle(previous_port
);
7250 static DWORD WINAPI
inet_ntoa_thread_proc(void *param
)
7254 HANDLE
*event
= param
;
7256 addr
= inet_addr("4.3.2.1");
7257 ok(addr
== htonl(0x04030201), "expected 0x04030201, got %08x\n", addr
);
7258 str
= inet_ntoa(*(struct in_addr
*)&addr
);
7259 ok(!strcmp(str
, "4.3.2.1"), "expected 4.3.2.1, got %s\n", str
);
7262 WaitForSingleObject(event
[1], 3000);
7267 static void test_inet_ntoa(void)
7271 HANDLE thread
, event
[2];
7274 addr
= inet_addr("1.2.3.4");
7275 ok(addr
== htonl(0x01020304), "expected 0x01020304, got %08x\n", addr
);
7276 str
= inet_ntoa(*(struct in_addr
*)&addr
);
7277 ok(!strcmp(str
, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str
);
7279 event
[0] = CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
7280 event
[1] = CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
7282 thread
= CreateThread(NULL
, 0, inet_ntoa_thread_proc
, event
, 0, &tid
);
7283 WaitForSingleObject(event
[0], 3000);
7285 ok(!strcmp(str
, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str
);
7288 WaitForSingleObject(thread
, 3000);
7290 CloseHandle(event
[0]);
7291 CloseHandle(event
[1]);
7292 CloseHandle(thread
);
7295 static void test_WSALookupService(void)
7297 char buffer
[4096], strbuff
[128];
7298 WSAQUERYSETW
*qs
= NULL
;
7302 DWORD error
, offset
, bsize
;
7304 if (!pWSALookupServiceBeginW
|| !pWSALookupServiceEnd
|| !pWSALookupServiceNextW
)
7306 win_skip("WSALookupServiceBeginW or WSALookupServiceEnd or WSALookupServiceNextW not found");
7310 qs
= (WSAQUERYSETW
*)buffer
;
7311 memset(qs
, 0, sizeof(*qs
));
7313 /* invalid parameter tests */
7314 ret
= pWSALookupServiceBeginW(NULL
, 0, &hnd
);
7315 error
= WSAGetLastError();
7316 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
7318 ok(error
== WSAEFAULT
, "expected 10014, got %d\n", error
);
7320 ret
= pWSALookupServiceBeginW(qs
, 0, NULL
);
7321 error
= WSAGetLastError();
7322 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
7324 ok(error
== WSAEFAULT
, "expected 10014, got %d\n", error
);
7326 ret
= pWSALookupServiceBeginW(qs
, 0, &hnd
);
7327 error
= WSAGetLastError();
7328 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
7330 ok(error
== WSAEINVAL
7331 || broken(error
== ERROR_INVALID_PARAMETER
) /* <= XP */
7332 || broken(error
== WSASERVICE_NOT_FOUND
) /* == 2000 */,
7333 "expected 10022, got %d\n", error
);
7335 ret
= pWSALookupServiceEnd(NULL
);
7336 error
= WSAGetLastError();
7338 ok(ret
== SOCKET_ERROR
, "WSALookupServiceEnd should have failed\n");
7340 ok(error
== ERROR_INVALID_HANDLE
, "expected 6, got %d\n", error
);
7342 /* standard network list query */
7343 qs
->dwSize
= sizeof(*qs
);
7344 hnd
= (HANDLE
)0xdeadbeef;
7345 ret
= pWSALookupServiceBeginW(qs
, LUP_RETURN_ALL
| LUP_DEEP
, &hnd
);
7346 error
= WSAGetLastError();
7347 if(ret
&& error
== ERROR_INVALID_PARAMETER
)
7349 win_skip("the current WSALookupServiceBeginW test is not supported in win 2000\n");
7354 ok(!ret
, "WSALookupServiceBeginW failed unexpectedly with error %d\n", error
);
7356 ok(hnd
!= (HANDLE
)0xdeadbeef, "Handle was not filled\n");
7361 memset(qs
, 0, sizeof(*qs
));
7362 bsize
= sizeof(buffer
);
7364 if (pWSALookupServiceNextW(hnd
, 0, &bsize
, qs
) == SOCKET_ERROR
)
7366 error
= WSAGetLastError();
7367 if (error
== WSA_E_NO_MORE
) break;
7368 ok(0, "Error %d happened while listing services\n", error
);
7372 WideCharToMultiByte(CP_ACP
, 0, qs
->lpszServiceInstanceName
, -1,
7373 strbuff
, sizeof(strbuff
), NULL
, NULL
);
7374 trace("Network Name: %s\n", strbuff
);
7376 /* network data is written in the blob field */
7379 /* each network may have multiple NLA_BLOB information structures */
7382 netdata
= (PNLA_BLOB
) &qs
->lpBlob
->pBlobData
[offset
];
7383 switch (netdata
->header
.type
)
7386 trace("\tNLA Data Type: NLA_RAW_DATA\n");
7389 trace("\tNLA Data Type: NLA_INTERFACE\n");
7390 trace("\t\tType: %d\n", netdata
->data
.interfaceData
.dwType
);
7391 trace("\t\tSpeed: %d\n", netdata
->data
.interfaceData
.dwSpeed
);
7392 trace("\t\tAdapter Name: %s\n", netdata
->data
.interfaceData
.adapterName
);
7394 case NLA_802_1X_LOCATION
:
7395 trace("\tNLA Data Type: NLA_802_1X_LOCATION\n");
7396 trace("\t\tInformation: %s\n", netdata
->data
.locationData
.information
);
7398 case NLA_CONNECTIVITY
:
7399 switch (netdata
->data
.connectivity
.type
)
7401 case NLA_NETWORK_AD_HOC
:
7402 trace("\t\tNetwork Type: AD HOC\n");
7404 case NLA_NETWORK_MANAGED
:
7405 trace("\t\tNetwork Type: Managed\n");
7407 case NLA_NETWORK_UNMANAGED
:
7408 trace("\t\tNetwork Type: Unmanaged\n");
7410 case NLA_NETWORK_UNKNOWN
:
7411 trace("\t\tNetwork Type: Unknown\n");
7413 switch (netdata
->data
.connectivity
.internet
)
7415 case NLA_INTERNET_NO
:
7416 trace("\t\tInternet connectivity: No\n");
7418 case NLA_INTERNET_YES
:
7419 trace("\t\tInternet connectivity: Yes\n");
7421 case NLA_INTERNET_UNKNOWN
:
7422 trace("\t\tInternet connectivity: Unknown\n");
7427 trace("\tNLA Data Type: NLA_ICS\n");
7428 trace("\t\tSpeed: %d\n",
7429 netdata
->data
.ICS
.remote
.speed
);
7430 trace("\t\tType: %d\n",
7431 netdata
->data
.ICS
.remote
.type
);
7432 trace("\t\tState: %d\n",
7433 netdata
->data
.ICS
.remote
.state
);
7434 WideCharToMultiByte(CP_ACP
, 0, netdata
->data
.ICS
.remote
.machineName
, -1,
7435 strbuff
, sizeof(strbuff
), NULL
, NULL
);
7436 trace("\t\tMachine Name: %s\n", strbuff
);
7437 WideCharToMultiByte(CP_ACP
, 0, netdata
->data
.ICS
.remote
.sharedAdapterName
, -1,
7438 strbuff
, sizeof(strbuff
), NULL
, NULL
);
7439 trace("\t\tShared Adapter Name: %s\n", strbuff
);
7442 trace("\tNLA Data Type: Unknown\n");
7451 ret
= pWSALookupServiceEnd(hnd
);
7452 ok(!ret
, "WSALookupServiceEnd failed unexpectedly\n");
7455 /**************** Main program ***************/
7461 /* Leave these tests at the beginning. They depend on WSAStartup not having been
7462 * called, which is done by Init() below. */
7463 test_WithoutWSAStartup();
7464 test_WithWSAStartup();
7469 test_set_getsockopt();
7470 test_so_reuseaddr();
7472 test_extendedSocketOptions();
7474 for (i
= 0; i
< sizeof(tests
)/sizeof(tests
[0]); i
++)
7476 trace ( " **** STARTING TEST %d ****\n", i
);
7477 do_test ( &tests
[i
] );
7478 trace ( " **** TEST %d COMPLETE ****\n", i
);
7483 test_getservbyname();
7485 test_WSADuplicateSocket();
7487 test_WSAAddressToStringA();
7488 test_WSAAddressToStringW();
7490 test_WSAStringToAddressA();
7491 test_WSAStringToAddressW();
7500 test_addr_to_print();
7503 test_gethostbyname_hack();
7513 test_GetAddrInfoW();
7518 test_sioRoutingInterfaceQuery();
7520 test_WSALookupService();
7522 test_WSAAsyncGetServByPort();
7523 test_WSAAsyncGetServByName();
7525 test_completion_port();
7527 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
7529 test_synchronous_WSAIoctl();