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_WINNT 0x0600
27 #define WIN32_NO_STATUS
28 #include <wine/test.h>
30 #include <wine/winternl.h>
40 // ReactOS: Wine has this in mstcpip.h, but it doesn't belong there
41 #define WSA_CMSG_ALIGN(len) (((len) + sizeof(SIZE_T) - 1) & ~(sizeof(SIZE_T) - 1))
43 #define MAX_CLIENTS 4 /* Max number of clients */
44 #define FIRST_CHAR 'A' /* First character in transferred pattern */
45 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
46 #define BIND_TRIES 6 /* Number of bind() attempts */
47 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
48 after server initialization, if something hangs */
50 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
52 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
53 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
55 #define SERVERIP "127.0.0.1" /* IP to bind to */
56 #define SERVERPORT 9374 /* Port number to bind to */
58 #define wsa_ok(op, cond, msg) \
62 if ( !(cond tmp) ) err = WSAGetLastError(); \
63 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
66 #define make_keepalive(k, enable, time, interval) \
68 k.keepalivetime = time; \
69 k.keepaliveinterval = interval;
71 /* Function pointers */
72 static void (WINAPI
*pfreeaddrinfo
)(struct addrinfo
*);
73 static int (WINAPI
*pgetaddrinfo
)(LPCSTR
,LPCSTR
,const struct addrinfo
*,struct addrinfo
**);
74 static void (WINAPI
*pFreeAddrInfoW
)(PADDRINFOW
);
75 static int (WINAPI
*pGetAddrInfoW
)(LPCWSTR
,LPCWSTR
,const ADDRINFOW
*,PADDRINFOW
*);
76 static PCSTR (WINAPI
*pInetNtop
)(INT
,LPVOID
,LPSTR
,ULONG
);
77 static PCWSTR(WINAPI
*pInetNtopW
)(INT
,LPVOID
,LPWSTR
,ULONG
);
78 static int (WINAPI
*pInetPtonA
)(INT
,LPCSTR
,LPVOID
);
79 static int (WINAPI
*pInetPtonW
)(INT
,LPWSTR
,LPVOID
);
80 static int (WINAPI
*pWSALookupServiceBeginW
)(LPWSAQUERYSETW
,DWORD
,LPHANDLE
);
81 static int (WINAPI
*pWSALookupServiceEnd
)(HANDLE
);
82 static int (WINAPI
*pWSALookupServiceNextW
)(HANDLE
,DWORD
,LPDWORD
,LPWSAQUERYSETW
);
83 static int (WINAPI
*pWSAEnumNameSpaceProvidersA
)(LPDWORD
,LPWSANAMESPACE_INFOA
);
84 static int (WINAPI
*pWSAEnumNameSpaceProvidersW
)(LPDWORD
,LPWSANAMESPACE_INFOW
);
85 static int (WINAPI
*pWSAPoll
)(WSAPOLLFD
*,ULONG
,INT
);
87 /* Function pointers from iphlpapi */
88 static DWORD (WINAPI
*pGetAdaptersInfo
)(PIP_ADAPTER_INFO
,PULONG
);
89 static DWORD (WINAPI
*pGetIpForwardTable
)(PMIB_IPFORWARDTABLE
,PULONG
,BOOL
);
91 /**************** Structs and typedefs ***************/
93 typedef struct thread_info
99 /* Information in the server about open client connections */
100 typedef struct sock_info
103 struct sockaddr_in addr
;
104 struct sockaddr_in peer
;
110 /* Test parameters for both server & client */
111 typedef struct test_params
115 const char *inet_addr
;
122 /* server-specific test parameters */
123 typedef struct server_params
125 test_params
*general
;
130 /* client-specific test parameters */
131 typedef struct client_params
133 test_params
*general
;
138 /* This type combines all information for setting up a test scenario */
139 typedef struct test_setup
143 server_params srv_params
;
145 client_params clt_params
;
148 /* Thread local storage for server */
149 typedef struct server_memory
152 struct sockaddr_in addr
;
153 sock_info sock
[MAX_CLIENTS
];
156 /* Thread local storage for client */
157 typedef struct client_memory
160 struct sockaddr_in addr
;
165 /* SelectReadThread thread parameters */
166 typedef struct select_thread_params
170 } select_thread_params
;
172 /* Tests used in both getaddrinfo and GetAddrInfoW */
173 static const struct addr_hint_tests
175 int family
, socktype
, protocol
;
178 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_TCP
, 0 },
179 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_UDP
, 0 },
180 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_IPV6
,0 },
181 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_TCP
, 0 },
182 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_UDP
, 0 },
183 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_IPV6
,0 },
184 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, 0 },
185 {AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, 0 },
186 {AF_INET
, SOCK_STREAM
, IPPROTO_IPV6
,0 },
187 {AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, 0 },
188 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, 0 },
189 {AF_INET
, SOCK_DGRAM
, IPPROTO_IPV6
,0 },
190 {AF_UNSPEC
, 0, IPPROTO_TCP
, 0 },
191 {AF_UNSPEC
, 0, IPPROTO_UDP
, 0 },
192 {AF_UNSPEC
, 0, IPPROTO_IPV6
,0 },
193 {AF_UNSPEC
, SOCK_STREAM
, 0, 0 },
194 {AF_UNSPEC
, SOCK_DGRAM
, 0, 0 },
195 {AF_INET
, 0, IPPROTO_TCP
, 0 },
196 {AF_INET
, 0, IPPROTO_UDP
, 0 },
197 {AF_INET
, 0, IPPROTO_IPV6
,0 },
198 {AF_INET
, SOCK_STREAM
, 0, 0 },
199 {AF_INET
, SOCK_DGRAM
, 0, 0 },
200 {AF_UNSPEC
, 999, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
201 {AF_UNSPEC
, 999, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
202 {AF_UNSPEC
, 999, IPPROTO_IPV6
,WSAESOCKTNOSUPPORT
},
203 {AF_INET
, 999, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
204 {AF_INET
, 999, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
205 {AF_INET
, 999, IPPROTO_IPV6
,WSAESOCKTNOSUPPORT
},
206 {AF_UNSPEC
, SOCK_STREAM
, 999, 0 },
207 {AF_UNSPEC
, SOCK_STREAM
, 999, 0 },
208 {AF_INET
, SOCK_DGRAM
, 999, 0 },
209 {AF_INET
, SOCK_DGRAM
, 999, 0 },
212 /**************** Static variables ***************/
214 static DWORD tls
; /* Thread local storage index */
215 static HANDLE thread
[1+MAX_CLIENTS
];
216 static DWORD thread_id
[1+MAX_CLIENTS
];
217 static HANDLE server_ready
;
218 static HANDLE client_ready
[MAX_CLIENTS
];
219 static int client_id
;
221 /**************** General utility functions ***************/
223 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
);
224 static SOCKET
setup_connector_socket(struct sockaddr_in
*addr
, int len
, BOOL nonblock
);
226 static int tcp_socketpair(SOCKET
*src
, SOCKET
*dst
)
228 SOCKET server
= INVALID_SOCKET
;
229 struct sockaddr_in addr
;
233 *src
= INVALID_SOCKET
;
234 *dst
= INVALID_SOCKET
;
236 *src
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
237 if (*src
== INVALID_SOCKET
)
240 server
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
241 if (server
== INVALID_SOCKET
)
244 memset(&addr
, 0, sizeof(addr
));
245 addr
.sin_family
= AF_INET
;
246 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
247 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
252 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
256 ret
= listen(server
, 1);
260 ret
= connect(*src
, (struct sockaddr
*)&addr
, sizeof(addr
));
265 *dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
268 if (server
!= INVALID_SOCKET
)
270 if (*src
!= INVALID_SOCKET
&& *dst
!= INVALID_SOCKET
)
277 static void set_so_opentype ( BOOL overlapped
)
279 int optval
= !overlapped
, newval
, len
= sizeof (int);
281 ok ( setsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
282 (LPVOID
) &optval
, sizeof (optval
) ) == 0,
283 "setting SO_OPENTYPE failed\n" );
284 ok ( getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
285 (LPVOID
) &newval
, &len
) == 0,
286 "getting SO_OPENTYPE failed\n" );
287 ok ( optval
== newval
, "failed to set SO_OPENTYPE\n" );
290 static int set_blocking ( SOCKET s
, BOOL blocking
)
292 u_long val
= !blocking
;
293 return ioctlsocket ( s
, FIONBIO
, &val
);
296 static void fill_buffer ( char *buf
, int chunk_size
, int n_chunks
)
299 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
300 memset ( p
, c
, chunk_size
);
303 static int test_buffer ( char *buf
, int chunk_size
, int n_chunks
)
307 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
309 for ( i
= 0; i
< chunk_size
; i
++ )
310 if ( p
[i
] != c
) return i
;
316 * This routine is called when a client / server does not expect any more data,
317 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
319 static void read_zero_bytes ( SOCKET s
)
323 while ( ( tmp
= recv ( s
, buf
, 256, 0 ) ) > 0 )
325 ok ( n
<= 0, "garbage data received: %d bytes\n", n
);
328 static int do_synchronous_send ( SOCKET s
, char *buf
, int buflen
, int flags
, int sendlen
)
330 char* last
= buf
+ buflen
, *p
;
332 for ( p
= buf
; n
> 0 && p
< last
; )
334 n
= send ( s
, p
, min ( sendlen
, last
- p
), flags
);
337 wsa_ok ( n
, 0 <=, "do_synchronous_send (%x): error %d\n" );
341 static int do_synchronous_recv ( SOCKET s
, char *buf
, int buflen
, int flags
, int recvlen
)
343 char* last
= buf
+ buflen
, *p
;
345 for ( p
= buf
; n
> 0 && p
< last
; )
347 n
= recv ( s
, p
, min ( recvlen
, last
- p
), flags
);
350 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
354 static int do_synchronous_recvfrom ( SOCKET s
, char *buf
, int buflen
, int flags
, struct sockaddr
*from
, int *fromlen
, int recvlen
)
356 char* last
= buf
+ buflen
, *p
;
358 for ( p
= buf
; n
> 0 && p
< last
; )
360 n
= recvfrom ( s
, p
, min ( recvlen
, last
- p
), flags
, from
, fromlen
);
363 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
368 * Call this routine right after thread startup.
369 * SO_OPENTYPE must by 0, regardless what the server did.
371 static void check_so_opentype (void)
375 getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
, (LPVOID
) &tmp
, &len
);
376 ok ( tmp
== 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp
);
379 static void compare_addrinfo (ADDRINFO
*a
, ADDRINFO
*b
)
381 for (; a
&& b
; a
= a
->ai_next
, b
= b
->ai_next
)
383 ok(a
->ai_flags
== b
->ai_flags
,
384 "Wrong flags %d != %d\n", a
->ai_flags
, b
->ai_flags
);
385 ok(a
->ai_family
== b
->ai_family
,
386 "Wrong family %d != %d\n", a
->ai_family
, b
->ai_family
);
387 ok(a
->ai_socktype
== b
->ai_socktype
,
388 "Wrong socktype %d != %d\n", a
->ai_socktype
, b
->ai_socktype
);
389 ok(a
->ai_protocol
== b
->ai_protocol
,
390 "Wrong protocol %d != %d\n", a
->ai_protocol
, b
->ai_protocol
);
391 ok(a
->ai_addrlen
== b
->ai_addrlen
,
392 "Wrong addrlen %lu != %lu\n", a
->ai_addrlen
, b
->ai_addrlen
);
393 ok(!memcmp(a
->ai_addr
, b
->ai_addr
, min(a
->ai_addrlen
, b
->ai_addrlen
)),
394 "Wrong address data\n");
395 if (a
->ai_canonname
&& b
->ai_canonname
)
397 ok(!strcmp(a
->ai_canonname
, b
->ai_canonname
), "Wrong canonical name '%s' != '%s'\n",
398 a
->ai_canonname
, b
->ai_canonname
);
401 ok(!a
->ai_canonname
&& !b
->ai_canonname
, "Expected both names absent (%p != %p)\n",
402 a
->ai_canonname
, b
->ai_canonname
);
404 ok(!a
&& !b
, "Expected both addresses null (%p != %p)\n", a
, b
);
407 static void compare_addrinfow (ADDRINFOW
*a
, ADDRINFOW
*b
)
409 for (; a
&& b
; a
= a
->ai_next
, b
= b
->ai_next
)
411 ok(a
->ai_flags
== b
->ai_flags
,
412 "Wrong flags %d != %d\n", a
->ai_flags
, b
->ai_flags
);
413 ok(a
->ai_family
== b
->ai_family
,
414 "Wrong family %d != %d\n", a
->ai_family
, b
->ai_family
);
415 ok(a
->ai_socktype
== b
->ai_socktype
,
416 "Wrong socktype %d != %d\n", a
->ai_socktype
, b
->ai_socktype
);
417 ok(a
->ai_protocol
== b
->ai_protocol
,
418 "Wrong protocol %d != %d\n", a
->ai_protocol
, b
->ai_protocol
);
419 ok(a
->ai_addrlen
== b
->ai_addrlen
,
420 "Wrong addrlen %lu != %lu\n", a
->ai_addrlen
, b
->ai_addrlen
);
421 ok(!memcmp(a
->ai_addr
, b
->ai_addr
, min(a
->ai_addrlen
, b
->ai_addrlen
)),
422 "Wrong address data\n");
423 if (a
->ai_canonname
&& b
->ai_canonname
)
425 ok(!lstrcmpW(a
->ai_canonname
, b
->ai_canonname
), "Wrong canonical name '%s' != '%s'\n",
426 wine_dbgstr_w(a
->ai_canonname
), wine_dbgstr_w(b
->ai_canonname
));
429 ok(!a
->ai_canonname
&& !b
->ai_canonname
, "Expected both names absent (%p != %p)\n",
430 a
->ai_canonname
, b
->ai_canonname
);
432 ok(!a
&& !b
, "Expected both addresses null (%p != %p)\n", a
, b
);
435 /**************** Server utility functions ***************/
438 * Even if we have closed our server socket cleanly,
439 * the OS may mark the address "in use" for some time -
440 * this happens with native Linux apps, too.
442 static void do_bind ( SOCKET s
, struct sockaddr
* addr
, int addrlen
)
444 int err
, wsaerr
= 0, n_try
= BIND_TRIES
;
446 while ( ( err
= bind ( s
, addr
, addrlen
) ) != 0 &&
447 ( wsaerr
= WSAGetLastError () ) == WSAEADDRINUSE
&&
450 trace ( "address in use, waiting ...\n" );
451 Sleep ( 1000 * BIND_SLEEP
);
453 ok ( err
== 0, "failed to bind: %d\n", wsaerr
);
456 static void server_start ( server_params
*par
)
459 test_params
*gen
= par
->general
;
460 server_memory
*mem
= LocalAlloc ( LPTR
, sizeof ( server_memory
) );
462 TlsSetValue ( tls
, mem
);
463 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
464 NULL
, 0, par
->sock_flags
);
465 ok ( mem
->s
!= INVALID_SOCKET
, "Server: WSASocket failed\n" );
467 mem
->addr
.sin_family
= AF_INET
;
468 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
469 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
471 for (i
= 0; i
< MAX_CLIENTS
; i
++)
473 mem
->sock
[i
].s
= INVALID_SOCKET
;
474 mem
->sock
[i
].buf
= LocalAlloc ( LPTR
, gen
->n_chunks
* gen
->chunk_size
);
475 mem
->sock
[i
].n_recvd
= 0;
476 mem
->sock
[i
].n_sent
= 0;
479 if ( gen
->sock_type
== SOCK_STREAM
)
480 do_bind ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof (mem
->addr
) );
483 static void server_stop (void)
486 server_memory
*mem
= TlsGetValue ( tls
);
488 for (i
= 0; i
< MAX_CLIENTS
; i
++ )
490 LocalFree ( mem
->sock
[i
].buf
);
491 if ( mem
->sock
[i
].s
!= INVALID_SOCKET
)
492 closesocket ( mem
->sock
[i
].s
);
494 ok ( closesocket ( mem
->s
) == 0, "closesocket failed\n" );
496 ExitThread ( GetCurrentThreadId () );
499 /**************** Client utilitiy functions ***************/
501 static void client_start ( client_params
*par
)
503 test_params
*gen
= par
->general
;
504 client_memory
*mem
= LocalAlloc (LPTR
, sizeof (client_memory
));
506 TlsSetValue ( tls
, mem
);
508 WaitForSingleObject ( server_ready
, INFINITE
);
510 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
511 NULL
, 0, par
->sock_flags
);
513 mem
->addr
.sin_family
= AF_INET
;
514 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
515 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
517 ok ( mem
->s
!= INVALID_SOCKET
, "Client: WSASocket failed\n" );
519 mem
->send_buf
= LocalAlloc ( LPTR
, 2 * gen
->n_chunks
* gen
->chunk_size
);
520 mem
->recv_buf
= mem
->send_buf
+ gen
->n_chunks
* gen
->chunk_size
;
521 fill_buffer ( mem
->send_buf
, gen
->chunk_size
, gen
->n_chunks
);
523 SetEvent ( client_ready
[client_id
] );
524 /* Wait for the other clients to come up */
525 WaitForMultipleObjects ( min ( gen
->n_clients
, MAX_CLIENTS
), client_ready
, TRUE
, INFINITE
);
528 static void client_stop (void)
530 client_memory
*mem
= TlsGetValue ( tls
);
531 wsa_ok ( closesocket ( mem
->s
), 0 ==, "closesocket error (%x): %d\n" );
532 LocalFree ( mem
->send_buf
);
537 /**************** Servers ***************/
540 * simple_server: A very basic server doing synchronous IO.
542 static VOID WINAPI
simple_server ( server_params
*par
)
544 test_params
*gen
= par
->general
;
546 int pos
, n_recvd
, n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
547 id
= GetCurrentThreadId();
549 trace ( "simple_server (%x) starting\n", id
);
551 set_so_opentype ( FALSE
); /* non-overlapped */
552 server_start ( par
);
553 mem
= TlsGetValue ( tls
);
555 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
556 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "simple_server (%x): listen failed: %d\n");
558 trace ( "simple_server (%x) ready\n", id
);
559 SetEvent ( server_ready
); /* notify clients */
561 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
563 trace ( "simple_server (%x): waiting for client\n", id
);
565 /* accept a single connection */
566 tmp
= sizeof ( mem
->sock
[0].peer
);
567 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
568 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "simple_server (%x): accept failed: %d\n" );
570 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
571 "simple_server (%x): strange peer address\n", id
);
573 /* Receive data & check it */
574 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
575 ok ( n_recvd
== n_expected
,
576 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
577 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
578 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
581 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
582 ok ( n_sent
== n_expected
,
583 "simple_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
586 read_zero_bytes ( mem
->sock
[0].s
);
587 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "simple_server (%x): closesocket error: %d\n" );
588 mem
->sock
[0].s
= INVALID_SOCKET
;
591 trace ( "simple_server (%x) exiting\n", id
);
596 * oob_server: A very basic server receiving out-of-band data.
598 static VOID WINAPI
oob_server ( server_params
*par
)
600 test_params
*gen
= par
->general
;
603 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
,
604 id
= GetCurrentThreadId();
606 trace ( "oob_server (%x) starting\n", id
);
608 set_so_opentype ( FALSE
); /* non-overlapped */
609 server_start ( par
);
610 mem
= TlsGetValue ( tls
);
612 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
613 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "oob_server (%x): listen failed: %d\n");
615 trace ( "oob_server (%x) ready\n", id
);
616 SetEvent ( server_ready
); /* notify clients */
618 trace ( "oob_server (%x): waiting for client\n", id
);
620 /* accept a single connection */
621 tmp
= sizeof ( mem
->sock
[0].peer
);
622 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
623 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "oob_server (%x): accept failed: %d\n" );
625 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
626 "oob_server (%x): strange peer address\n", id
);
628 /* check initial atmark state */
629 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
630 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
632 /* Receive normal data */
633 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
634 ok ( n_recvd
== n_expected
,
635 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
636 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
637 ok ( pos
== -1, "oob_server (%x): test pattern error: %d\n", id
, pos
);
639 /* check atmark state */
640 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
641 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
644 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
645 ok ( n_sent
== n_expected
,
646 "oob_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
648 /* Receive a part of the out-of-band data and print atmark state */
649 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, 8, 0, par
->buflen
);
651 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, 8 );
654 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
655 trace( "oob_server (%x): %s the OOB mark: %i\n", id
, atmark
== 1 ? "not at" : "at", atmark
);
657 /* Receive the rest of the out-of-band data and check atmark state */
658 do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, 0, par
->buflen
);
660 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
661 todo_wine
ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %i\n", id
, atmark
);
664 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "oob_server (%x): closesocket error: %d\n" );
665 mem
->sock
[0].s
= INVALID_SOCKET
;
667 trace ( "oob_server (%x) exiting\n", id
);
672 * select_server: A non-blocking server.
674 static VOID WINAPI
select_server ( server_params
*par
)
676 test_params
*gen
= par
->general
;
678 int n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
679 id
= GetCurrentThreadId(), n_connections
= 0, n_sent
, n_recvd
,
680 n_set
, delta
, n_ready
;
681 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
682 fd_set fds_recv
, fds_send
, fds_openrecv
, fds_opensend
;
684 trace ( "select_server (%x) starting\n", id
);
686 set_so_opentype ( FALSE
); /* non-overlapped */
687 server_start ( par
);
688 mem
= TlsGetValue ( tls
);
690 wsa_ok ( set_blocking ( mem
->s
, FALSE
), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
691 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "select_server (%x): listen failed: %d\n");
693 trace ( "select_server (%x) ready\n", id
);
694 SetEvent ( server_ready
); /* notify clients */
696 FD_ZERO ( &fds_openrecv
);
697 FD_ZERO ( &fds_recv
);
698 FD_ZERO ( &fds_send
);
699 FD_ZERO ( &fds_opensend
);
701 FD_SET ( mem
->s
, &fds_openrecv
);
705 fds_recv
= fds_openrecv
;
706 fds_send
= fds_opensend
;
710 wsa_ok ( ( n_ready
= select ( 0, &fds_recv
, &fds_send
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
711 "select_server (%x): select() failed: %d\n" );
713 /* check for incoming requests */
714 if ( FD_ISSET ( mem
->s
, &fds_recv
) ) {
717 trace ( "select_server (%x): accepting client connection\n", id
);
719 /* accept a single connection */
720 tmp
= sizeof ( mem
->sock
[n_connections
].peer
);
721 mem
->sock
[n_connections
].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[n_connections
].peer
, &tmp
);
722 wsa_ok ( mem
->sock
[n_connections
].s
, INVALID_SOCKET
!=, "select_server (%x): accept() failed: %d\n" );
724 ok ( mem
->sock
[n_connections
].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
725 "select_server (%x): strange peer address\n", id
);
727 /* add to list of open connections */
728 FD_SET ( mem
->sock
[n_connections
].s
, &fds_openrecv
);
729 FD_SET ( mem
->sock
[n_connections
].s
, &fds_opensend
);
734 /* handle open requests */
736 for ( i
= 0; i
< n_connections
; i
++ )
738 if ( FD_ISSET( mem
->sock
[i
].s
, &fds_recv
) ) {
741 if ( mem
->sock
[i
].n_recvd
< n_expected
) {
742 /* Receive data & check it */
743 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 );
744 ok ( n_recvd
!= SOCKET_ERROR
, "select_server (%x): error in recv(): %d\n", id
, WSAGetLastError() );
745 mem
->sock
[i
].n_recvd
+= n_recvd
;
747 if ( mem
->sock
[i
].n_recvd
== n_expected
) {
748 int pos
= test_buffer ( mem
->sock
[i
].buf
, gen
->chunk_size
, gen
->n_chunks
);
749 ok ( pos
== -1, "select_server (%x): test pattern error: %d\n", id
, pos
);
750 FD_CLR ( mem
->sock
[i
].s
, &fds_openrecv
);
753 ok ( mem
->sock
[i
].n_recvd
<= n_expected
, "select_server (%x): received too many bytes: %d\n", id
, mem
->sock
[i
].n_recvd
);
757 /* only echo back what we've received */
758 delta
= mem
->sock
[i
].n_recvd
- mem
->sock
[i
].n_sent
;
760 if ( FD_ISSET ( mem
->sock
[i
].s
, &fds_send
) ) {
763 if ( ( delta
> 0 ) && ( mem
->sock
[i
].n_sent
< n_expected
) ) {
765 n_sent
= send ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_sent
, min ( delta
, par
->buflen
), 0 );
766 ok ( n_sent
!= SOCKET_ERROR
, "select_server (%x): error in send(): %d\n", id
, WSAGetLastError() );
767 mem
->sock
[i
].n_sent
+= n_sent
;
769 if ( mem
->sock
[i
].n_sent
== n_expected
) {
770 FD_CLR ( mem
->sock
[i
].s
, &fds_opensend
);
773 ok ( mem
->sock
[i
].n_sent
<= n_expected
, "select_server (%x): sent too many bytes: %d\n", id
, mem
->sock
[i
].n_sent
);
778 /* check that select returned the correct number of ready sockets */
779 ok ( ( n_set
== n_ready
), "select_server (%x): select() returns wrong number of ready sockets\n", id
);
781 /* check if all clients are done */
782 if ( ( fds_opensend
.fd_count
== 0 )
783 && ( fds_openrecv
.fd_count
== 1 ) /* initial socket that accepts clients */
784 && ( n_connections
== min ( gen
->n_clients
, MAX_CLIENTS
) ) ) {
789 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
792 read_zero_bytes ( mem
->sock
[i
].s
);
793 wsa_ok ( closesocket ( mem
->sock
[i
].s
), 0 ==, "select_server (%x): closesocket error: %d\n" );
794 mem
->sock
[i
].s
= INVALID_SOCKET
;
797 trace ( "select_server (%x) exiting\n", id
);
801 /**************** Clients ***************/
804 * simple_client: A very basic client doing synchronous IO.
806 static VOID WINAPI
simple_client ( client_params
*par
)
808 test_params
*gen
= par
->general
;
810 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
812 id
= GetCurrentThreadId();
813 trace ( "simple_client (%x): starting\n", id
);
814 /* wait here because we want to call set_so_opentype before creating a socket */
815 WaitForSingleObject ( server_ready
, INFINITE
);
816 trace ( "simple_client (%x): server ready\n", id
);
818 check_so_opentype ();
819 set_so_opentype ( FALSE
); /* non-overlapped */
820 client_start ( par
);
821 mem
= TlsGetValue ( tls
);
824 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
825 0 ==, "simple_client (%x): connect error: %d\n" );
826 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
827 "simple_client (%x): failed to set blocking mode\n", id
);
828 trace ( "simple_client (%x) connected\n", id
);
830 /* send data to server */
831 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
832 ok ( n_sent
== n_expected
,
833 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
835 /* shutdown send direction */
836 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
838 /* Receive data echoed back & check it */
839 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
840 ok ( n_recvd
== n_expected
,
841 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
844 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
845 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
848 read_zero_bytes ( mem
->s
);
849 trace ( "simple_client (%x) exiting\n", id
);
854 * oob_client: A very basic client sending out-of-band data.
856 static VOID WINAPI
oob_client ( client_params
*par
)
858 test_params
*gen
= par
->general
;
860 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
862 id
= GetCurrentThreadId();
863 trace ( "oob_client (%x): starting\n", id
);
864 /* wait here because we want to call set_so_opentype before creating a socket */
865 WaitForSingleObject ( server_ready
, INFINITE
);
866 trace ( "oob_client (%x): server ready\n", id
);
868 check_so_opentype ();
869 set_so_opentype ( FALSE
); /* non-overlapped */
870 client_start ( par
);
871 mem
= TlsGetValue ( tls
);
874 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
875 0 ==, "oob_client (%x): connect error: %d\n" );
876 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
877 "oob_client (%x): failed to set blocking mode\n", id
);
878 trace ( "oob_client (%x) connected\n", id
);
880 /* send data to server */
881 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
882 ok ( n_sent
== n_expected
,
883 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
885 /* Receive data echoed back & check it */
886 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, 0, par
->buflen
);
887 ok ( n_recvd
== n_expected
,
888 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
889 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
890 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
892 /* send out-of-band data to server */
893 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, MSG_OOB
, par
->buflen
);
894 ok ( n_sent
== n_expected
,
895 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
897 /* shutdown send direction */
898 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
901 read_zero_bytes ( mem
->s
);
902 trace ( "oob_client (%x) exiting\n", id
);
907 * simple_mixed_client: mixing send and recvfrom
909 static VOID WINAPI
simple_mixed_client ( client_params
*par
)
911 test_params
*gen
= par
->general
;
913 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
914 int fromLen
= sizeof(mem
->addr
);
915 struct sockaddr test
;
917 id
= GetCurrentThreadId();
918 trace ( "simple_client (%x): starting\n", id
);
919 /* wait here because we want to call set_so_opentype before creating a socket */
920 WaitForSingleObject ( server_ready
, INFINITE
);
921 trace ( "simple_client (%x): server ready\n", id
);
923 check_so_opentype ();
924 set_so_opentype ( FALSE
); /* non-overlapped */
925 client_start ( par
);
926 mem
= TlsGetValue ( tls
);
929 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
930 0 ==, "simple_client (%x): connect error: %d\n" );
931 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
932 "simple_client (%x): failed to set blocking mode\n", id
);
933 trace ( "simple_client (%x) connected\n", id
);
935 /* send data to server */
936 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, 0, par
->buflen
);
937 ok ( n_sent
== n_expected
,
938 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
940 /* shutdown send direction */
941 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
943 /* this shouldn't change, since lpFrom, is not updated on
944 connection oriented sockets - exposed by bug 11640
946 ((struct sockaddr_in
*)&test
)->sin_addr
.s_addr
= inet_addr("0.0.0.0");
948 /* Receive data echoed back & check it */
949 n_recvd
= do_synchronous_recvfrom ( mem
->s
,
953 (struct sockaddr
*)&test
,
956 ok ( n_recvd
== n_expected
,
957 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
959 /* check that lpFrom was not updated */
962 inet_ntoa(((struct sockaddr_in
*)&test
)->sin_addr
),
963 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
966 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
967 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
970 read_zero_bytes ( mem
->s
);
971 trace ( "simple_client (%x) exiting\n", id
);
976 * event_client: An event-driven client
978 static void WINAPI
event_client ( client_params
*par
)
980 test_params
*gen
= par
->general
;
982 int id
= GetCurrentThreadId(), n_expected
= gen
->n_chunks
* gen
->chunk_size
,
985 WSANETWORKEVENTS wsa_events
;
986 char *send_last
, *recv_last
, *send_p
, *recv_p
;
987 LONG mask
= FD_READ
| FD_WRITE
| FD_CLOSE
;
989 trace ( "event_client (%x): starting\n", id
);
990 client_start ( par
);
991 trace ( "event_client (%x): server ready\n", id
);
993 mem
= TlsGetValue ( tls
);
995 /* Prepare event notification for connect, makes socket nonblocking */
996 event
= WSACreateEvent ();
997 WSAEventSelect ( mem
->s
, event
, FD_CONNECT
);
998 tmp
= connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) );
1000 err
= WSAGetLastError ();
1001 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): connect error: %d\n", id
, err
);
1002 tmp
= WaitForSingleObject ( event
, INFINITE
);
1003 ok ( tmp
== WAIT_OBJECT_0
, "event_client (%x): wait for connect event failed: %d\n", id
, tmp
);
1004 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
1005 ok ( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
1006 err
= wsa_events
.iErrorCode
[ FD_CONNECT_BIT
];
1007 ok ( err
== 0, "event_client (%x): connect error: %d\n", id
, err
);
1008 if ( err
) goto out
;
1011 trace ( "event_client (%x) connected\n", id
);
1013 WSAEventSelect ( mem
->s
, event
, mask
);
1015 recv_p
= mem
->recv_buf
;
1016 recv_last
= mem
->recv_buf
+ n_expected
;
1017 send_p
= mem
->send_buf
;
1018 send_last
= mem
->send_buf
+ n_expected
;
1022 err
= WaitForSingleObject ( event
, INFINITE
);
1023 ok ( err
== WAIT_OBJECT_0
, "event_client (%x): wait failed\n", id
);
1025 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
1026 ok( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
1028 if ( wsa_events
.lNetworkEvents
& FD_WRITE
)
1030 err
= wsa_events
.iErrorCode
[ FD_WRITE_BIT
];
1031 ok ( err
== 0, "event_client (%x): FD_WRITE error code: %d\n", id
, err
);
1036 n
= send ( mem
->s
, send_p
, min ( send_last
- send_p
, par
->buflen
), 0 );
1039 err
= WSAGetLastError ();
1040 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): send error: %d\n", id
, err
);
1045 while ( n
>= 0 && send_p
< send_last
);
1047 if ( send_p
== send_last
)
1049 trace ( "event_client (%x): all data sent - shutdown\n", id
);
1050 shutdown ( mem
->s
, SD_SEND
);
1052 WSAEventSelect ( mem
->s
, event
, mask
);
1055 if ( wsa_events
.lNetworkEvents
& FD_READ
)
1057 err
= wsa_events
.iErrorCode
[ FD_READ_BIT
];
1058 ok ( err
== 0, "event_client (%x): FD_READ error code: %d\n", id
, err
);
1059 if ( err
!= 0 ) break;
1061 /* First read must succeed */
1062 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
1063 wsa_ok ( n
, 0 <=, "event_client (%x): recv error: %d\n" );
1067 if ( recv_p
== recv_last
)
1070 trace ( "event_client (%x): all data received\n", id
);
1071 WSAEventSelect ( mem
->s
, event
, mask
);
1074 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
1075 if ( n
< 0 && ( err
= WSAGetLastError()) != WSAEWOULDBLOCK
)
1076 ok ( 0, "event_client (%x): read error: %d\n", id
, err
);
1080 if ( wsa_events
.lNetworkEvents
& FD_CLOSE
)
1082 trace ( "event_client (%x): close event\n", id
);
1083 err
= wsa_events
.iErrorCode
[ FD_CLOSE_BIT
];
1084 ok ( err
== 0, "event_client (%x): FD_CLOSE error code: %d\n", id
, err
);
1089 n
= send_p
- mem
->send_buf
;
1090 ok ( send_p
== send_last
,
1091 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n
, n_expected
);
1092 n
= recv_p
- mem
->recv_buf
;
1093 ok ( recv_p
== recv_last
,
1094 "simple_client (%x): received less data than expected: %d of %d\n", id
, n
, n_expected
);
1095 n
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
1096 ok ( n
== -1, "event_client (%x): test pattern error: %d\n", id
, n
);
1099 WSACloseEvent ( event
);
1100 trace ( "event_client (%x) exiting\n", id
);
1104 /* Tests for WSAStartup */
1105 static void test_WithoutWSAStartup(void)
1109 WSASetLastError(0xdeadbeef);
1110 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
, "WSASocketA should have failed\n");
1111 err
= WSAGetLastError();
1112 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
1114 WSASetLastError(0xdeadbeef);
1115 ok(gethostbyname("localhost") == NULL
, "gethostbyname() succeeded unexpectedly\n");
1116 err
= WSAGetLastError();
1117 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
1120 static void test_WithWSAStartup(void)
1123 WORD version
= MAKEWORD( 2, 2 );
1124 INT res
, socks
, i
, j
;
1129 SOCKET src
, dst
, dup_src
, dup_dst
;
1133 res
= WSAStartup( version
, &data
);
1134 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1136 ptr
= gethostbyname("localhost");
1137 ok(ptr
!= NULL
, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1139 /* Alloc some sockets to check if they are destroyed on WSACleanup */
1140 for (socks
= 0; socks
< sizeof(pairs
) / sizeof(pairs
[0]); socks
++)
1142 WSAPROTOCOL_INFOA info
;
1143 if (tcp_socketpair(&pairs
[socks
].src
, &pairs
[socks
].dst
)) break;
1145 memset(&info
, 0, sizeof(info
));
1146 ok(!WSADuplicateSocketA(pairs
[socks
].src
, GetCurrentProcessId(), &info
),
1147 "WSADuplicateSocketA should have worked\n");
1148 pairs
[socks
].dup_src
= WSASocketA(0, 0, 0, &info
, 0, 0);
1149 ok(pairs
[socks
].dup_src
!= SOCKET_ERROR
, "expected != -1\n");
1151 memset(&info
, 0, sizeof(info
));
1152 ok(!WSADuplicateSocketA(pairs
[socks
].dst
, GetCurrentProcessId(), &info
),
1153 "WSADuplicateSocketA should have worked\n");
1154 pairs
[socks
].dup_dst
= WSASocketA(0, 0, 0, &info
, 0, 0);
1155 ok(pairs
[socks
].dup_dst
!= SOCKET_ERROR
, "expected != -1\n");
1158 res
= send(pairs
[0].src
, "TEST", 4, 0);
1159 ok(res
== 4, "send failed with error %d\n", WSAGetLastError());
1163 res
= WSAStartup( version
, &data
);
1164 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1166 /* show that sockets are destroyed automatically after WSACleanup */
1167 SetLastError(0xdeadbeef);
1168 res
= send(pairs
[0].src
, "TEST", 4, 0);
1169 error
= WSAGetLastError();
1170 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1171 todo_wine
ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1173 SetLastError(0xdeadbeef);
1174 res
= send(pairs
[0].dst
, "TEST", 4, 0);
1175 error
= WSAGetLastError();
1176 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1177 todo_wine
ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1179 /* Check that all sockets were destroyed */
1180 for (i
= 0; i
< socks
; i
++)
1182 for (j
= 0; j
< 4; j
++)
1184 struct sockaddr_in saddr
;
1185 int size
= sizeof(saddr
);
1188 case 0: sock
= pairs
[i
].src
; break;
1189 case 1: sock
= pairs
[i
].dup_src
; break;
1190 case 2: sock
= pairs
[i
].dst
; break;
1191 case 3: sock
= pairs
[i
].dup_dst
; break;
1194 SetLastError(0xdeadbeef);
1195 res
= getsockname(sock
, (struct sockaddr
*)&saddr
, &size
);
1196 error
= WSAGetLastError();
1197 ok(res
== SOCKET_ERROR
, "Test[%d]: getsockname should have failed\n", i
);
1198 todo_wine
ok(error
== WSAENOTSOCK
, "Test[%d]: expected 10038, got %d\n", i
, error
);
1202 /* While wine is not fixed, close all sockets manually */
1203 for (i
= 0; i
< socks
; i
++)
1205 closesocket(pairs
[i
].src
);
1206 closesocket(pairs
[i
].dst
);
1207 closesocket(pairs
[i
].dup_src
);
1208 closesocket(pairs
[i
].dup_dst
);
1212 ok(res
== 0, "expected 0, got %d\n", res
);
1213 WSASetLastError(0xdeadbeef);
1215 error
= WSAGetLastError();
1216 ok ( (res
== SOCKET_ERROR
&& error
== WSANOTINITIALISED
) ||
1217 broken(res
== 0), /* WinME */
1218 "WSACleanup returned %d WSAGetLastError is %d\n", res
, error
);
1221 /**************** Main program utility functions ***************/
1223 static void Init (void)
1225 WORD ver
= MAKEWORD (2, 2);
1227 HMODULE hws2_32
= GetModuleHandleA("ws2_32.dll"), hiphlpapi
;
1229 pfreeaddrinfo
= (void *)GetProcAddress(hws2_32
, "freeaddrinfo");
1230 pgetaddrinfo
= (void *)GetProcAddress(hws2_32
, "getaddrinfo");
1231 pFreeAddrInfoW
= (void *)GetProcAddress(hws2_32
, "FreeAddrInfoW");
1232 pGetAddrInfoW
= (void *)GetProcAddress(hws2_32
, "GetAddrInfoW");
1233 pInetNtop
= (void *)GetProcAddress(hws2_32
, "inet_ntop");
1234 pInetNtopW
= (void *)GetProcAddress(hws2_32
, "InetNtopW");
1235 pInetPtonA
= (void *)GetProcAddress(hws2_32
, "inet_pton");
1236 pInetPtonW
= (void *)GetProcAddress(hws2_32
, "InetPtonW");
1237 pWSALookupServiceBeginW
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceBeginW");
1238 pWSALookupServiceEnd
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceEnd");
1239 pWSALookupServiceNextW
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceNextW");
1240 pWSAEnumNameSpaceProvidersA
= (void *)GetProcAddress(hws2_32
, "WSAEnumNameSpaceProvidersA");
1241 pWSAEnumNameSpaceProvidersW
= (void *)GetProcAddress(hws2_32
, "WSAEnumNameSpaceProvidersW");
1242 pWSAPoll
= (void *)GetProcAddress(hws2_32
, "WSAPoll");
1244 hiphlpapi
= LoadLibraryA("iphlpapi.dll");
1247 pGetIpForwardTable
= (void *)GetProcAddress(hiphlpapi
, "GetIpForwardTable");
1248 pGetAdaptersInfo
= (void *)GetProcAddress(hiphlpapi
, "GetAdaptersInfo");
1251 ok ( WSAStartup ( ver
, &data
) == 0, "WSAStartup failed\n" );
1255 static void Exit (void)
1260 err
= WSAGetLastError();
1261 ok ( ret
== 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret
, err
);
1264 static void StartServer (LPTHREAD_START_ROUTINE routine
,
1265 test_params
*general
, server_params
*par
)
1267 par
->general
= general
;
1268 thread
[0] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[0] );
1269 ok ( thread
[0] != NULL
, "Failed to create server thread\n" );
1272 static void StartClients (LPTHREAD_START_ROUTINE routine
,
1273 test_params
*general
, client_params
*par
)
1276 par
->general
= general
;
1277 for ( i
= 1; i
<= min ( general
->n_clients
, MAX_CLIENTS
); i
++ )
1280 thread
[i
] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[i
] );
1281 ok ( thread
[i
] != NULL
, "Failed to create client thread\n" );
1282 /* Make sure the client is up and running */
1283 WaitForSingleObject ( client_ready
[client_id
], INFINITE
);
1287 static void do_test( test_setup
*test
)
1289 DWORD i
, n
= min (test
->general
.n_clients
, MAX_CLIENTS
);
1292 server_ready
= CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1293 for (i
= 0; i
<= n
; i
++)
1294 client_ready
[i
] = CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1296 StartServer ( test
->srv
, &test
->general
, &test
->srv_params
);
1297 StartClients ( test
->clt
, &test
->general
, &test
->clt_params
);
1298 WaitForSingleObject ( server_ready
, INFINITE
);
1300 wait
= WaitForMultipleObjects ( 1 + n
, thread
, TRUE
, 1000 * TEST_TIMEOUT
);
1301 ok ( wait
<= WAIT_OBJECT_0
+ n
,
1302 "some threads have not completed: %x\n", wait
);
1304 if ( ! ( wait
<= WAIT_OBJECT_0
+ n
) )
1306 for (i
= 0; i
<= n
; i
++)
1308 if ( WaitForSingleObject ( thread
[i
], 0 ) != WAIT_OBJECT_0
)
1310 trace ("terminating thread %08x\n", thread_id
[i
]);
1311 TerminateThread ( thread
[i
], 0 );
1315 CloseHandle ( server_ready
);
1316 for (i
= 0; i
<= n
; i
++)
1317 CloseHandle ( client_ready
[i
] );
1320 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1321 /* optname = SO_LINGER */
1322 static const LINGER linger_testvals
[] = {
1329 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1330 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1331 bug in the linux kernel (fixed in 2.6.8) */
1332 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1334 static void test_set_getsockopt(void)
1337 int i
, err
, lasterr
;
1341 WSAPROTOCOL_INFOA infoA
;
1342 WSAPROTOCOL_INFOW infoW
;
1343 char providername
[WSAPROTOCOL_LEN
+ 1];
1347 int family
, type
, proto
;
1349 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
1350 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
1351 {AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
},
1352 {AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
}
1360 s
= socket(AF_INET
, SOCK_STREAM
, 0);
1361 ok(s
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1362 if( s
== INVALID_SOCKET
) return;
1364 timeout
= SOCKTIMEOUT1
;
1365 size
= sizeof(timeout
);
1366 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1368 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1369 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1370 ok( timeout
== SOCKTIMEOUT1
, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1373 size
= sizeof(timeout
);
1374 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1376 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1377 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1378 ok( timeout
== 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1381 timeout
= SOCKTIMEOUT2
; /* 997 seconds. See remark above */
1382 size
= sizeof(timeout
);
1383 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, size
);
1385 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, &size
);
1386 ok( !err
, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1387 ok( timeout
== SOCKTIMEOUT2
, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout
);
1391 size
= sizeof(value
);
1392 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, size
);
1393 ok( !err
, "setsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1395 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDBUF
, (char *)&value
, &size
);
1396 ok( !err
, "getsockopt(SO_SNDBUF) failed error: %u\n", WSAGetLastError() );
1397 ok( value
== 4096, "expected 4096, got %u\n", value
);
1401 size
= sizeof(value
);
1402 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, size
);
1403 ok( !err
, "setsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1405 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVBUF
, (char *)&value
, &size
);
1406 ok( !err
, "getsockopt(SO_RCVBUF) failed error: %u\n", WSAGetLastError() );
1407 ok( value
== 4096, "expected 4096, got %u\n", value
);
1410 for( i
= 0; i
< sizeof(linger_testvals
)/sizeof(LINGER
);i
++) {
1411 size
= sizeof(lingval
);
1412 lingval
= linger_testvals
[i
];
1413 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, size
);
1415 err
= getsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, &size
);
1416 ok( !err
, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1417 ok( !lingval
.l_onoff
== !linger_testvals
[i
].l_onoff
&&
1418 (lingval
.l_linger
== linger_testvals
[i
].l_linger
||
1419 (!lingval
.l_linger
&& !linger_testvals
[i
].l_onoff
))
1420 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i
,
1421 lingval
.l_onoff
, lingval
.l_linger
,
1422 linger_testvals
[i
].l_onoff
, linger_testvals
[i
].l_linger
);
1425 size
= sizeof(lingval
);
1426 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, size
);
1427 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1428 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1429 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, 0);
1430 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1431 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1433 size
= sizeof(BOOL
);
1434 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, size
);
1435 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1436 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1437 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, 0);
1438 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1439 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1441 /* Test for erroneously passing a value instead of a pointer as optval */
1442 size
= sizeof(char);
1443 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTROUTE
, (char *)1, size
);
1444 ok(err
== SOCKET_ERROR
, "setsockopt with optval being a value passed "
1445 "instead of failing.\n");
1446 lasterr
= WSAGetLastError();
1447 ok(lasterr
== WSAEFAULT
, "setsockopt with optval being a value "
1448 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1449 lasterr
, WSAEFAULT
);
1451 /* SO_RCVTIMEO with invalid values for level */
1452 size
= sizeof(timeout
);
1453 timeout
= SOCKTIMEOUT1
;
1454 SetLastError(0xdeadbeef);
1455 err
= setsockopt(s
, 0xffffffff, SO_RCVTIMEO
, (char *) &timeout
, size
);
1456 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1457 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1458 err
, WSAGetLastError());
1460 timeout
= SOCKTIMEOUT1
;
1461 SetLastError(0xdeadbeef);
1462 err
= setsockopt(s
, 0x00008000, SO_RCVTIMEO
, (char *) &timeout
, size
);
1463 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1464 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1465 err
, WSAGetLastError());
1467 /* Test SO_ERROR set/get */
1468 SetLastError(0xdeadbeef);
1470 err
= setsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, size
);
1472 ok( !err
&& !WSAGetLastError(),
1473 "got %d with %d (expected 0 with 0)\n",
1474 err
, WSAGetLastError());
1476 SetLastError(0xdeadbeef);
1478 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1480 ok( !err
&& !WSAGetLastError(),
1481 "got %d with %d (expected 0 with 0)\n",
1482 err
, WSAGetLastError());
1484 ok (i
== 1234, "got %d (expected 1234)\n", i
);
1486 /* Test invalid optlen */
1487 SetLastError(0xdeadbeef);
1489 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1491 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEFAULT
),
1492 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1493 err
, WSAGetLastError());
1496 /* Test with the closed socket */
1497 SetLastError(0xdeadbeef);
1500 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1502 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOTSOCK
),
1503 "got %d with %d (expected SOCKET_ERROR with WSAENOTSOCK)\n",
1504 err
, WSAGetLastError());
1505 ok (i
== 1234, "expected 1234, got %d\n", i
);
1507 /* Test WS_IP_MULTICAST_TTL with 8, 16, 24 and 32 bits values */
1508 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
1509 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1512 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &i
, size
);
1515 for (i
= 0; i
< 4; i
++)
1518 const int tests
[] = {0xffffff0a, 0xffff000b, 0xff00000c, 0x0000000d};
1519 err
= setsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &tests
[i
], i
+ 1);
1520 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1521 err
= getsockopt(s
, IPPROTO_IP
, IP_MULTICAST_TTL
, (char *) &k
, &size
);
1522 ok(!err
, "Test [%d] Expected 0, got %d\n", i
, err
);
1523 j
= i
!= 3 ? tests
[i
] & ((1 << (i
+ 1) * 8) - 1) : tests
[i
];
1524 ok(k
== j
, "Test [%d] Expected 0x%x, got 0x%x\n", i
, j
, k
);
1528 win_skip("IP_MULTICAST_TTL is unsupported\n");
1531 /* test SO_PROTOCOL_INFOA invalid parameters */
1532 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1533 "getsockopt should have failed\n");
1534 err
= WSAGetLastError();
1535 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1536 size
= sizeof(WSAPROTOCOL_INFOA
);
1537 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1538 "getsockopt should have failed\n");
1539 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1540 err
= WSAGetLastError();
1541 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1542 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1543 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1544 "getsockopt should have failed\n");
1545 err
= WSAGetLastError();
1546 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1547 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, NULL
),
1548 "getsockopt should have failed\n");
1549 err
= WSAGetLastError();
1550 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1551 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, &size
),
1552 "getsockopt should have failed\n");
1553 err
= WSAGetLastError();
1554 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1555 size
= sizeof(WSAPROTOCOL_INFOA
) / 2;
1556 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1557 "getsockopt should have failed\n");
1558 err
= WSAGetLastError();
1559 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1560 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1561 size
= sizeof(WSAPROTOCOL_INFOA
) * 2;
1562 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1563 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1564 ok(size
== sizeof(WSAPROTOCOL_INFOA
) * 2, "got size %d\n", size
);
1568 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1569 for (i
= 0; i
< sizeof(prottest
) / sizeof(prottest
[0]); i
++)
1571 s
= socket(prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1572 if (s
== INVALID_SOCKET
&& prottest
[i
].family
== AF_INET6
) continue;
1574 ok(s
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1577 /* compare both A and W version */
1578 infoA
.szProtocol
[0] = 0;
1579 size
= sizeof(WSAPROTOCOL_INFOA
);
1580 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1581 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1582 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1584 infoW
.szProtocol
[0] = 0;
1585 size
= sizeof(WSAPROTOCOL_INFOW
);
1586 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOW
, (char *) &infoW
, &size
);
1587 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1588 ok(size
== sizeof(WSAPROTOCOL_INFOW
), "got size %d\n", size
);
1590 trace("provider name '%s', family %d, type %d, proto %d\n",
1591 infoA
.szProtocol
, prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1593 ok(infoA
.szProtocol
[0] || broken(!infoA
.szProtocol
[0]) /* NT4 */,
1594 "WSAPROTOCOL_INFOA was not filled\n");
1595 ok(infoW
.szProtocol
[0] || broken(!infoA
.szProtocol
[0]) /* NT4 */,
1596 "WSAPROTOCOL_INFOW was not filled\n");
1598 WideCharToMultiByte(CP_ACP
, 0, infoW
.szProtocol
, -1,
1599 providername
, sizeof(providername
), NULL
, NULL
);
1600 ok(!strcmp(infoA
.szProtocol
,providername
),
1601 "different provider names '%s' != '%s'\n", infoA
.szProtocol
, providername
);
1603 ok(!memcmp(&infoA
, &infoW
, FIELD_OFFSET(WSAPROTOCOL_INFOA
, szProtocol
)),
1604 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1606 /* Remove IF when WSAEnumProtocols support IPV6 data */
1607 todo_wine_if (prottest
[i
].family
== AF_INET6
)
1608 ok(infoA
.iAddressFamily
== prottest
[i
].family
, "socket family invalid, expected %d received %d\n",
1609 prottest
[i
].family
, infoA
.iAddressFamily
);
1610 ok(infoA
.iSocketType
== prottest
[i
].type
, "socket type invalid, expected %d received %d\n",
1611 prottest
[i
].type
, infoA
.iSocketType
);
1612 ok(infoA
.iProtocol
== prottest
[i
].proto
, "socket protocol invalid, expected %d received %d\n",
1613 prottest
[i
].proto
, infoA
.iProtocol
);
1618 /* Test SO_BSP_STATE - Present only in >= Win 2008 */
1619 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1620 ok(s
!= INVALID_SOCKET
, "Failed to create socket\n");
1621 s2
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1622 ok(s2
!= INVALID_SOCKET
, "Failed to create socket\n");
1624 SetLastError(0xdeadbeef);
1625 size
= sizeof(csinfoA
);
1626 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1629 struct sockaddr_in saddr
;
1630 memset(&saddr
, 0, sizeof(saddr
));
1631 saddr
.sin_family
= AF_INET
;
1632 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1634 /* Socket is not bound, no information provided */
1635 ok(!csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1636 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1637 /* Socket is not connected, no information provided */
1638 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1639 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1641 err
= bind(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1642 ok(!err
, "Expected 0, got %d\n", err
);
1643 size
= sizeof(csinfoA
);
1644 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1645 ok(!err
, "Expected 0, got %d\n", err
);
1647 /* Socket is bound */
1648 ok(csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected non-zero\n");
1649 ok(csinfoA
.cs
.LocalAddr
.lpSockaddr
!= NULL
, "Expected non-null\n");
1650 /* Socket is not connected, no information provided */
1651 ok(!csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected 0, got %d\n", csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1652 ok(csinfoA
.cs
.RemoteAddr
.lpSockaddr
== NULL
, "Expected NULL, got %p\n", csinfoA
.cs
.LocalAddr
.lpSockaddr
);
1654 err
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1655 ok(!err
, "Expected 0, got %d\n", err
);
1656 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1657 ok(!err
, "Expected 0, got %d\n", err
);
1658 err
= listen(s2
, 1);
1659 ok(!err
, "Expected 0, got %d\n", err
);
1660 err
= connect(s
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1661 ok(!err
, "Expected 0, got %d\n", err
);
1662 size
= sizeof(saddr
);
1663 err
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1664 ok(err
!= INVALID_SOCKET
, "Failed to accept socket\n");
1668 size
= sizeof(csinfoA
);
1669 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1670 ok(!err
, "Expected 0, got %d\n", err
);
1671 err
= getsockopt(s2
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoB
, &size
);
1672 ok(!err
, "Expected 0, got %d\n", err
);
1673 ok(size
== sizeof(csinfoA
), "Got %d\n", size
);
1674 size
= sizeof(saddr
);
1675 ok(size
== csinfoA
.cs
.LocalAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1676 csinfoA
.cs
.LocalAddr
.iSockaddrLength
);
1677 ok(size
== csinfoA
.cs
.RemoteAddr
.iSockaddrLength
, "Expected %d, got %d\n", size
,
1678 csinfoA
.cs
.RemoteAddr
.iSockaddrLength
);
1679 ok(!memcmp(csinfoA
.cs
.LocalAddr
.lpSockaddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
),
1680 "Expected matching addresses\n");
1681 ok(!memcmp(csinfoB
.cs
.LocalAddr
.lpSockaddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
),
1682 "Expected matching addresses\n");
1683 ok(csinfoA
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1684 ok(csinfoB
.cs
.iSocketType
== SOCK_STREAM
, "Wrong socket type\n");
1685 ok(csinfoA
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1686 ok(csinfoB
.cs
.iProtocol
== IPPROTO_TCP
, "Wrong socket protocol\n");
1688 err
= getpeername(s
, (struct sockaddr
*)&saddr
, &size
);
1689 ok(!err
, "Expected 0, got %d\n", err
);
1690 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1691 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1692 err
= getpeername(s2
, (struct sockaddr
*)&saddr
, &size
);
1693 ok(!err
, "Expected 0, got %d\n", err
);
1694 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1695 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1696 err
= getsockname(s
, (struct sockaddr
*)&saddr
, &size
);
1697 ok(!err
, "Expected 0, got %d\n", err
);
1698 ok(!memcmp(&saddr
, csinfoA
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1699 ok(!memcmp(&saddr
, csinfoB
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1700 err
= getsockname(s2
, (struct sockaddr
*)&saddr
, &size
);
1701 ok(!err
, "Expected 0, got %d\n", err
);
1702 ok(!memcmp(&saddr
, csinfoB
.cs
.LocalAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1703 ok(!memcmp(&saddr
, csinfoA
.cs
.RemoteAddr
.lpSockaddr
, size
), "Expected matching addresses\n");
1705 SetLastError(0xdeadbeef);
1706 size
= sizeof(CSADDR_INFO
);
1707 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1708 ok(err
, "Expected non-zero\n");
1709 ok(size
== sizeof(CSADDR_INFO
), "Got %d\n", size
);
1710 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %d\n", GetLastError());
1712 /* At least for IPv4 the size is exactly 56 bytes */
1713 size
= sizeof(*csinfoA
.cs
.LocalAddr
.lpSockaddr
) * 2 + sizeof(csinfoA
.cs
);
1714 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1715 ok(!err
, "Expected 0, got %d\n", err
);
1717 SetLastError(0xdeadbeef);
1718 err
= getsockopt(s
, SOL_SOCKET
, SO_BSP_STATE
, (char *) &csinfoA
, &size
);
1719 ok(err
, "Expected non-zero\n");
1720 ok(GetLastError() == WSAEFAULT
, "Expected 10014, got %d\n", GetLastError());
1723 ok(GetLastError() == WSAENOPROTOOPT
, "Expected 10042, got %d\n", GetLastError());
1729 static void test_so_reuseaddr(void)
1731 struct sockaddr_in saddr
;
1733 unsigned int rc
,reuse
;
1737 saddr
.sin_family
= AF_INET
;
1738 saddr
.sin_port
= htons(9375);
1739 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1741 s1
=socket(AF_INET
, SOCK_STREAM
, 0);
1742 ok(s1
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1743 rc
= bind(s1
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1744 ok(rc
!=SOCKET_ERROR
, "bind(s1) failed error: %d\n", WSAGetLastError());
1746 s2
=socket(AF_INET
, SOCK_STREAM
, 0);
1747 ok(s2
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1751 rc
=getsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, &size
);
1752 ok(rc
==0 && reuse
==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc
,reuse
);
1754 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1755 ok(rc
==SOCKET_ERROR
, "bind() succeeded\n");
1758 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
1759 ok(rc
==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1761 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1762 * a port immediately after closing another socket on that port, so
1763 * basically following the BSD socket semantics here. */
1764 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1767 int s3
=socket(AF_INET
, SOCK_STREAM
, 0), s4
;
1768 trace("<= Win XP behavior of SO_REUSEADDR\n");
1770 /* If we could bind again in the same port this is Windows version <= XP.
1771 * Lets test if we can really connect to one of them. */
1772 set_blocking(s1
, FALSE
);
1773 set_blocking(s2
, FALSE
);
1775 ok(!rc
, "listen() failed with error: %d\n", WSAGetLastError());
1777 ok(!rc
, "listen() failed with error: %d\n", WSAGetLastError());
1778 rc
= connect(s3
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1779 ok(!rc
, "connecting to accepting socket failed %d\n", WSAGetLastError());
1781 /* the delivery of the connection is random so we need to try on both sockets */
1782 size
= sizeof(saddr
);
1783 s4
= accept(s1
, (struct sockaddr
*)&saddr
, &size
);
1784 if(s4
== INVALID_SOCKET
)
1785 s4
= accept(s2
, (struct sockaddr
*)&saddr
, &size
);
1786 ok(s4
!= INVALID_SOCKET
, "none of the listening sockets could get the connection\n");
1794 trace(">= Win 2003 behavior of SO_REUSEADDR\n");
1795 err
= WSAGetLastError();
1796 ok(err
==WSAEACCES
, "expected 10013, got %d\n", err
);
1799 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1800 ok(rc
==0, "bind() failed error: %d\n", WSAGetLastError());
1806 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1808 static void test_ip_pktinfo(void)
1810 ULONG addresses
[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY
)};
1811 char recvbuf
[10], pktbuf
[512], msg
[] = "HELLO";
1812 struct sockaddr_in s1addr
, s2addr
, s3addr
;
1813 GUID WSARecvMsg_GUID
= WSAID_WSARECVMSG
;
1814 LPFN_WSARECVMSG pWSARecvMsg
= NULL
;
1815 unsigned int rc
, yes
= 1;
1817 DWORD dwBytes
, dwSize
, dwFlags
;
1826 memset(&ov
, 0, sizeof(ov
));
1827 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
1828 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
1830 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
1834 memset(&hdr
, 0x00, sizeof(hdr
));
1835 s1addr
.sin_family
= AF_INET
;
1836 s1addr
.sin_port
= htons(0);
1837 /* Note: s1addr.sin_addr is set below */
1838 iovec
[0].buf
= recvbuf
;
1839 iovec
[0].len
= sizeof(recvbuf
);
1840 hdr
.name
= (struct sockaddr
*)&s3addr
;
1841 hdr
.namelen
= sizeof(s3addr
);
1842 hdr
.lpBuffers
= &iovec
[0];
1843 hdr
.dwBufferCount
= 1;
1844 hdr
.Control
.buf
= pktbuf
;
1845 /* Note: hdr.Control.len is set below */
1848 for (i
=0;i
<sizeof(addresses
)/sizeof(UINT32
);i
++)
1850 s1addr
.sin_addr
.s_addr
= addresses
[i
];
1852 /* Build "server" side socket */
1853 s1
=socket(AF_INET
, SOCK_DGRAM
, 0);
1854 if (s1
== INVALID_SOCKET
)
1856 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1860 /* Obtain the WSARecvMsg function */
1861 WSAIoctl(s1
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
1862 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &dwBytes
, NULL
, NULL
);
1865 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
1870 /* Setup the server side socket */
1871 rc
=bind(s1
, (struct sockaddr
*)&s1addr
, sizeof(s1addr
));
1872 ok(rc
!= SOCKET_ERROR
, "bind() failed error: %d\n", WSAGetLastError());
1873 rc
=setsockopt(s1
, IPPROTO_IP
, IP_PKTINFO
, (const char*)&yes
, sizeof(yes
));
1874 ok(rc
== 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1876 /* Build "client" side socket */
1877 addrlen
= sizeof(s2addr
);
1878 if (getsockname(s1
, (struct sockaddr
*) &s2addr
, &addrlen
) != 0)
1880 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
1884 s2addr
.sin_addr
.s_addr
= addresses
[0]; /* Always target the local adapter address */
1885 s2
=socket(AF_INET
, SOCK_DGRAM
, 0);
1886 if (s2
== INVALID_SOCKET
)
1888 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1893 /* Test an empty message header */
1894 rc
=pWSARecvMsg(s1
, NULL
, NULL
, NULL
, NULL
);
1895 err
=WSAGetLastError();
1896 ok(rc
== SOCKET_ERROR
&& err
== WSAEFAULT
, "WSARecvMsg() failed error: %d (ret = %d)\n", err
, rc
);
1899 * Send a packet from the client to the server and test for specifying
1900 * a short control header.
1902 SetLastError(0xdeadbeef);
1903 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1904 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1905 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1906 hdr
.Control
.len
= 1;
1907 rc
=pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
1908 err
=WSAGetLastError();
1909 ok(rc
== SOCKET_ERROR
&& err
== WSAEMSGSIZE
&& (hdr
.dwFlags
& MSG_CTRUNC
),
1910 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err
, rc
, hdr
.dwFlags
);
1911 hdr
.dwFlags
= 0; /* Reset flags */
1913 /* Perform another short control header test, this time with an overlapped receive */
1914 hdr
.Control
.len
= 1;
1915 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1916 err
=WSAGetLastError();
1917 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1918 SetLastError(0xdeadbeef);
1919 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1920 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1921 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
1922 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
1924 skip("Server side did not receive packet, some tests skipped.\n");
1930 WSAGetOverlappedResult(s1
, &ov
, NULL
, FALSE
, &dwFlags
);
1932 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags
);
1933 ok(hdr
.dwFlags
== MSG_CTRUNC
,
1934 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr
.dwFlags
);
1935 hdr
.dwFlags
= 0; /* Reset flags */
1938 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1939 * on the server end and check that the returned packet matches what was sent.
1941 hdr
.Control
.len
= sizeof(pktbuf
);
1942 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1943 err
=WSAGetLastError();
1944 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1945 ok(hdr
.Control
.len
== sizeof(pktbuf
),
1946 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr
.Control
.len
);
1947 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1948 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1949 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
1951 skip("Server side did not receive packet, some tests skipped.\n");
1957 WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, NULL
);
1958 ok(dwSize
== sizeof(msg
),
1959 "WSARecvMsg() buffer length does not match transmitted data!\n");
1960 ok(strncmp(iovec
[0].buf
, msg
, sizeof(msg
)) == 0,
1961 "WSARecvMsg() buffer does not match transmitted data!\n");
1962 ok(hdr
.Control
.len
== IP_PKTINFO_LEN
,
1963 "WSARecvMsg() control length mismatch (%d).\n", hdr
.Control
.len
);
1965 /* Test for the expected IP_PKTINFO return information. */
1967 for (cmsg
= WSA_CMSG_FIRSTHDR(&hdr
); cmsg
!= NULL
; cmsg
= WSA_CMSG_NXTHDR(&hdr
, cmsg
))
1969 if (cmsg
->cmsg_level
== IPPROTO_IP
&& cmsg
->cmsg_type
== IP_PKTINFO
)
1971 struct in_pktinfo
*pi
= (struct in_pktinfo
*)WSA_CMSG_DATA(cmsg
);
1973 ok(pi
->ipi_addr
.s_addr
== s2addr
.sin_addr
.s_addr
, "destination ip mismatch!\n");
1977 ok(foundhdr
, "IP_PKTINFO header information was not returned!\n");
1984 CloseHandle(ov
.hEvent
);
1987 /************* Array containing the tests to run **********/
1989 #define STD_STREAM_SOCKET \
1995 static test_setup tests
[] =
1997 /* Test 0: synchronous client and server */
2018 /* Test 1: event-driven client, synchronous server */
2035 WSA_FLAG_OVERLAPPED
,
2039 /* Test 2: synchronous client, non-blocking server via select() */
2060 /* Test 3: OOB client, OOB server */
2081 /* Test 4: synchronous mixed client and server */
2095 simple_mixed_client
,
2104 static void test_UDP(void)
2106 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
2107 possible that this test fails due to dropped packets. */
2109 /* peer 0 receives data from all other peers */
2110 struct sock_info peer
[NUM_UDP_PEERS
];
2112 int ss
, i
, n_recv
, n_sent
;
2114 memset (buf
,0,sizeof(buf
));
2115 for ( i
= NUM_UDP_PEERS
- 1; i
>= 0; i
-- ) {
2116 ok ( ( peer
[i
].s
= socket ( AF_INET
, SOCK_DGRAM
, 0 ) ) != INVALID_SOCKET
, "UDP: socket failed\n" );
2118 peer
[i
].addr
.sin_family
= AF_INET
;
2119 peer
[i
].addr
.sin_addr
.s_addr
= inet_addr ( SERVERIP
);
2122 peer
[i
].addr
.sin_port
= htons ( SERVERPORT
);
2124 peer
[i
].addr
.sin_port
= htons ( 0 );
2127 do_bind ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, sizeof( peer
[i
].addr
) );
2129 /* test getsockname() to get peer's port */
2130 ss
= sizeof ( peer
[i
].addr
);
2131 ok ( getsockname ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, &ss
) != SOCKET_ERROR
, "UDP: could not getsockname()\n" );
2132 ok ( peer
[i
].addr
.sin_port
!= htons ( 0 ), "UDP: bind() did not associate port\n" );
2135 /* test getsockname() */
2136 ok ( peer
[0].addr
.sin_port
== htons ( SERVERPORT
), "UDP: getsockname returned incorrect peer port\n" );
2138 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
2139 /* send client's ip */
2140 memcpy( buf
, &peer
[i
].addr
.sin_port
, sizeof(peer
[i
].addr
.sin_port
) );
2141 n_sent
= sendto ( peer
[i
].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*) &peer
[0].addr
, sizeof(peer
[0].addr
) );
2142 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
2145 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
2146 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0,(struct sockaddr
*) &peer
[0].peer
, &ss
);
2147 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
2148 ok ( memcmp ( &peer
[0].peer
.sin_port
, buf
, sizeof(peer
[0].addr
.sin_port
) ) == 0, "UDP: port numbers do not match\n" );
2152 static DWORD WINAPI
do_getservbyname( void *param
)
2158 } serv
[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
2160 HANDLE
*starttest
= param
;
2162 struct servent
*pserv
[2];
2164 ok ( WaitForSingleObject ( *starttest
, TEST_TIMEOUT
* 1000 ) != WAIT_TIMEOUT
,
2165 "test_getservbyname: timeout waiting for start signal\n" );
2167 /* ensure that necessary buffer resizes are completed */
2168 for ( j
= 0; j
< 2; j
++) {
2169 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
2172 for ( i
= 0; i
< NUM_QUERIES
/ 2; i
++ ) {
2173 for ( j
= 0; j
< 2; j
++ ) {
2174 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
2175 ok ( pserv
[j
] != NULL
|| broken(pserv
[j
] == NULL
) /* win8, fixed in win81 */,
2176 "getservbyname could not retrieve information for %s: %d\n", serv
[j
].name
, WSAGetLastError() );
2177 if ( !pserv
[j
] ) continue;
2178 ok ( pserv
[j
]->s_port
== htons(serv
[j
].port
),
2179 "getservbyname returned the wrong port for %s: %d\n", serv
[j
].name
, ntohs(pserv
[j
]->s_port
) );
2180 ok ( !strcmp ( pserv
[j
]->s_proto
, serv
[j
].proto
),
2181 "getservbyname returned the wrong protocol for %s: %s\n", serv
[j
].name
, pserv
[j
]->s_proto
);
2182 ok ( !strcmp ( pserv
[j
]->s_name
, serv
[j
].name
),
2183 "getservbyname returned the wrong name for %s: %s\n", serv
[j
].name
, pserv
[j
]->s_name
);
2186 ok ( pserv
[0] == pserv
[1] || broken(pserv
[0] != pserv
[1]) /* win8, fixed in win81 */,
2187 "getservbyname: winsock resized servent buffer when not necessary\n" );
2193 static void test_getservbyname(void)
2196 HANDLE starttest
, thread
[NUM_THREADS
];
2197 DWORD thread_id
[NUM_THREADS
];
2199 starttest
= CreateEventA ( NULL
, 1, 0, "test_getservbyname_starttest" );
2201 /* create threads */
2202 for ( i
= 0; i
< NUM_THREADS
; i
++ ) {
2203 thread
[i
] = CreateThread ( NULL
, 0, do_getservbyname
, &starttest
, 0, &thread_id
[i
] );
2206 /* signal threads to start */
2207 SetEvent ( starttest
);
2209 for ( i
= 0; i
< NUM_THREADS
; i
++) {
2210 WaitForSingleObject ( thread
[i
], TEST_TIMEOUT
* 1000 );
2214 static void test_WSASocket(void)
2216 SOCKET sock
= INVALID_SOCKET
;
2217 WSAPROTOCOL_INFOA
*pi
;
2218 int wsaproviders
[] = {IPPROTO_TCP
, IPPROTO_IP
};
2219 int autoprotocols
[] = {IPPROTO_TCP
, IPPROTO_UDP
};
2220 int items
, err
, size
, socktype
, i
, j
;
2223 SetLastError(0xdeadbeef);
2224 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2225 "WSASocketA should have failed\n");
2226 err
= WSAGetLastError();
2227 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2229 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
2230 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2233 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, NULL
, 0, 0);
2234 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2237 SetLastError(0xdeadbeef);
2238 ok(WSASocketA(0, SOCK_STREAM
, -1, NULL
, 0, 0) == INVALID_SOCKET
,
2239 "WSASocketA should have failed\n");
2240 err
= WSAGetLastError();
2241 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2243 SetLastError(0xdeadbeef);
2244 ok(WSASocketA(0, -1, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
2245 "WSASocketA should have failed\n");
2246 err
= WSAGetLastError();
2247 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
2249 SetLastError(0xdeadbeef);
2250 ok(WSASocketA(0, -1, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2251 "WSASocketA should have failed\n");
2252 err
= WSAGetLastError();
2253 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2255 SetLastError(0xdeadbeef);
2256 ok(WSASocketA(AF_INET
, -1, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2257 "WSASocketA should have failed\n");
2258 err
= WSAGetLastError();
2259 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
2261 SetLastError(0xdeadbeef);
2262 ok(WSASocketA(AF_INET
, 0, -1, NULL
, 0, 0) == INVALID_SOCKET
,
2263 "WSASocketA should have failed\n");
2264 err
= WSAGetLastError();
2265 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2267 SetLastError(0xdeadbeef);
2268 ok(WSASocketA(0, -1, -1, NULL
, 0, 0) == INVALID_SOCKET
,
2269 "WSASocketA should have failed\n");
2270 err
= WSAGetLastError();
2271 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
2273 SetLastError(0xdeadbeef);
2274 ok(WSASocketA(-1, SOCK_STREAM
, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
2275 "WSASocketA should have failed\n");
2276 err
= WSAGetLastError();
2277 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2279 sock
= WSASocketA(AF_INET
, 0, IPPROTO_TCP
, NULL
, 0, 0);
2280 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2283 SetLastError(0xdeadbeef);
2284 ok(WSASocketA(0, SOCK_STREAM
, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2285 "WSASocketA should have failed\n");
2286 err
= WSAGetLastError();
2287 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2289 SetLastError(0xdeadbeef);
2290 ok(WSASocketA(0, 0, 0xdead, NULL
, 0, 0) == INVALID_SOCKET
,
2291 "WSASocketA should have failed\n");
2292 err
= WSAGetLastError();
2293 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2295 SetLastError(0xdeadbeef);
2296 ok(WSASocketA(AF_INET
, 0xdead, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2297 "WSASocketA should have failed\n");
2298 err
= WSAGetLastError();
2299 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
2301 SetLastError(0xdeadbeef);
2302 ok(WSASocketA(0, 0xdead, 0, NULL
, 0, 0) == INVALID_SOCKET
,
2303 "WSASocketA should have failed\n");
2304 err
= WSAGetLastError();
2305 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2307 sock
= WSASocketA(0, 0, IPPROTO_TCP
, NULL
, 0, 0);
2308 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2311 /* SOCK_STREAM does not support IPPROTO_UDP */
2312 SetLastError(0xdeadbeef);
2313 ok(WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
2314 "WSASocketA should have failed\n");
2315 err
= WSAGetLastError();
2316 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2318 /* SOCK_DGRAM does not support IPPROTO_TCP */
2319 SetLastError(0xdeadbeef);
2320 ok(WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, NULL
, 0, 0) == INVALID_SOCKET
,
2321 "WSASocketA should have failed\n");
2322 err
= WSAGetLastError();
2323 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2325 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2326 * to avoid a crash on win98.
2329 items
= WSAEnumProtocolsA(wsaproviders
, NULL
, &pi_size
);
2330 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2332 err
= WSAGetLastError();
2333 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2336 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2337 ok(pi
!= NULL
, "Failed to allocate memory\n");
2339 skip("Can't continue without memory.\n");
2343 items
= WSAEnumProtocolsA(wsaproviders
, pi
, &pi_size
);
2344 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2348 skip("No protocols enumerated.\n");
2349 HeapFree(GetProcessHeap(), 0, pi
);
2353 sock
= WSASocketA(FROM_PROTOCOL_INFO
, FROM_PROTOCOL_INFO
,
2354 FROM_PROTOCOL_INFO
, &pi
[0], 0, 0);
2355 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2359 /* find what parameters are used first: plain parameters or protocol info struct */
2360 pi
[0].iProtocol
= -1;
2361 pi
[0].iSocketType
= -1;
2362 pi
[0].iAddressFamily
= -1;
2363 ok(WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0) == INVALID_SOCKET
,
2364 "WSASocketA should have failed\n");
2365 err
= WSAGetLastError();
2366 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2368 pi
[0].iProtocol
= 0;
2369 pi
[0].iSocketType
= 0;
2370 pi
[0].iAddressFamily
= 0;
2371 sock
= WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0);
2372 if(sock
!= INVALID_SOCKET
)
2374 win_skip("must work only in OS <= 2003\n");
2379 err
= WSAGetLastError();
2380 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2383 pi
[0].iProtocol
= IPPROTO_UDP
;
2384 pi
[0].iSocketType
= SOCK_DGRAM
;
2385 pi
[0].iAddressFamily
= AF_INET
;
2386 sock
= WSASocketA(0, 0, 0, &pi
[0], 0, 0);
2387 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2389 size
= sizeof(socktype
);
2391 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2392 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2393 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2394 SOCK_DGRAM
, socktype
);
2397 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, &pi
[0], 0, 0);
2398 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2400 size
= sizeof(socktype
);
2402 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2403 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2404 ok(socktype
== SOCK_STREAM
, "Wrong socket type, expected %d received %d\n",
2405 SOCK_STREAM
, socktype
);
2408 HeapFree(GetProcessHeap(), 0, pi
);
2411 items
= WSAEnumProtocolsA(NULL
, NULL
, &pi_size
);
2412 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2414 err
= WSAGetLastError();
2415 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2418 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2419 ok(pi
!= NULL
, "Failed to allocate memory\n");
2421 skip("Can't continue without memory.\n");
2425 items
= WSAEnumProtocolsA(NULL
, pi
, &pi_size
);
2426 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2429 /* when no protocol and socket type are specified the first entry
2430 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2432 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
2433 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2436 size
= sizeof(socktype
);
2438 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2439 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2440 for(i
= 0; i
< items
; i
++)
2442 if(pi
[i
].dwProviderFlags
& PFL_MATCHES_PROTOCOL_ZERO
)
2444 ok(socktype
== pi
[i
].iSocketType
, "Wrong socket type, expected %d received %d\n",
2445 pi
[i
].iSocketType
, socktype
);
2449 ok(i
!= items
, "Creating a socket without protocol and socket type didn't work\n");
2452 /* when no socket type is specified the first entry from WSAEnumProtocols
2453 * that matches the protocol is returned */
2454 for (i
= 0; i
< sizeof(autoprotocols
) / sizeof(autoprotocols
[0]); i
++)
2456 sock
= WSASocketA(0, 0, autoprotocols
[i
], NULL
, 0, 0);
2457 ok(sock
!= INVALID_SOCKET
, "Failed to create socket for protocol %d, received %d\n",
2458 autoprotocols
[i
], WSAGetLastError());
2460 size
= sizeof(socktype
);
2462 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2463 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2465 for (err
= 1, j
= 0; j
< items
; j
++)
2467 if (pi
[j
].iProtocol
== autoprotocols
[i
])
2469 if (socktype
== pi
[j
].iSocketType
)
2472 ok(0, "Wrong socket type, expected %d received %d\n",
2473 pi
[j
].iSocketType
, socktype
);
2477 ok(!err
, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols
[i
]);
2482 HeapFree(GetProcessHeap(), 0, pi
);
2484 SetLastError(0xdeadbeef);
2485 /* starting on vista the socket function returns error during the socket
2486 creation and no longer in the socket operations (sendto, readfrom) */
2487 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_ICMP
, NULL
, 0, 0);
2488 if (sock
== INVALID_SOCKET
)
2490 err
= WSAGetLastError();
2491 ok(err
== WSAEACCES
, "Expected 10013, received %d\n", err
);
2492 skip("SOCK_RAW is not supported\n");
2496 trace("SOCK_RAW is supported\n");
2498 size
= sizeof(socktype
);
2500 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2501 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2502 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2503 SOCK_RAW
, socktype
);
2507 sock
= WSASocketA(0, 0, IPPROTO_RAW
, NULL
, 0, 0);
2508 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2510 size
= sizeof(socktype
);
2512 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2513 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2514 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2515 SOCK_RAW
, socktype
);
2519 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_TCP
, NULL
, 0, 0);
2520 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2522 size
= sizeof(socktype
);
2524 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2525 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2526 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2527 SOCK_RAW
, socktype
);
2531 /* IPX socket tests */
2533 SetLastError(0xdeadbeef);
2534 sock
= WSASocketA(AF_IPX
, SOCK_DGRAM
, NSPROTO_IPX
, NULL
, 0, 0);
2535 if (sock
== INVALID_SOCKET
)
2537 err
= WSAGetLastError();
2538 todo_wine_if (err
== WSAEPROTONOSUPPORT
)
2539 ok(err
== WSAEAFNOSUPPORT
|| broken(err
== WSAEPROTONOSUPPORT
), "Expected 10047, received %d\n", err
);
2540 skip("IPX is not supported\n");
2544 WSAPROTOCOL_INFOA info
;
2547 trace("IPX is supported\n");
2549 sock
= WSASocketA(0, 0, NSPROTO_IPX
, NULL
, 0, 0);
2550 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2553 size
= sizeof(socktype
);
2555 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2556 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2557 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2558 SOCK_DGRAM
, socktype
);
2560 /* check socket family, type and protocol */
2561 size
= sizeof(WSAPROTOCOL_INFOA
);
2562 err
= getsockopt(sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &info
, &size
);
2563 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2564 ok(info
.iProtocol
== NSPROTO_IPX
, "expected protocol %d, received %d\n",
2565 NSPROTO_IPX
, info
.iProtocol
);
2566 ok(info
.iAddressFamily
== AF_IPX
, "expected family %d, received %d\n",
2567 AF_IPX
, info
.iProtocol
);
2568 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2569 SOCK_DGRAM
, info
.iSocketType
);
2572 /* SOCK_STREAM does not support NSPROTO_IPX */
2573 SetLastError(0xdeadbeef);
2574 ok(WSASocketA(AF_IPX
, SOCK_STREAM
, NSPROTO_IPX
, NULL
, 0, 0) == INVALID_SOCKET
,
2575 "WSASocketA should have failed\n");
2576 err
= WSAGetLastError();
2577 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2579 /* test extended IPX support - that is adding any number between 0 and 255
2580 * to the IPX protocol value will make it be used as IPX packet type */
2581 for(i
= 0;i
<= 255;i
+= 17)
2583 SetLastError(0xdeadbeef);
2584 sock
= WSASocketA(0, 0, NSPROTO_IPX
+ i
, NULL
, 0, 0);
2585 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2590 err
= getsockopt(sock
, NSPROTO_IPX
, IPX_PTYPE
, (char *) &socktype
, &size
);
2591 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2592 ok(socktype
== i
, "Wrong IPX packet type, expected %d received %d\n",
2600 static void test_WSADuplicateSocket(void)
2602 SOCKET source
, dupsock
;
2603 WSAPROTOCOL_INFOA info
;
2605 struct sockaddr_in addr
;
2606 int socktype
, size
, addrsize
, ret
;
2607 char teststr
[] = "TEST", buffer
[16];
2609 source
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
2610 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2612 /* test invalid parameters */
2613 SetLastError(0xdeadbeef);
2614 ok(WSADuplicateSocketA(0, 0, NULL
), "WSADuplicateSocketA should have failed\n");
2615 err
= WSAGetLastError();
2616 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2618 SetLastError(0xdeadbeef);
2619 ok(WSADuplicateSocketA(source
, 0, NULL
),
2620 "WSADuplicateSocketA should have failed\n");
2621 err
= WSAGetLastError();
2622 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2624 SetLastError(0xdeadbeef);
2625 ok(WSADuplicateSocketA(source
, ~0, &info
),
2626 "WSADuplicateSocketA should have failed\n");
2627 err
= WSAGetLastError();
2628 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2630 SetLastError(0xdeadbeef);
2631 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info
),
2632 "WSADuplicateSocketA should have failed\n");
2633 err
= WSAGetLastError();
2634 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2636 SetLastError(0xdeadbeef);
2637 ok(WSADuplicateSocketA(source
, GetCurrentProcessId(), NULL
),
2638 "WSADuplicateSocketA should have failed\n");
2639 err
= WSAGetLastError();
2640 ok(err
== WSAEFAULT
, "expected 10014, received %d\n", err
);
2642 /* test returned structure */
2643 memset(&info
, 0, sizeof(info
));
2644 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2645 "WSADuplicateSocketA should have worked\n");
2647 ok(info
.iProtocol
== IPPROTO_TCP
, "expected protocol %d, received %d\n",
2648 IPPROTO_TCP
, info
.iProtocol
);
2649 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2650 AF_INET
, info
.iProtocol
);
2651 ok(info
.iSocketType
== SOCK_STREAM
, "expected type %d, received %d\n",
2652 SOCK_STREAM
, info
.iSocketType
);
2654 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2655 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2657 closesocket(dupsock
);
2658 closesocket(source
);
2660 /* create a socket, bind it, duplicate it then send data on source and
2661 * receive in the duplicated socket */
2662 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2663 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2665 memset(&info
, 0, sizeof(info
));
2666 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2667 "WSADuplicateSocketA should have worked\n");
2669 ok(info
.iProtocol
== IPPROTO_UDP
, "expected protocol %d, received %d\n",
2670 IPPROTO_UDP
, info
.iProtocol
);
2671 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2672 AF_INET
, info
.iProtocol
);
2673 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2674 SOCK_DGRAM
, info
.iSocketType
);
2676 memset(&addr
, 0, sizeof(addr
));
2677 addr
.sin_family
= AF_INET
;
2678 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2679 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2680 "bind should have worked\n");
2682 /* read address to find out the port number to be used in sendto */
2683 memset(&addr
, 0, sizeof(addr
));
2684 addrsize
= sizeof(addr
);
2685 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2686 "getsockname should have worked\n");
2687 ok(addr
.sin_port
, "socket port should be != 0\n");
2689 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2690 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2693 ret
= getsockopt(dupsock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2694 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
2695 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2696 SOCK_DGRAM
, socktype
);
2698 set_blocking(source
, TRUE
);
2700 /* send data on source socket */
2701 addrsize
= sizeof(addr
);
2702 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2703 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2705 /* receive on duplicated socket */
2706 addrsize
= sizeof(addr
);
2707 memset(buffer
, 0, sizeof(buffer
));
2708 size
= recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
);
2709 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2710 buffer
[sizeof(teststr
) - 1] = 0;
2711 ok(!strcmp(buffer
, teststr
), "expected '%s', received '%s'\n", teststr
, buffer
);
2713 closesocket(dupsock
);
2714 closesocket(source
);
2716 /* show that the source socket need to be bound before the duplicated
2717 * socket is created */
2718 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2719 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2721 memset(&info
, 0, sizeof(info
));
2722 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2723 "WSADuplicateSocketA should have worked\n");
2725 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2726 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2728 memset(&addr
, 0, sizeof(addr
));
2729 addr
.sin_family
= AF_INET
;
2730 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2731 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2732 "bind should have worked\n");
2734 /* read address to find out the port number to be used in sendto */
2735 memset(&addr
, 0, sizeof(addr
));
2736 addrsize
= sizeof(addr
);
2737 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2738 "getsockname should have worked\n");
2739 ok(addr
.sin_port
, "socket port should be != 0\n");
2741 set_blocking(source
, TRUE
);
2743 addrsize
= sizeof(addr
);
2744 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2745 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2747 SetLastError(0xdeadbeef);
2748 addrsize
= sizeof(addr
);
2749 memset(buffer
, 0, sizeof(buffer
));
2751 ok(recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
) == -1,
2752 "recvfrom should have failed\n");
2753 err
= WSAGetLastError();
2754 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2757 closesocket(dupsock
);
2758 closesocket(source
);
2761 static void test_WSAEnumNetworkEvents(void)
2764 int sock_type
[] = {SOCK_STREAM
, SOCK_DGRAM
, SOCK_STREAM
}, i
, j
, k
, l
;
2765 struct sockaddr_in address
;
2767 WSANETWORKEVENTS net_events
;
2768 /* Windows 2000 Pro without SP installed (testbot) will crash if
2769 * WSAEnumNetworkEvents have a NULL event, so skip this test in <= 2000 */
2770 DWORD ver
= GetVersion() & 0xFFFF;
2771 BOOL supports_null
= ((ver
& 0xFF) << 8 | (ver
>> 8)) > 0x0500;
2773 memset(&address
, 0, sizeof(address
));
2774 address
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
2775 address
.sin_family
= AF_INET
;
2777 /* This test follows the steps from bugs 10204 and 24946 */
2778 for (l
= 0; l
< 2; l
++)
2780 if (l
== 1 && !supports_null
&& broken(1)) continue;
2782 for (i
= 0; i
< sizeof(sock_type
) / sizeof(sock_type
[0]); i
++)
2785 ok(!tcp_socketpair(&s
, &s2
), "Test[%d]: creating socket pair failed\n", i
);
2788 s
= socket(AF_INET
, sock_type
[i
], 0);
2789 ok (s
!= SOCKET_ERROR
, "Test[%d]: failed to create socket\n", i
);
2790 ok (!bind(s
, (struct sockaddr
*) &address
, sizeof(address
)), "Test[%d]: bind failed\n", i
);
2792 event
= WSACreateEvent();
2793 ok (event
!= NULL
, "Test[%d]: failed to create event\n", i
);
2794 for (j
= 0; j
< 5; j
++) /* Repeat sometimes and the result must be the same */
2796 /* When the TCP socket is not connected NO events will be returned.
2797 * When connected and no data pending it will get the write event.
2798 * UDP sockets don't have connections so as soon as they are bound
2799 * they can read/write data. Since nobody is sendind us data only
2800 * the write event will be returned and ONLY once.
2802 ok (!WSAEventSelect(s
, event
, FD_READ
| FD_WRITE
), "Test[%d]: WSAEventSelect failed\n", i
);
2803 memset(&net_events
, 0xAB, sizeof(net_events
));
2804 ok (!WSAEnumNetworkEvents(s
, l
== 0 ? event
: NULL
, &net_events
),
2805 "Test[%d]: WSAEnumNetworkEvents failed\n", i
);
2806 if (i
>= 1 && j
== 0) /* FD_WRITE is SET on first try for UDP and connected TCP */
2808 todo_wine_if (i
== 0 || net_events
.lNetworkEvents
== 0)
2809 ok (net_events
.lNetworkEvents
== FD_WRITE
, "Test[%d]: expected 2, got %d\n",
2810 i
, net_events
.lNetworkEvents
);
2814 todo_wine_if (i
!= 0 && net_events
.lNetworkEvents
!= 0)
2815 ok (net_events
.lNetworkEvents
== 0, "Test[%d]: expected 0, got %d\n",
2816 i
, net_events
.lNetworkEvents
);
2818 for (k
= 0; k
< FD_MAX_EVENTS
; k
++)
2820 if (i
>= 1 && j
== 0 && k
== 1) /* first UDP and connected TCP test, FD_WRITE bit no error*/
2822 ok (net_events
.iErrorCode
[k
] == 0x0, "Test[%d][%d]: expected 0x0, got 0x%x\n",
2823 i
, k
, net_events
.iErrorCode
[k
]);
2827 /* Bits that are not set in lNetworkEvents MUST not be changed */
2829 ok (net_events
.iErrorCode
[k
] == 0xABABABAB, "Test[%d][%d]: expected 0xABABABAB, got 0x%x\n",
2830 i
, k
, net_events
.iErrorCode
[k
]);
2835 WSACloseEvent(event
);
2836 if (i
== 2) closesocket(s2
);
2841 static void test_WSAAddressToStringA(void)
2843 SOCKET v6
= INVALID_SOCKET
;
2847 SOCKADDR_IN sockaddr
;
2848 CHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2850 CHAR expect1
[] = "0.0.0.0";
2851 CHAR expect2
[] = "255.255.255.255";
2852 CHAR expect3
[] = "0.0.0.0:65535";
2853 CHAR expect4
[] = "255.255.255.255:65535";
2855 SOCKADDR_IN6 sockaddr6
;
2856 CHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2858 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2859 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2860 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2862 CHAR expect6_1
[] = "::1";
2863 CHAR expect6_2
[] = "20ab::1";
2864 CHAR expect6_3
[] = "[20ab::2001]:33274";
2865 CHAR expect6_3_nt
[] = "20ab::2001@33274";
2866 CHAR expect6_3_w2k
[] = "20ab::2001";
2867 CHAR expect6_3_2
[] = "[20ab::2001%4660]:33274";
2868 CHAR expect6_3_2_nt
[] = "4660/20ab::2001@33274";
2869 CHAR expect6_3_2_w2k
[] = "20ab::2001%4660";
2870 CHAR expect6_3_3
[] = "20ab::2001%4660";
2871 CHAR expect6_3_3_nt
[] = "4660/20ab::2001";
2875 sockaddr
.sin_family
= AF_INET
;
2876 sockaddr
.sin_port
= 0;
2877 sockaddr
.sin_addr
.s_addr
= 0;
2879 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2880 GLE
= WSAGetLastError();
2881 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
2882 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2885 len
= sizeof(address
);
2887 sockaddr
.sin_family
= AF_INET
;
2888 sockaddr
.sin_port
= 0;
2889 sockaddr
.sin_addr
.s_addr
= 0;
2891 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2892 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2894 ok( !strcmp( address
, expect1
), "Expected: %s, got: %s\n", expect1
, address
);
2895 ok( len
== sizeof( expect1
), "Got size %d\n", len
);
2897 len
= sizeof(address
);
2899 sockaddr
.sin_family
= AF_INET
;
2900 sockaddr
.sin_port
= 0;
2901 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
2903 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2904 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2906 ok( !strcmp( address
, expect2
), "Expected: %s, got: %s\n", expect2
, address
);
2908 len
= sizeof(address
);
2910 sockaddr
.sin_family
= AF_INET
;
2911 sockaddr
.sin_port
= 0xffff;
2912 sockaddr
.sin_addr
.s_addr
= 0;
2914 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2915 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2917 ok( !strcmp( address
, expect3
), "Expected: %s, got: %s\n", expect3
, address
);
2919 len
= sizeof(address
);
2921 sockaddr
.sin_family
= AF_INET
;
2922 sockaddr
.sin_port
= 0xffff;
2923 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
2925 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2926 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2928 ok( !strcmp( address
, expect4
), "Expected: %s, got: %s\n", expect4
, address
);
2929 ok( len
== sizeof( expect4
), "Got size %d\n", len
);
2931 /*check to see it IPv6 is available */
2932 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
2933 if (v6
== INVALID_SOCKET
) {
2934 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2935 WSAGetLastError(), WSAEAFNOSUPPORT
);
2938 /* Test a short IPv6 address */
2939 len
= sizeof(address6
);
2941 sockaddr6
.sin6_family
= AF_INET6
;
2942 sockaddr6
.sin6_port
= 0x0000;
2943 sockaddr6
.sin6_scope_id
= 0;
2944 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
2946 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2947 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2948 ok( !strcmp( address6
, expect6_1
), "Expected: %s, got: %s\n", expect6_1
, address6
);
2949 ok( len
== sizeof(expect6_1
), "Got size %d\n", len
);
2951 /* Test a longer IPv6 address */
2952 len
= sizeof(address6
);
2954 sockaddr6
.sin6_family
= AF_INET6
;
2955 sockaddr6
.sin6_port
= 0x0000;
2956 sockaddr6
.sin6_scope_id
= 0;
2957 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
2959 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2960 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2961 ok( !strcmp( address6
, expect6_2
), "Expected: %s, got: %s\n", expect6_2
, address6
);
2962 ok( len
== sizeof(expect6_2
), "Got size %d\n", len
);
2964 /* Test IPv6 address and port number */
2965 len
= sizeof(address6
);
2967 sockaddr6
.sin6_family
= AF_INET6
;
2968 sockaddr6
.sin6_port
= 0xfa81;
2969 sockaddr6
.sin6_scope_id
= 0;
2970 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2972 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2973 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2974 ok( !strcmp( address6
, expect6_3
) ||
2975 broken( !strcmp( address6
, expect6_3_nt
) ) || /* NT4 */
2976 broken( !strcmp( address6
, expect6_3_w2k
) ), /* Win2000 */
2977 "Expected: %s, got: %s\n", expect6_3
, address6
);
2978 ok( len
== sizeof(expect6_3
) ||
2979 broken( len
== sizeof(expect6_3_nt
) ) || /* NT4 */
2980 broken( len
== sizeof(expect6_3_w2k
) ), /* Win2000 */
2981 "Got size %d\n", len
);
2983 /* Test IPv6 address, port number and scope_id */
2984 len
= sizeof(address6
);
2986 sockaddr6
.sin6_family
= AF_INET6
;
2987 sockaddr6
.sin6_port
= 0xfa81;
2988 sockaddr6
.sin6_scope_id
= 0x1234;
2989 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2991 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2992 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2993 ok( !strcmp( address6
, expect6_3_2
) ||
2994 broken( !strcmp( address6
, expect6_3_2_nt
) ) || /* NT4 */
2995 broken( !strcmp( address6
, expect6_3_2_w2k
) ), /* Win2000 */
2996 "Expected: %s, got: %s\n", expect6_3_2
, address6
);
2997 ok( len
== sizeof(expect6_3_2
) ||
2998 broken( len
== sizeof(expect6_3_2_nt
) ) || /* NT4 */
2999 broken( len
== sizeof(expect6_3_2_w2k
) ), /* Win2000 */
3000 "Got size %d\n", len
);
3002 /* Test IPv6 address and scope_id */
3003 len
= sizeof(address6
);
3005 sockaddr6
.sin6_family
= AF_INET6
;
3006 sockaddr6
.sin6_port
= 0x0000;
3007 sockaddr6
.sin6_scope_id
= 0x1234;
3008 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3010 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3011 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
3012 ok( !strcmp( address6
, expect6_3_3
) ||
3013 broken( !strcmp( address6
, expect6_3_3_nt
) ), /* NT4 */
3014 "Expected: %s, got: %s\n", expect6_3_3
, address6
);
3015 ok( len
== sizeof(expect6_3_3
) ||
3016 broken( len
== sizeof(expect6_3_3_nt
) ), /* NT4 */
3017 "Got size %d\n", len
);
3020 if (v6
!= INVALID_SOCKET
)
3024 static void test_WSAAddressToStringW(void)
3026 SOCKET v6
= INVALID_SOCKET
;
3030 SOCKADDR_IN sockaddr
;
3031 WCHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
3033 WCHAR expect1
[] = { '0','.','0','.','0','.','0', 0 };
3034 WCHAR expect2
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3035 WCHAR expect3
[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
3036 WCHAR expect4
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3037 '6', '5', '5', '3', '5', 0 };
3039 SOCKADDR_IN6 sockaddr6
;
3040 WCHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
3042 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3043 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
3044 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
3046 WCHAR expect6_1
[] = {':',':','1',0};
3047 WCHAR expect6_2
[] = {'2','0','a','b',':',':','1',0};
3048 WCHAR expect6_3
[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
3049 WCHAR expect6_3_nt
[] = {'2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
3050 WCHAR expect6_3_w2k
[] = {'2','0','a','b',':',':','2','0','0','1',0};
3051 WCHAR expect6_3_2
[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
3052 WCHAR expect6_3_2_nt
[] = {'4','6','6','0','/','2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
3053 WCHAR expect6_3_2_w2k
[] = {'2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',0};
3054 WCHAR expect6_3_3
[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
3055 WCHAR expect6_3_3_nt
[] = {'6','5','5','3','4','/','2','0','a','b',':',':','2','0','0','1',0};
3059 sockaddr
.sin_family
= AF_INET
;
3060 sockaddr
.sin_port
= 0;
3061 sockaddr
.sin_addr
.s_addr
= 0;
3063 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3064 GLE
= WSAGetLastError();
3065 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
3066 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
3069 len
= sizeof(address
);
3071 sockaddr
.sin_family
= AF_INET
;
3072 sockaddr
.sin_port
= 0;
3073 sockaddr
.sin_addr
.s_addr
= 0;
3075 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3076 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3078 ok( !lstrcmpW( address
, expect1
), "Expected different address string\n" );
3079 ok( len
== sizeof( expect1
)/sizeof( WCHAR
), "Got size %d\n", len
);
3081 len
= sizeof(address
);
3083 sockaddr
.sin_family
= AF_INET
;
3084 sockaddr
.sin_port
= 0;
3085 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
3087 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3088 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3090 ok( !lstrcmpW( address
, expect2
), "Expected different address string\n" );
3092 len
= sizeof(address
);
3094 sockaddr
.sin_family
= AF_INET
;
3095 sockaddr
.sin_port
= 0xffff;
3096 sockaddr
.sin_addr
.s_addr
= 0;
3098 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3099 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3101 ok( !lstrcmpW( address
, expect3
), "Expected different address string\n" );
3103 len
= sizeof(address
);
3105 sockaddr
.sin_family
= AF_INET
;
3106 sockaddr
.sin_port
= 0xffff;
3107 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
3109 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
3110 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3112 ok( !lstrcmpW( address
, expect4
), "Expected different address string\n" );
3113 ok( len
== sizeof( expect4
)/sizeof( WCHAR
), "Got %d\n", len
);
3115 /*check to see it IPv6 is available */
3116 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
3117 if (v6
== INVALID_SOCKET
) {
3118 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3119 WSAGetLastError(), WSAEAFNOSUPPORT
);
3123 /* Test a short IPv6 address */
3124 len
= sizeof(address6
)/sizeof(WCHAR
);
3126 sockaddr6
.sin6_family
= AF_INET6
;
3127 sockaddr6
.sin6_port
= 0x0000;
3128 sockaddr6
.sin6_scope_id
= 0;
3129 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
3131 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3132 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3133 ok( !lstrcmpW( address6
, expect6_1
), "Wrong string returned\n" );
3134 ok( len
== sizeof(expect6_1
)/sizeof(WCHAR
), "Got %d\n", len
);
3136 /* Test a longer IPv6 address */
3137 len
= sizeof(address6
)/sizeof(WCHAR
);
3139 sockaddr6
.sin6_family
= AF_INET6
;
3140 sockaddr6
.sin6_port
= 0x0000;
3141 sockaddr6
.sin6_scope_id
= 0;
3142 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
3144 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3145 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3147 ok( !lstrcmpW( address6
, expect6_2
), "Wrong string returned\n" );
3148 ok( len
== sizeof(expect6_2
)/sizeof(WCHAR
), "Got %d\n", len
);
3150 /* Test IPv6 address and port number */
3151 len
= sizeof(address6
)/sizeof(WCHAR
);
3153 sockaddr6
.sin6_family
= AF_INET6
;
3154 sockaddr6
.sin6_port
= 0xfa81;
3155 sockaddr6
.sin6_scope_id
= 0;
3156 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3158 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3159 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3160 ok( !lstrcmpW( address6
, expect6_3
) ||
3161 broken( !lstrcmpW( address6
, expect6_3_nt
) ) || /* NT4 */
3162 broken( !lstrcmpW( address6
, expect6_3_w2k
) ), /* Win2000 */
3163 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3
),
3164 wine_dbgstr_w(address6
) );
3165 ok( len
== sizeof(expect6_3
)/sizeof(WCHAR
) ||
3166 broken(len
== sizeof(expect6_3_nt
)/sizeof(WCHAR
) ) || /* NT4 */
3167 broken(len
== sizeof(expect6_3_w2k
)/sizeof(WCHAR
) ), /* Win2000 */
3170 /* Test IPv6 address, port number and scope_id */
3171 len
= sizeof(address6
)/sizeof(WCHAR
);
3173 sockaddr6
.sin6_family
= AF_INET6
;
3174 sockaddr6
.sin6_port
= 0xfa81;
3175 sockaddr6
.sin6_scope_id
= 0x1234;
3176 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3178 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3179 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3180 ok( !lstrcmpW( address6
, expect6_3_2
) ||
3181 broken( !lstrcmpW( address6
, expect6_3_2_nt
) ) || /* NT4 */
3182 broken( !lstrcmpW( address6
, expect6_3_2_w2k
) ), /* Win2000 */
3183 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2
),
3184 wine_dbgstr_w(address6
) );
3185 ok( len
== sizeof(expect6_3_2
)/sizeof(WCHAR
) ||
3186 broken( len
== sizeof(expect6_3_2_nt
)/sizeof(WCHAR
) ) || /* NT4 */
3187 broken( len
== sizeof(expect6_3_2_w2k
)/sizeof(WCHAR
) ), /* Win2000 */
3190 /* Test IPv6 address and scope_id */
3191 len
= sizeof(address6
)/sizeof(WCHAR
);
3193 sockaddr6
.sin6_family
= AF_INET6
;
3194 sockaddr6
.sin6_port
= 0x0000;
3195 sockaddr6
.sin6_scope_id
= 0xfffe;
3196 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
3198 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
3199 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
3200 ok( !lstrcmpW( address6
, expect6_3_3
) ||
3201 broken( !lstrcmpW( address6
, expect6_3_3_nt
) ), /* NT4 */
3202 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3
),
3203 wine_dbgstr_w(address6
) );
3204 ok( len
== sizeof(expect6_3_3
)/sizeof(WCHAR
) ||
3205 broken( len
== sizeof(expect6_3_3_nt
)/sizeof(WCHAR
) ), /* NT4 */
3209 if (v6
!= INVALID_SOCKET
)
3213 static void test_WSAStringToAddressA(void)
3216 SOCKADDR_IN sockaddr
;
3217 SOCKADDR_IN6 sockaddr6
;
3220 CHAR address1
[] = "0.0.0.0";
3221 CHAR address2
[] = "127.127.127.127";
3222 CHAR address3
[] = "255.255.255.255";
3223 CHAR address4
[] = "127.127.127.127:65535";
3224 CHAR address5
[] = "255.255.255.255:65535";
3225 CHAR address6
[] = "::1";
3226 CHAR address7
[] = "[::1]";
3227 CHAR address8
[] = "[::1]:65535";
3228 CHAR address9
[] = "2001::1";
3231 sockaddr
.sin_family
= AF_INET
;
3233 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3234 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
3235 WSAGetLastError() );
3237 len
= sizeof(sockaddr
);
3238 sockaddr
.sin_port
= 0;
3239 sockaddr
.sin_addr
.s_addr
= 0;
3241 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3242 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
3243 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3245 len
= sizeof(sockaddr
);
3246 sockaddr
.sin_port
= 0;
3247 sockaddr
.sin_addr
.s_addr
= 0;
3249 ret
= WSAStringToAddressA( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3250 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
3251 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3253 len
= sizeof(sockaddr
);
3254 sockaddr
.sin_port
= 0;
3255 sockaddr
.sin_addr
.s_addr
= 0;
3257 ret
= WSAStringToAddressA( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3258 GLE
= WSAGetLastError();
3259 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
3260 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3261 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
3263 len
= sizeof(sockaddr
);
3264 sockaddr
.sin_port
= 0;
3265 sockaddr
.sin_addr
.s_addr
= 0;
3267 ret
= WSAStringToAddressA( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3268 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
3269 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
3271 len
= sizeof(sockaddr
);
3272 sockaddr
.sin_port
= 0;
3273 sockaddr
.sin_addr
.s_addr
= 0;
3275 ret
= WSAStringToAddressA( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3276 GLE
= WSAGetLastError();
3277 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
3278 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3279 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
3281 len
= sizeof(sockaddr6
);
3282 memset(&sockaddr6
, 0, len
);
3283 sockaddr6
.sin6_family
= AF_INET6
;
3285 ret
= WSAStringToAddressA( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3287 GLE
= WSAGetLastError();
3288 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3289 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
3291 len
= sizeof(sockaddr6
);
3292 memset(&sockaddr6
, 0, len
);
3293 sockaddr6
.sin6_family
= AF_INET6
;
3295 ret
= WSAStringToAddressA( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3297 GLE
= WSAGetLastError();
3298 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3299 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
3301 len
= sizeof(sockaddr6
);
3302 memset(&sockaddr6
, 0, len
);
3303 sockaddr6
.sin6_family
= AF_INET6
;
3305 ret
= WSAStringToAddressA( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3307 GLE
= WSAGetLastError();
3308 ok( (ret
== 0 && sockaddr6
.sin6_port
== 0xffff) ||
3309 (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3310 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
3312 len
= sizeof(sockaddr
);
3314 ret
= WSAStringToAddressA( address9
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3315 GLE
= WSAGetLastError();
3316 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3317 "WSAStringToAddressA() should have failed with %d\n", GLE
);
3320 static void test_WSAStringToAddressW(void)
3323 SOCKADDR_IN sockaddr
, *sin
;
3324 SOCKADDR_IN6 sockaddr6
;
3325 SOCKADDR_STORAGE sockaddr_storage
;
3328 WCHAR address1
[] = { '0','.','0','.','0','.','0', 0 };
3329 WCHAR address2
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
3330 WCHAR address3
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
3331 WCHAR address4
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
3332 ':', '6', '5', '5', '3', '5', 0 };
3333 WCHAR address5
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
3334 '6', '5', '5', '3', '5', 0 };
3335 WCHAR address6
[] = {':',':','1','\0'};
3336 WCHAR address7
[] = {'[',':',':','1',']','\0'};
3337 WCHAR address8
[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
3338 WCHAR address9
[] = {'2','0','0','1',':',':','1','\0'};
3341 sockaddr
.sin_family
= AF_INET
;
3343 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3344 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressW() failed unexpectedly: %d\n",
3345 WSAGetLastError() );
3347 len
= sizeof(sockaddr
);
3348 sockaddr
.sin_port
= 0;
3349 sockaddr
.sin_addr
.s_addr
= 0;
3351 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3352 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
3353 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3355 len
= sizeof(sockaddr
);
3356 sockaddr
.sin_port
= 0;
3357 sockaddr
.sin_addr
.s_addr
= 0;
3359 ret
= WSAStringToAddressW( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3360 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
3361 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3363 len
= sizeof(sockaddr
);
3364 sockaddr
.sin_port
= 0;
3365 sockaddr
.sin_addr
.s_addr
= 0;
3367 ret
= WSAStringToAddressW( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3368 GLE
= WSAGetLastError();
3369 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
3370 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3371 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
3373 len
= sizeof(sockaddr
);
3374 sockaddr
.sin_port
= 0;
3375 sockaddr
.sin_addr
.s_addr
= 0;
3377 ret
= WSAStringToAddressW( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3378 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
3379 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
3381 len
= sizeof(sockaddr
);
3382 sockaddr
.sin_port
= 0;
3383 sockaddr
.sin_addr
.s_addr
= 0;
3385 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3386 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
3387 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3388 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
3390 /* Test with a larger buffer than necessary */
3391 len
= sizeof(sockaddr_storage
);
3392 sin
= (SOCKADDR_IN
*)&sockaddr_storage
;
3394 sin
->sin_addr
.s_addr
= 0;
3396 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)sin
, &len
);
3397 ok( (ret
== 0 && sin
->sin_addr
.s_addr
== 0xffffffff && sin
->sin_port
== 0xffff) ||
3398 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3399 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
3400 ok( len
== sizeof(SOCKADDR_IN
) ||
3401 broken(len
== sizeof(SOCKADDR_STORAGE
)) /* NT4/2k */,
3402 "unexpected length %d\n", len
);
3404 len
= sizeof(sockaddr6
);
3405 memset(&sockaddr6
, 0, len
);
3406 sockaddr6
.sin6_family
= AF_INET6
;
3408 ret
= WSAStringToAddressW( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3410 GLE
= WSAGetLastError();
3411 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3412 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
3414 len
= sizeof(sockaddr6
);
3415 memset(&sockaddr6
, 0, len
);
3416 sockaddr6
.sin6_family
= AF_INET6
;
3418 ret
= WSAStringToAddressW( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3420 GLE
= WSAGetLastError();
3421 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3422 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
3424 len
= sizeof(sockaddr6
);
3425 memset(&sockaddr6
, 0, len
);
3426 sockaddr6
.sin6_family
= AF_INET6
;
3428 ret
= WSAStringToAddressW( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3430 GLE
= WSAGetLastError();
3431 ok( (ret
== 0 && sockaddr6
.sin6_port
== 0xffff) ||
3432 (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3433 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
3435 len
= sizeof(sockaddr
);
3437 ret
= WSAStringToAddressW( address9
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
3438 GLE
= WSAGetLastError();
3439 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3440 "WSAStringToAddressW() should have failed with %d\n", GLE
);
3443 static DWORD WINAPI
SelectReadThread(void *param
)
3445 select_thread_params
*par
= param
;
3448 struct sockaddr_in addr
;
3449 struct timeval select_timeout
;
3452 FD_SET(par
->s
, &readfds
);
3453 select_timeout
.tv_sec
=5;
3454 select_timeout
.tv_usec
=0;
3455 addr
.sin_family
= AF_INET
;
3456 addr
.sin_addr
.s_addr
= inet_addr(SERVERIP
);
3457 addr
.sin_port
= htons(SERVERPORT
);
3459 do_bind(par
->s
, (struct sockaddr
*)&addr
, sizeof(addr
));
3460 wsa_ok(listen(par
->s
, SOMAXCONN
), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
3462 SetEvent(server_ready
);
3463 ret
= select(par
->s
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3464 par
->ReadKilled
= (ret
== 1);
3469 static DWORD WINAPI
SelectCloseThread(void *param
)
3471 SOCKET s
= *(SOCKET
*)param
;
3477 static void test_errors(void)
3480 SOCKADDR_IN SockAddr
;
3483 WSASetLastError(NO_ERROR
);
3484 sock
= socket(PF_INET
, SOCK_STREAM
, 0);
3485 ok( (sock
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3486 memset(&SockAddr
, 0, sizeof(SockAddr
));
3487 SockAddr
.sin_family
= AF_INET
;
3488 SockAddr
.sin_port
= htons(6924);
3489 SockAddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3491 ret
= connect(sock
, (PSOCKADDR
)&SockAddr
, sizeof(SockAddr
));
3492 ok( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got: %d\n", ret
);
3493 if (ret
== SOCKET_ERROR
)
3495 err
= WSAGetLastError();
3496 ok( (err
== WSAECONNREFUSED
), "expected WSAECONNREFUSED, got: %d\n", err
);
3501 fd_set set
= {1, {sock
}};
3504 timeval
.tv_usec
= 50000;
3506 ret
= select(1, NULL
, &set
, NULL
, &timeval
);
3507 ok( (ret
== 0), "expected 0 (timeout), got: %d\n", ret
);
3510 ret
= closesocket(sock
);
3511 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3514 static void test_listen(void)
3517 int ret
, acceptc
, olen
= sizeof(acceptc
);
3518 struct sockaddr_in address
;
3520 memset(&address
, 0, sizeof(address
));
3521 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3522 address
.sin_family
= AF_INET
;
3523 address
.sin_port
= htons(SERVERPORT
);
3525 /* invalid socket tests */
3526 SetLastError(0xdeadbeef);
3527 ok ((listen(0, 0) == SOCKET_ERROR
), "listen did not fail\n");
3528 ret
= WSAGetLastError();
3529 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
3531 SetLastError(0xdeadbeef);
3532 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR
), "listen did not fail\n");
3533 ret
= WSAGetLastError();
3534 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
3537 fdA
= socket(AF_INET
, SOCK_STREAM
, 0);
3538 ok ((fdA
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3540 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
3541 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3543 SetLastError(0xdeadbeef);
3544 ok ((listen(fdA
, -2) == SOCKET_ERROR
), "listen did not fail\n");
3545 ret
= WSAGetLastError();
3546 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3548 SetLastError(0xdeadbeef);
3549 ok ((listen(fdA
, 1) == SOCKET_ERROR
), "listen did not fail\n");
3550 ret
= WSAGetLastError();
3551 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3553 SetLastError(0xdeadbeef);
3554 ok ((listen(fdA
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3555 ret
= WSAGetLastError();
3556 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3558 ok (!bind(fdA
, (struct sockaddr
*) &address
, sizeof(address
)), "bind failed\n");
3560 SetLastError(0xdeadbeef);
3561 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
3562 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3565 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
3566 ok (!ret
, "getsockopt failed\n");
3567 ok (acceptc
== 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc
);
3569 ok (!listen(fdA
, 0), "listen failed\n");
3570 ok (!listen(fdA
, SOMAXCONN
), "double listen failed\n");
3573 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
3574 ok (!ret
, "getsockopt failed\n");
3575 ok (acceptc
== 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc
);
3577 SetLastError(0xdeadbeef);
3578 ok ((listen(fdB
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3579 ret
= WSAGetLastError();
3580 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3582 ret
= closesocket(fdB
);
3583 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3585 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
3586 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3588 SetLastError(0xdeadbeef);
3589 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
3590 ret
= WSAGetLastError();
3591 ok (ret
== WSAEADDRINUSE
, "expected 10048, received %d\n", ret
);
3593 ret
= closesocket(fdA
);
3594 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3595 ret
= closesocket(fdB
);
3596 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3599 #define FD_ZERO_ALL() { FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds); }
3600 #define FD_SET_ALL(s) { FD_SET(s, &readfds); FD_SET(s, &writefds); FD_SET(s, &exceptfds); }
3601 static void test_select(void)
3603 static char tmp_buf
[1024];
3605 SOCKET fdListen
, fdRead
, fdWrite
;
3606 fd_set readfds
, writefds
, exceptfds
;
3610 struct timeval select_timeout
;
3611 struct sockaddr_in address
;
3612 select_thread_params thread_params
;
3613 HANDLE thread_handle
;
3616 fdRead
= socket(AF_INET
, SOCK_STREAM
, 0);
3617 ok( (fdRead
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3618 fdWrite
= socket(AF_INET
, SOCK_STREAM
, 0);
3619 ok( (fdWrite
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3622 if (fdWrite
> maxfd
)
3627 FD_SET_ALL(fdWrite
);
3628 select_timeout
.tv_sec
=0;
3629 select_timeout
.tv_usec
=0;
3631 ticks
= GetTickCount();
3632 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3633 ticks
= GetTickCount() - ticks
;
3634 ok(ret
== 0, "select should not return any socket handles\n");
3635 ok(ticks
< 10, "select was blocking for %u ms, expected < 10 ms\n", ticks
);
3636 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3637 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
3638 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3639 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
3643 FD_SET_ALL(fdWrite
);
3644 select_timeout
.tv_sec
=0;
3645 select_timeout
.tv_usec
=500;
3647 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3648 ok(ret
== 0, "select should not return any socket handles\n");
3649 ok(!FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3650 ok(!FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
3651 ok(!FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3652 ok(!FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
3654 ok ((listen(fdWrite
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3655 ret
= closesocket(fdWrite
);
3656 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3658 thread_params
.s
= fdRead
;
3659 thread_params
.ReadKilled
= FALSE
;
3660 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
3661 thread_handle
= CreateThread (NULL
, 0, SelectReadThread
, &thread_params
, 0, &id
);
3662 ok ( (thread_handle
!= NULL
), "CreateThread failed unexpectedly: %d\n", GetLastError());
3664 WaitForSingleObject (server_ready
, INFINITE
);
3666 ret
= closesocket(fdRead
);
3667 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3669 WaitForSingleObject (thread_handle
, 1000);
3670 ok ( (thread_params
.ReadKilled
) ||
3671 broken(thread_params
.ReadKilled
== 0), /*Win98*/
3672 "closesocket did not wakeup select\n");
3673 ret
= recv(fdRead
, &buffer
, 1, MSG_PEEK
);
3674 ok( (ret
== -1), "peek at closed socket expected -1 got %d\n", ret
);
3676 /* Test selecting invalid handles */
3680 ret
= select(maxfd
+1, 0, 0, 0, &select_timeout
);
3681 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3682 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3685 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3686 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3687 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3689 FD_SET(INVALID_SOCKET
, &readfds
);
3691 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3692 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3693 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3694 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3697 FD_SET(INVALID_SOCKET
, &writefds
);
3699 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3700 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3701 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3702 ok ( !FD_ISSET(fdRead
, &writefds
), "FD should not be set\n");
3705 FD_SET(INVALID_SOCKET
, &exceptfds
);
3707 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3708 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3709 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3710 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3712 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
3714 if(fdWrite
> maxfd
) maxfd
= fdWrite
;
3717 FD_SET(fdRead
, &readfds
);
3718 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3719 ok(!ret
, "select returned %d\n", ret
);
3722 FD_SET(fdWrite
, &writefds
);
3723 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
3724 ok(ret
== 1, "select returned %d\n", ret
);
3725 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3727 /* tests for overlapping fd_set pointers */
3729 FD_SET(fdWrite
, &readfds
);
3730 ret
= select(fdWrite
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3731 ok(ret
== 1, "select returned %d\n", ret
);
3732 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3735 FD_SET(fdWrite
, &readfds
);
3736 FD_SET(fdRead
, &readfds
);
3737 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3738 ok(ret
== 2, "select returned %d\n", ret
);
3739 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3740 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3742 ok(send(fdWrite
, "test", 4, 0) == 4, "failed to send data\n");
3744 FD_SET(fdRead
, &readfds
);
3745 ret
= select(fdRead
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3746 ok(ret
== 1, "select returned %d\n", ret
);
3747 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3750 FD_SET(fdWrite
, &readfds
);
3751 FD_SET(fdRead
, &readfds
);
3752 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3753 ok(ret
== 2, "select returned %d\n", ret
);
3754 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3755 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3757 #if ROSTESTS_233_IS_FIXED
3760 FD_SET(fdWrite
, &writefds
);
3761 ret
= select(fdWrite
+1, NULL
, &writefds
, NULL
, &select_timeout
);
3763 ok(send(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0) > 0, "failed to send data\n");
3765 #endif /* ROSTESTS_233_IS_FIXED */
3768 FD_SET(fdWrite
, &readfds
);
3769 FD_SET(fdRead
, &readfds
);
3770 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3771 ok(ret
== 1, "select returned %d\n", ret
);
3772 ok(!FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is in the set\n");
3773 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3775 ok(send(fdRead
, "test", 4, 0) == 4, "failed to send data\n");
3778 FD_SET(fdWrite
, &readfds
);
3779 FD_SET(fdRead
, &readfds
);
3780 ret
= select(maxfd
+1, &readfds
, &readfds
, NULL
, &select_timeout
);
3781 ok(ret
== 2, "select returned %d\n", ret
);
3782 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3783 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3785 closesocket(fdRead
);
3786 closesocket(fdWrite
);
3788 /* select() works in 3 distinct states:
3789 * - to check if a connection attempt ended with success or error;
3790 * - to check if a pending connection is waiting for acceptance;
3791 * - to check for data to read, availability for write and OOB data
3793 * The tests below ensure that all conditions are tested.
3795 memset(&address
, 0, sizeof(address
));
3796 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3797 address
.sin_family
= AF_INET
;
3798 len
= sizeof(address
);
3799 fdListen
= setup_server_socket(&address
, &len
);
3800 select_timeout
.tv_sec
= 1;
3801 select_timeout
.tv_usec
= 250000;
3803 /* When no events are pending select returns 0 with no error */
3805 FD_SET_ALL(fdListen
);
3806 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3807 ok(ret
== 0, "expected 0, got %d\n", ret
);
3809 /* When a socket is attempting to connect the listening socket receives the read descriptor */
3810 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
3812 FD_SET_ALL(fdListen
);
3813 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3814 ok(ret
== 1, "expected 1, got %d\n", ret
);
3815 ok(FD_ISSET(fdListen
, &readfds
), "fdListen socket is not in the set\n");
3816 len
= sizeof(address
);
3817 fdRead
= accept(fdListen
, (struct sockaddr
*) &address
, &len
);
3818 ok(fdRead
!= INVALID_SOCKET
, "expected a valid socket\n");
3820 /* The connector is signaled through the write descriptor */
3822 FD_SET_ALL(fdListen
);
3824 FD_SET_ALL(fdWrite
);
3825 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3826 ok(ret
== 2, "expected 2, got %d\n", ret
);
3827 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3828 ok(FD_ISSET(fdRead
, &writefds
), "fdRead socket is not in the set\n");
3831 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
3832 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3833 ok(id
== 0, "expected 0, got %d\n", id
);
3835 /* When data is received the receiver gets the read descriptor */
3836 ret
= send(fdWrite
, "1234", 4, 0);
3837 ok(ret
== 4, "expected 4, got %d\n", ret
);
3839 FD_SET_ALL(fdListen
);
3840 FD_SET(fdRead
, &readfds
);
3841 FD_SET(fdRead
, &exceptfds
);
3842 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3843 ok(ret
== 1, "expected 1, got %d\n", ret
);
3844 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3845 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
3846 ok(ret
== 4, "expected 4, got %d\n", ret
);
3847 ok(!strcmp(tmp_buf
, "1234"), "data received differs from sent\n");
3849 /* When OOB data is received the socket is set in the except descriptor */
3850 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
3851 ok(ret
== 1, "expected 1, got %d\n", ret
);
3853 FD_SET_ALL(fdListen
);
3854 FD_SET(fdRead
, &readfds
);
3855 FD_SET(fdRead
, &exceptfds
);
3856 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3857 ok(ret
== 1, "expected 1, got %d\n", ret
);
3858 ok(FD_ISSET(fdRead
, &exceptfds
), "fdRead socket is not in the set\n");
3860 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
3861 ok(ret
== 1, "expected 1, got %d\n", ret
);
3862 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
3864 /* If the socket is OOBINLINED it will not receive the OOB in except fds */
3866 ret
= setsockopt(fdRead
, SOL_SOCKET
, SO_OOBINLINE
, (char*) &ret
, sizeof(ret
));
3867 ok(ret
== 0, "expected 0, got %d\n", ret
);
3868 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
3869 ok(ret
== 1, "expected 1, got %d\n", ret
);
3871 FD_SET_ALL(fdListen
);
3872 FD_SET(fdRead
, &readfds
);
3873 FD_SET(fdRead
, &exceptfds
);
3874 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3875 ok(ret
== 1, "expected 1, got %d\n", ret
);
3876 ok(FD_ISSET(fdRead
, &readfds
), "fdRead socket is not in the set\n");
3878 SetLastError(0xdeadbeef);
3879 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
3880 if (ret
== SOCKET_ERROR
) /* can't recv with MSG_OOB if OOBINLINED */
3882 ok(GetLastError() == WSAEINVAL
, "expected 10022, got %d\n", GetLastError());
3883 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
3884 ok(ret
== 1, "expected 1, got %d\n", ret
);
3885 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
3887 else ok(broken(ret
== 1) /* <= NT4 */, "expected error, got 1\n");
3889 /* When the connection is closed the socket is set in the read descriptor */
3890 ret
= closesocket(fdRead
);
3891 ok(ret
== 0, "expected 0, got %d\n", ret
);
3893 FD_SET_ALL(fdListen
);
3894 FD_SET(fdWrite
, &readfds
);
3895 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3896 ok(ret
== 1, "expected 1, got %d\n", ret
);
3897 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3898 ret
= recv(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0);
3899 ok(ret
== 0, "expected 0, got %d\n", ret
);
3901 /* When a connection is attempted to a non-listening socket it will get to the except descriptor */
3902 ret
= closesocket(fdWrite
);
3903 ok(ret
== 0, "expected 0, got %d\n", ret
);
3904 ret
= closesocket(fdListen
);
3905 ok(ret
== 0, "expected 0, got %d\n", ret
);
3906 len
= sizeof(address
);
3907 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
3909 FD_SET(fdWrite
, &writefds
);
3910 FD_SET(fdWrite
, &exceptfds
);
3911 select_timeout
.tv_sec
= 2; /* requires more time to realize it will not connect */
3912 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3913 ok(ret
== 1, "expected 1, got %d\n", ret
);
3916 ret
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
3917 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
3918 ok(id
== WSAECONNREFUSED
, "expected 10061, got %d\n", id
);
3919 ok(FD_ISSET(fdWrite
, &exceptfds
), "fdWrite socket is not in the set\n");
3920 ok(select_timeout
.tv_usec
== 250000, "select timeout should not have changed\n");
3921 closesocket(fdWrite
);
3923 /* Try select() on a closed socket after connection */
3924 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
3925 closesocket(fdRead
);
3927 FD_SET_ALL(fdWrite
);
3929 SetLastError(0xdeadbeef);
3930 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
3931 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
3933 ok(GetLastError() == WSAENOTSOCK
, "expected 10038, got %d\n", GetLastError());
3934 /* descriptor sets are unchanged */
3935 ok(readfds
.fd_count
== 2, "expected 2, got %d\n", readfds
.fd_count
);
3936 ok(exceptfds
.fd_count
== 2, "expected 2, got %d\n", exceptfds
.fd_count
);
3937 closesocket(fdWrite
);
3939 #if ROSTESTS_233_IS_FIXED
3941 /* Close the socket currently being selected in a thread - bug 38399 */
3942 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
3943 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
3944 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
3946 FD_SET_ALL(fdWrite
);
3947 ret
= select(0, &readfds
, NULL
, &exceptfds
, &select_timeout
);
3948 ok(ret
== 1, "expected 1, got %d\n", ret
);
3949 ok(FD_ISSET(fdWrite
, &readfds
), "fdWrite socket is not in the set\n");
3950 WaitForSingleObject (thread_handle
, 1000);
3951 closesocket(fdRead
);
3952 /* test again with only the except descriptor */
3953 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
3954 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
3955 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
3957 FD_SET(fdWrite
, &exceptfds
);
3958 SetLastError(0xdeadbeef);
3959 ret
= select(0, NULL
, NULL
, &exceptfds
, &select_timeout
);
3961 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
3963 ok(GetLastError() == WSAENOTSOCK
, "expected 10038, got %d\n", GetLastError());
3964 WaitForSingleObject (thread_handle
, 1000);
3965 closesocket(fdRead
);
3967 #endif /* ROSTESTS_233_IS_FIXED */
3969 /* test UDP behavior of unbound sockets */
3970 select_timeout
.tv_sec
= 0;
3971 select_timeout
.tv_usec
= 250000;
3972 fdWrite
= socket(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
3973 ok(fdWrite
!= INVALID_SOCKET
, "socket call failed\n");
3975 FD_SET_ALL(fdWrite
);
3976 ret
= select(0, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3977 ok(ret
== 1, "expected 1, got %d\n", ret
);
3978 ok(FD_ISSET(fdWrite
, &writefds
), "fdWrite socket is not in the set\n");
3979 closesocket(fdWrite
);
3984 static DWORD WINAPI
AcceptKillThread(void *param
)
3986 select_thread_params
*par
= param
;
3987 struct sockaddr_in address
;
3988 int len
= sizeof(address
);
3989 SOCKET client_socket
;
3991 SetEvent(server_ready
);
3992 client_socket
= accept(par
->s
, (struct sockaddr
*) &address
, &len
);
3993 if (client_socket
!= INVALID_SOCKET
)
3994 closesocket(client_socket
);
3995 par
->ReadKilled
= (client_socket
== INVALID_SOCKET
);
4000 static int CALLBACK
AlwaysDeferConditionFunc(LPWSABUF lpCallerId
, LPWSABUF lpCallerData
, LPQOS pQos
,
4001 LPQOS lpGQOS
, LPWSABUF lpCalleeId
, LPWSABUF lpCalleeData
,
4002 GROUP
*g
, DWORD_PTR dwCallbackData
)
4007 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
)
4010 SOCKET server_socket
;
4012 server_socket
= socket(AF_INET
, SOCK_STREAM
, 0);
4013 if (server_socket
== INVALID_SOCKET
)
4015 trace("error creating server socket: %d\n", WSAGetLastError());
4016 return INVALID_SOCKET
;
4020 ret
= setsockopt(server_socket
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
4023 trace("error setting SO_REUSEADDR: %d\n", WSAGetLastError());
4024 closesocket(server_socket
);
4025 return INVALID_SOCKET
;
4028 ret
= bind(server_socket
, (struct sockaddr
*)addr
, *len
);
4031 trace("error binding server socket: %d\n", WSAGetLastError());
4034 ret
= getsockname(server_socket
, (struct sockaddr
*)addr
, len
);
4037 skip("failed to lookup bind address: %d\n", WSAGetLastError());
4038 closesocket(server_socket
);
4039 return INVALID_SOCKET
;
4042 ret
= listen(server_socket
, 5);
4045 trace("error making server socket listen: %d\n", WSAGetLastError());
4046 closesocket(server_socket
);
4047 return INVALID_SOCKET
;
4050 return server_socket
;
4053 static SOCKET
setup_connector_socket(struct sockaddr_in
*addr
, int len
, BOOL nonblock
)
4058 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
4059 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket %d\n", WSAGetLastError());
4062 set_blocking(connector
, !nonblock
);
4064 ret
= connect(connector
, (struct sockaddr
*)addr
, len
);
4066 ok(!ret
, "connecting to accepting socket failed %d\n", WSAGetLastError());
4067 else if (ret
== SOCKET_ERROR
)
4069 DWORD error
= WSAGetLastError();
4070 ok(error
== WSAEWOULDBLOCK
|| error
== WSAEINPROGRESS
,
4071 "expected 10035 or 10036, got %d\n", error
);
4077 static void test_accept(void)
4080 SOCKET server_socket
, accepted
= INVALID_SOCKET
, connector
;
4081 struct sockaddr_in address
;
4082 SOCKADDR_STORAGE ss
;
4084 select_thread_params thread_params
;
4085 HANDLE thread_handle
= NULL
;
4088 memset(&address
, 0, sizeof(address
));
4089 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4090 address
.sin_family
= AF_INET
;
4092 socklen
= sizeof(address
);
4093 server_socket
= setup_server_socket(&address
, &socklen
);
4094 if (server_socket
== INVALID_SOCKET
)
4096 trace("error creating server socket: %d\n", WSAGetLastError());
4100 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4101 if (connector
== INVALID_SOCKET
) goto done
;
4103 trace("Blocking accept next\n");
4105 accepted
= WSAAccept(server_socket
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
4106 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
4108 accepted
= accept(server_socket
, NULL
, 0);
4109 ok(accepted
!= INVALID_SOCKET
, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
4111 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
4112 if (server_ready
== INVALID_HANDLE_VALUE
)
4114 trace("error creating event: %d\n", GetLastError());
4118 thread_params
.s
= server_socket
;
4119 thread_params
.ReadKilled
= FALSE
;
4120 thread_handle
= CreateThread(NULL
, 0, AcceptKillThread
, &thread_params
, 0, &id
);
4121 if (thread_handle
== NULL
)
4123 trace("error creating thread: %d\n", GetLastError());
4127 WaitForSingleObject(server_ready
, INFINITE
);
4129 ret
= closesocket(server_socket
);
4132 trace("closesocket failed: %d\n", WSAGetLastError());
4136 WaitForSingleObject(thread_handle
, 1000);
4137 ok(thread_params
.ReadKilled
|| broken(!thread_params
.ReadKilled
) /* Win98/ME, after accept */,
4138 "closesocket did not wakeup accept\n");
4140 closesocket(accepted
);
4141 closesocket(connector
);
4142 accepted
= connector
= INVALID_SOCKET
;
4144 socklen
= sizeof(address
);
4145 server_socket
= setup_server_socket(&address
, &socklen
);
4146 if (server_socket
== INVALID_SOCKET
) goto done
;
4148 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4149 if (connector
== INVALID_SOCKET
) goto done
;
4152 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
4153 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
4154 ok(!socklen
, "got %d\n", socklen
);
4155 closesocket(connector
);
4156 connector
= INVALID_SOCKET
;
4158 socklen
= sizeof(address
);
4159 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4160 if (connector
== INVALID_SOCKET
) goto done
;
4162 accepted
= WSAAccept(server_socket
, NULL
, NULL
, NULL
, 0);
4163 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4164 closesocket(accepted
);
4165 closesocket(connector
);
4166 accepted
= connector
= INVALID_SOCKET
;
4168 socklen
= sizeof(address
);
4169 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4170 if (connector
== INVALID_SOCKET
) goto done
;
4172 socklen
= sizeof(ss
);
4173 memset(&ss
, 0, sizeof(ss
));
4174 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
4175 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4176 ok(socklen
!= sizeof(ss
), "unexpected length\n");
4177 ok(ss
.ss_family
, "family not set\n");
4178 closesocket(accepted
);
4179 closesocket(connector
);
4180 accepted
= connector
= INVALID_SOCKET
;
4182 socklen
= sizeof(address
);
4183 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4184 if (connector
== INVALID_SOCKET
) goto done
;
4187 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
4188 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
4189 ok(!socklen
, "got %d\n", socklen
);
4190 closesocket(connector
);
4191 accepted
= connector
= INVALID_SOCKET
;
4193 socklen
= sizeof(address
);
4194 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4195 if (connector
== INVALID_SOCKET
) goto done
;
4197 accepted
= accept(server_socket
, NULL
, NULL
);
4198 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4199 closesocket(accepted
);
4200 closesocket(connector
);
4201 accepted
= connector
= INVALID_SOCKET
;
4203 socklen
= sizeof(address
);
4204 connector
= setup_connector_socket(&address
, socklen
, FALSE
);
4205 if (connector
== INVALID_SOCKET
) goto done
;
4207 socklen
= sizeof(ss
);
4208 memset(&ss
, 0, sizeof(ss
));
4209 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
4210 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
4211 ok(socklen
!= sizeof(ss
), "unexpected length\n");
4212 ok(ss
.ss_family
, "family not set\n");
4215 if (accepted
!= INVALID_SOCKET
)
4216 closesocket(accepted
);
4217 if (connector
!= INVALID_SOCKET
)
4218 closesocket(connector
);
4219 if (thread_handle
!= NULL
)
4220 CloseHandle(thread_handle
);
4221 if (server_ready
!= INVALID_HANDLE_VALUE
)
4222 CloseHandle(server_ready
);
4223 if (server_socket
!= INVALID_SOCKET
)
4224 closesocket(server_socket
);
4227 static void test_extendedSocketOptions(void)
4231 struct sockaddr_in sa
;
4232 int sa_len
= sizeof(struct sockaddr_in
);
4233 int optval
, optlen
= sizeof(int), ret
;
4237 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
4238 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4242 memset(&sa
, 0, sa_len
);
4244 sa
.sin_family
= AF_INET
;
4245 sa
.sin_port
= htons(0);
4246 sa
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
4248 if((sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
4249 trace("Creating the socket failed: %d\n", WSAGetLastError());
4254 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
4255 trace("Failed to bind socket: %d\n", WSAGetLastError());
4261 ret
= getsockopt(sock
, SOL_SOCKET
, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4263 ok(ret
== 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret
);
4264 ok((optval
== 65507) || (optval
== 65527),
4265 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval
);
4267 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
4268 SetLastError(0xdeadbeef);
4269 optval
= 0xdeadbeef;
4270 optlen
= sizeof(int);
4271 ret
= getsockopt(sock
, 0xffffffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4272 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
4273 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4274 ret
, WSAGetLastError(), optval
, optval
);
4276 /* more invalid values for level */
4277 SetLastError(0xdeadbeef);
4278 optval
= 0xdeadbeef;
4279 optlen
= sizeof(int);
4280 ret
= getsockopt(sock
, 0x1234ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4281 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
4282 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4283 ret
, WSAGetLastError(), optval
, optval
);
4285 SetLastError(0xdeadbeef);
4286 optval
= 0xdeadbeef;
4287 optlen
= sizeof(int);
4288 ret
= getsockopt(sock
, 0x8000ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4289 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
4290 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4291 ret
, WSAGetLastError(), optval
, optval
);
4293 SetLastError(0xdeadbeef);
4294 optval
= 0xdeadbeef;
4295 optlen
= sizeof(int);
4296 ret
= getsockopt(sock
, 0x00008000, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4297 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
4298 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4299 ret
, WSAGetLastError(), optval
, optval
);
4301 SetLastError(0xdeadbeef);
4302 optval
= 0xdeadbeef;
4303 optlen
= sizeof(int);
4304 ret
= getsockopt(sock
, 0x00000800, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
4305 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
4306 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
4307 ret
, WSAGetLastError(), optval
, optval
);
4309 SetLastError(0xdeadbeef);
4310 optlen
= sizeof(LINGER
);
4311 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
4312 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOPROTOOPT
),
4313 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
4314 ret
, WSAGetLastError());
4317 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
4318 trace("Creating the socket failed: %d\n", WSAGetLastError());
4323 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
4324 trace("Failed to bind socket: %d\n", WSAGetLastError());
4330 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
4331 ok(ret
== 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret
);
4333 optlen
= sizeof(BOOL
);
4334 ret
= getsockopt(sock
, SOL_SOCKET
, SO_DONTLINGER
, (char *)&bool_opt_val
, &optlen
);
4335 ok(ret
== 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret
);
4336 ok((linger_val
.l_onoff
&& !bool_opt_val
) || (!linger_val
.l_onoff
&& bool_opt_val
),
4337 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
4338 bool_opt_val
, linger_val
.l_onoff
);
4344 static void test_getsockname(void)
4348 struct sockaddr_in sa_set
, sa_get
;
4349 int sa_set_len
= sizeof(struct sockaddr_in
);
4350 int sa_get_len
= sa_set_len
;
4351 static const unsigned char null_padding
[] = {0,0,0,0,0,0,0,0};
4355 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
4356 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
4360 memset(&sa_set
, 0, sa_set_len
);
4362 sa_set
.sin_family
= AF_INET
;
4363 sa_set
.sin_port
= htons(0);
4364 sa_set
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
4366 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
4367 trace("Creating the socket failed: %d\n", WSAGetLastError());
4373 if (getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) == 0)
4374 ok(0, "getsockname on unbound socket should fail\n");
4376 ok(WSAGetLastError() == WSAEINVAL
, "getsockname on unbound socket "
4377 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL
);
4378 ok(memcmp(&sa_get
, &sa_set
, sizeof(sa_get
)) == 0,
4379 "failed getsockname modified sockaddr when it shouldn't\n");
4382 if(bind(sock
, (struct sockaddr
*) &sa_set
, sa_set_len
) < 0){
4383 trace("Failed to bind socket: %d\n", WSAGetLastError());
4389 if(getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) != 0){
4390 trace("Failed to call getsockname: %d\n", WSAGetLastError());
4396 ret
= memcmp(sa_get
.sin_zero
, null_padding
, 8);
4397 ok(ret
== 0 || broken(ret
!= 0), /* NT4 */
4398 "getsockname did not zero the sockaddr_in structure\n");
4402 h
= gethostbyname("");
4403 if (h
&& h
->h_length
== 4) /* this test is only meaningful in IPv4 */
4406 for (i
= 0; h
->h_addr_list
[i
]; i
++)
4410 ip
.s_addr
= *(ULONG
*) h
->h_addr_list
[i
];
4412 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
4413 ok(sock
!= INVALID_SOCKET
, "socket failed with %d\n", GetLastError());
4415 memset(&sa_set
, 0, sizeof(sa_set
));
4416 sa_set
.sin_family
= AF_INET
;
4417 sa_set
.sin_addr
.s_addr
= ip
.s_addr
;
4418 /* The same address we bind must be the same address we get */
4419 ret
= bind(sock
, (struct sockaddr
*)&sa_set
, sizeof(sa_set
));
4420 ok(ret
== 0, "bind failed with %d\n", GetLastError());
4421 sa_get_len
= sizeof(sa_get
);
4422 ret
= getsockname(sock
, (struct sockaddr
*)&sa_get
, &sa_get_len
);
4423 ok(ret
== 0, "getsockname failed with %d\n", GetLastError());
4424 strcpy(ipstr
, inet_ntoa(sa_get
.sin_addr
));
4425 trace("testing bind on interface %s\n", ipstr
);
4426 ok(sa_get
.sin_addr
.s_addr
== sa_set
.sin_addr
.s_addr
,
4427 "address does not match: %s != %s\n", ipstr
, inet_ntoa(sa_set
.sin_addr
));
4436 static void test_dns(void)
4447 h
= gethostbyname("");
4448 ok(h
!= NULL
, "gethostbyname(\"\") failed with %d\n", h_errno
);
4450 /* Use an address with valid alias names if possible */
4451 h
= gethostbyname("source.winehq.org");
4454 skip("Can't test the hostent structure because gethostbyname failed\n");
4458 /* The returned struct must be allocated in a very strict way. First we need to
4459 * count how many aliases there are because they must be located right after
4460 * the struct hostent size. Knowing the amount of aliases we know the exact
4461 * location of the first IP returned. Rule valid for >= XP, for older OS's
4462 * it's somewhat the opposite. */
4464 if(h
->h_addr_list
== addr
.mem
) /* <= W2K */
4466 win_skip("Skipping hostent tests since this OS is unsupported\n");
4470 ok(h
->h_aliases
== addr
.mem
,
4471 "hostent->h_aliases should be in %p, it is in %p\n", addr
.mem
, h
->h_aliases
);
4473 for(ptr
= h
->h_aliases
, acount
= 1; *ptr
; ptr
++) acount
++;
4474 addr
.chr
+= sizeof(*ptr
) * acount
;
4475 ok(h
->h_addr_list
== addr
.mem
,
4476 "hostent->h_addr_list should be in %p, it is in %p\n", addr
.mem
, h
->h_addr_list
);
4478 for(ptr
= h
->h_addr_list
, acount
= 1; *ptr
; ptr
++) acount
++;
4480 addr
.chr
+= sizeof(*ptr
) * acount
;
4481 ok(h
->h_addr_list
[0] == addr
.mem
,
4482 "hostent->h_addr_list[0] should be in %p, it is in %p\n", addr
.mem
, h
->h_addr_list
[0]);
4486 /* Our winsock headers don't define gethostname because it conflicts with the
4487 * definition in unistd.h. Define it here to get rid of the warning. */
4489 int WINAPI
gethostname(char *name
, int namelen
);
4492 static void test_gethostbyname(void)
4495 struct in_addr
**addr_list
;
4496 char name
[256], first_ip
[16];
4498 PMIB_IPFORWARDTABLE routes
= NULL
;
4499 PIP_ADAPTER_INFO adapters
= NULL
, k
;
4500 DWORD adap_size
= 0, route_size
= 0;
4501 BOOL found_default
= FALSE
;
4502 BOOL local_ip
= FALSE
;
4504 ret
= gethostname(name
, sizeof(name
));
4505 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
4507 he
= gethostbyname(name
);
4508 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, WSAGetLastError());
4509 #ifdef __REACTOS__ /* ROSTESTS-233 */
4513 addr_list
= (struct in_addr
**)he
->h_addr_list
;
4514 strcpy(first_ip
, inet_ntoa(*addr_list
[0]));
4516 trace("List of local IPs:\n");
4517 for(count
= 0; addr_list
[count
] != NULL
; count
++)
4519 char *ip
= inet_ntoa(*addr_list
[count
]);
4520 if (!strcmp(ip
, "127.0.0.1"))
4524 #ifdef __REACTOS__ /* ROSTESTS-233 */
4530 ok (count
== 1, "expected 127.0.0.1 to be the only IP returned\n");
4531 skip("Only the loopback address is present, skipping tests\n");
4535 if (!pGetAdaptersInfo
|| !pGetIpForwardTable
)
4537 win_skip("GetAdaptersInfo and/or GetIpForwardTable not found, skipping tests\n");
4541 ret
= pGetAdaptersInfo(NULL
, &adap_size
);
4542 ok (ret
== ERROR_BUFFER_OVERFLOW
, "GetAdaptersInfo failed with a different error: %d\n", ret
);
4543 ret
= pGetIpForwardTable(NULL
, &route_size
, FALSE
);
4544 ok (ret
== ERROR_INSUFFICIENT_BUFFER
, "GetIpForwardTable failed with a different error: %d\n", ret
);
4546 adapters
= HeapAlloc(GetProcessHeap(), 0, adap_size
);
4547 routes
= HeapAlloc(GetProcessHeap(), 0, route_size
);
4549 ret
= pGetAdaptersInfo(adapters
, &adap_size
);
4550 ok (ret
== NO_ERROR
, "GetAdaptersInfo failed, error: %d\n", ret
);
4551 ret
= pGetIpForwardTable(routes
, &route_size
, FALSE
);
4552 ok (ret
== NO_ERROR
, "GetIpForwardTable failed, error: %d\n", ret
);
4554 /* This test only has meaning if there is more than one IP configured */
4555 if (adapters
->Next
== NULL
&& count
== 1)
4557 skip("Only one IP is present, skipping tests\n");
4561 for (i
= 0; !found_default
&& i
< routes
->dwNumEntries
; i
++)
4563 /* default route (ip 0.0.0.0) ? */
4564 if (routes
->table
[i
].dwForwardDest
) continue;
4566 for (k
= adapters
; k
!= NULL
; k
= k
->Next
)
4570 if (k
->Index
!= routes
->table
[i
].dwForwardIfIndex
) continue;
4572 /* the first IP returned from gethostbyname must be a default route */
4573 ip
= k
->IpAddressList
.IpAddress
.String
;
4574 if (!strcmp(first_ip
, ip
))
4576 found_default
= TRUE
;
4581 ok (found_default
, "failed to find the first IP from gethostbyname!\n");
4584 HeapFree(GetProcessHeap(), 0, adapters
);
4585 HeapFree(GetProcessHeap(), 0, routes
);
4588 static void test_gethostbyname_hack(void)
4592 static BYTE loopback
[] = {127, 0, 0, 1};
4593 static BYTE magic_loopback
[] = {127, 12, 34, 56};
4596 ret
= gethostname(name
, 256);
4597 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
4599 he
= gethostbyname("localhost");
4600 ok(he
!= NULL
, "gethostbyname(\"localhost\") failed: %d\n", h_errno
);
4603 if(he
->h_length
!= 4)
4605 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
4609 ok(memcmp(he
->h_addr_list
[0], loopback
, he
->h_length
) == 0,
4610 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
4611 he
->h_addr_list
[0][0], he
->h_addr_list
[0][1], he
->h_addr_list
[0][2],
4612 he
->h_addr_list
[0][3]);
4615 if(strcmp(name
, "localhost") == 0)
4617 skip("hostname seems to be \"localhost\", skipping test.\n");
4621 he
= gethostbyname(name
);
4622 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, h_errno
);
4625 if(he
->h_length
!= 4)
4627 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
4631 if (he
->h_addr_list
[0][0] == 127)
4633 ok(memcmp(he
->h_addr_list
[0], magic_loopback
, he
->h_length
) == 0,
4634 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
4635 name
, he
->h_addr_list
[0][0], he
->h_addr_list
[0][1],
4636 he
->h_addr_list
[0][2], he
->h_addr_list
[0][3]);
4640 gethostbyname("nonexistent.winehq.org");
4641 /* Don't check for the return value, as some braindead ISPs will kindly
4642 * resolve nonexistent host names to addresses of the ISP's spam pages. */
4645 static void test_gethostname(void)
4651 WSASetLastError(0xdeadbeef);
4652 ret
= gethostname(NULL
, 256);
4653 ok(ret
== -1, "gethostname() returned %d\n", ret
);
4654 ok(WSAGetLastError() == WSAEFAULT
, "gethostname with null buffer "
4655 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT
);
4657 ret
= gethostname(name
, sizeof(name
));
4658 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
4659 he
= gethostbyname(name
);
4660 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, WSAGetLastError());
4663 WSASetLastError(0xdeadbeef);
4664 strcpy(name
, "deadbeef");
4665 ret
= gethostname(name
, len
);
4666 ok(ret
== -1, "gethostname() returned %d\n", ret
);
4667 ok(!strcmp(name
, "deadbeef"), "name changed unexpected!\n");
4668 ok(WSAGetLastError() == WSAEFAULT
, "gethostname with insufficient length "
4669 "failed with %d, expected %d\n", WSAGetLastError(), WSAEFAULT
);
4672 ret
= gethostname(name
, len
);
4673 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
4674 he
= gethostbyname(name
);
4675 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, WSAGetLastError());
4678 static void test_inet_addr(void)
4682 addr
= inet_addr(NULL
);
4683 ok(addr
== INADDR_NONE
, "inet_addr succeeded unexpectedly\n");
4686 static void test_addr_to_print(void)
4692 struct in6_addr in6
;
4694 u_long addr0_Num
= 0x00000000;
4695 PCSTR addr0_Str
= "0.0.0.0";
4696 u_long addr1_Num
= 0x20201015;
4697 PCSTR addr1_Str
= "21.16.32.32";
4698 u_char addr2_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
4699 PCSTR addr2_Str
= "::fffe:cc98:bd74";
4700 u_char addr3_Num
[16] = {0x20,0x30,0xa4,0xb1};
4701 PCSTR addr3_Str
= "2030:a4b1::";
4702 u_char addr4_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
4703 PCSTR addr4_Str
= "::204.152.189.116";
4705 /* Test IPv4 addresses */
4706 in
.s_addr
= addr0_Num
;
4708 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
4709 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
4710 ok(!strcmp(pdst
, addr0_Str
),"Address %s != %s\n", pdst
, addr0_Str
);
4712 /* Test that inet_ntoa and inet_ntop return the same value */
4713 in
.S_un
.S_addr
= addr1_Num
;
4714 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
4715 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
4716 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
4718 /* InetNtop became available in Vista and Win2008 */
4721 win_skip("InetNtop not present, not executing tests\n");
4725 /* Second part of test */
4726 pdst
= pInetNtop(AF_INET
,(void*)&in
.s_addr
, dst
, sizeof(dst
));
4727 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst
);
4728 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
4730 /* Test invalid parm conditions */
4731 pdst
= pInetNtop(1, (void*)&in
.s_addr
, dst
, sizeof(dst
));
4732 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4733 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "Should be WSAEAFNOSUPPORT\n");
4735 /* Test Null destination */
4737 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, NULL
, sizeof(dst
));
4738 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4739 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4740 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4742 /* Test zero length passed */
4745 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 0);
4746 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4747 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4748 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4750 /* Test length one shorter than the address length */
4753 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 6);
4754 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4755 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4756 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4758 /* Test longer length is ok */
4761 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, sizeof(dst
)+1);
4762 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
4763 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
4765 /* Test the IPv6 addresses */
4767 /* Test an zero prefixed IPV6 address */
4768 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
4769 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
4770 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
4771 ok(!strcmp(pdst
, addr2_Str
),"Address %s != %s\n", pdst
, addr2_Str
);
4773 /* Test an zero suffixed IPV6 address */
4774 memcpy(in6
.s6_addr
, addr3_Num
, sizeof(addr3_Num
));
4775 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
4776 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
4777 ok(!strcmp(pdst
, addr3_Str
),"Address %s != %s\n", pdst
, addr3_Str
);
4779 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
4780 memcpy(in6
.s6_addr
, addr4_Num
, sizeof(addr4_Num
));
4781 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
4782 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
4783 ok(!strcmp(pdst
, addr4_Str
),"Address %s != %s\n", pdst
, addr4_Str
);
4785 /* Test invalid parm conditions */
4786 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
4788 /* Test Null destination */
4790 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, NULL
, sizeof(dst6
));
4791 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4792 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4793 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4795 /* Test zero length passed */
4798 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 0);
4799 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4800 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4801 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4803 /* Test length one shorter than the address length */
4806 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 16);
4807 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
4808 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
4809 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
4811 /* Test longer length is ok */
4814 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 18);
4815 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
4817 static void test_inet_pton(void)
4823 const char *printable
, *collapsed
, *raw_data
;
4825 {AF_UNSPEC
, -1, WSAEFAULT
, /* Test 0 */
4827 {AF_INET
, -1, WSAEFAULT
,
4829 {AF_INET6
, -1, WSAEFAULT
,
4831 {AF_UNSPEC
, -1, WSAEAFNOSUPPORT
,
4832 "127.0.0.1", NULL
, NULL
},
4834 "127.0.0.1", "127.0.0.1",
4835 "\x7f\x00\x00\x01"},
4837 "127.0.0.1", "127.0.0.1", NULL
},
4839 "::1/128", NULL
, NULL
},
4841 "::1/128", NULL
, NULL
},
4842 {AF_UNSPEC
, -1, WSAEAFNOSUPPORT
,
4843 "broken", NULL
, NULL
},
4845 "broken", NULL
, NULL
},
4846 {AF_INET6
, 0, 0, /* Test 10 */
4847 "broken", NULL
, NULL
},
4848 {AF_UNSPEC
, -1, WSAEAFNOSUPPORT
,
4849 "177.32.45.20", NULL
, NULL
},
4851 "177.32.45.20", "177.32.45.20",
4852 "\xb1\x20\x2d\x14"},
4854 "177.32.45.20", NULL
, NULL
},
4856 "2607:f0d0:1002:51::4", NULL
, NULL
},
4858 "2607:f0d0:1002:51::4", "2607:f0d0:1002:51::4",
4859 "\x26\x07\xf0\xd0\x10\x02\x00\x51\x00\x00\x00\x00\x00\x00\x00\x04"},
4861 "::177.32.45.20", NULL
, NULL
},
4863 "::177.32.45.20", "::177.32.45.20",
4864 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x20\x2d\x14"},
4866 "fe80::0202:b3ff:fe1e:8329", NULL
, NULL
},
4868 "fe80::0202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
4869 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
4870 {AF_INET6
, 1, 0, /* Test 20 */
4871 "fe80::202:b3ff:fe1e:8329", "fe80::202:b3ff:fe1e:8329",
4872 "\xfe\x80\x00\x00\x00\x00\x00\x00\x02\x02\xb3\xff\xfe\x1e\x83\x29"},
4878 "a.b.c", NULL
, NULL
},
4880 "a.b.c.d", NULL
, NULL
},
4882 "2001:cdba:0000:0000:0000:0000:3257:9652", "2001:cdba::3257:9652",
4883 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
4885 "2001:cdba::3257:9652", "2001:cdba::3257:9652",
4886 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"},
4888 "2001:cdba:0:0:0:0:3257:9652", "2001:cdba::3257:9652",
4889 "\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52"}
4893 char buffer
[64],str
[64];
4894 WCHAR printableW
[64], collapsedW
[64];
4898 /* InetNtop and InetPton became available in Vista and Win2008 */
4899 if (!pInetNtop
|| !pInetNtopW
|| !pInetPtonA
|| !pInetPtonW
)
4901 win_skip("InetNtop and/or InetPton not present, not executing tests\n");
4905 for (i
= 0; i
< sizeof(tests
) / sizeof(tests
[0]); i
++)
4907 WSASetLastError(0xdeadbeef);
4908 ret
= pInetPtonA(tests
[i
].family
, tests
[i
].printable
, buffer
);
4909 ok (ret
== tests
[i
].ret
, "Test [%d]: Expected %d, got %d\n", i
, tests
[i
].ret
, ret
);
4910 if (tests
[i
].ret
== -1)
4912 err
= WSAGetLastError();
4913 ok (tests
[i
].err
== err
, "Test [%d]: Expected 0x%x, got 0x%x\n", i
, tests
[i
].err
, err
);
4915 if (tests
[i
].ret
!= 1) continue;
4916 ok (memcmp(buffer
, tests
[i
].raw_data
,
4917 tests
[i
].family
== AF_INET
? sizeof(struct in_addr
) : sizeof(struct in6_addr
)) == 0,
4918 "Test [%d]: Expected binary data differs\n", i
);
4920 /* Test the result from Pton with Ntop */
4921 strcpy (str
, "deadbeef");
4922 ptr
= pInetNtop(tests
[i
].family
, buffer
, str
, sizeof(str
));
4923 ok (ptr
!= NULL
, "Test [%d]: Failed with NULL\n", i
);
4924 ok (ptr
== str
, "Test [%d]: Pointers differ (%p != %p)\n", i
, ptr
, str
);
4926 ok (strcmp(ptr
, tests
[i
].collapsed
) == 0, "Test [%d]: Expected '%s', got '%s'\n",
4927 i
, tests
[i
].collapsed
, ptr
);
4930 for (i
= 0; i
< sizeof(tests
) / sizeof(tests
[0]); i
++)
4932 if (tests
[i
].printable
)
4933 MultiByteToWideChar(CP_ACP
, 0, tests
[i
].printable
, -1, printableW
,
4934 sizeof(printableW
) / sizeof(printableW
[0]));
4935 WSASetLastError(0xdeadbeef);
4936 ret
= pInetPtonW(tests
[i
].family
, tests
[i
].printable
? printableW
: NULL
, buffer
);
4937 ok(ret
== tests
[i
].ret
, "Test [%d]: Expected %d, got %d\n", i
, tests
[i
].ret
, ret
);
4938 if (tests
[i
].ret
== -1)
4940 err
= WSAGetLastError();
4941 ok(tests
[i
].err
== err
, "Test [%d]: Expected 0x%x, got 0x%x\n", i
, tests
[i
].err
, err
);
4943 if (tests
[i
].ret
!= 1) continue;
4944 ok(memcmp(buffer
, tests
[i
].raw_data
,
4945 tests
[i
].family
== AF_INET
? sizeof(struct in_addr
) : sizeof(struct in6_addr
)) == 0,
4946 "Test [%d]: Expected binary data differs\n", i
);
4948 /* Test the result from Pton with Ntop */
4949 printableW
[0] = 0xdead;
4950 ptrW
= pInetNtopW(tests
[i
].family
, buffer
, printableW
, sizeof(printableW
) / sizeof(printableW
[0]));
4951 ok (ptrW
!= NULL
, "Test [%d]: Failed with NULL\n", i
);
4952 ok (ptrW
== printableW
, "Test [%d]: Pointers differ (%p != %p)\n", i
, ptrW
, printableW
);
4953 if (!ptrW
) continue;
4955 MultiByteToWideChar(CP_ACP
, 0, tests
[i
].collapsed
, -1, collapsedW
,
4956 sizeof(collapsedW
) / sizeof(collapsedW
[0]));
4957 ok (lstrcmpW(ptrW
, collapsedW
) == 0, "Test [%d]: Expected '%s', got '%s'\n",
4958 i
, tests
[i
].collapsed
, wine_dbgstr_w(ptrW
));
4962 static void test_ioctlsocket(void)
4964 SOCKET sock
, src
, dst
;
4965 struct tcp_keepalive kalive
;
4967 static const LONG cmds
[] = {FIONBIO
, FIONREAD
, SIOCATMARK
};
4973 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
4974 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
4975 if(sock
== INVALID_SOCKET
)
4977 skip("Can't continue without a socket.\n");
4981 for(i
= 0; i
< sizeof(cmds
)/sizeof(cmds
[0]); i
++)
4983 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
4984 ret
= ioctlsocket(sock
, cmds
[i
], (u_long
*)1);
4985 ok(ret
== SOCKET_ERROR
, "ioctlsocket succeeded unexpectedly\n");
4986 ret
= WSAGetLastError();
4987 ok(ret
== WSAEFAULT
, "expected WSAEFAULT, got %d instead\n", ret
);
4990 /* A fresh and not connected socket has no urgent data, this test shows
4991 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
4993 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
4994 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
4995 ok(arg
, "SIOCATMARK expected a non-zero value\n");
4997 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
4999 ret
= setsockopt(sock
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
5000 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
5002 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
5003 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
5004 ok(arg
, "SIOCATMARK expected a non-zero value\n");
5006 /* disable SO_OOBINLINE and get the same old behavior */
5008 ret
= setsockopt(sock
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
5009 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
5011 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
5012 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
5013 ok(arg
, "SIOCATMARK expected a non-zero value\n");
5015 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &arg
, 0, NULL
, 0, &arg
, NULL
, NULL
);
5016 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5017 ret
= WSAGetLastError();
5018 ok(ret
== WSAEFAULT
|| broken(ret
== WSAEINVAL
), "expected WSAEFAULT, got %d instead\n", ret
);
5020 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, NULL
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5021 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5022 ret
= WSAGetLastError();
5023 ok(ret
== WSAEFAULT
|| broken(ret
== WSAEINVAL
), "expected WSAEFAULT, got %d instead\n", ret
);
5025 /* broken used to catch W95, W98, NT4 */
5026 make_keepalive(kalive
, 0, 0, 0);
5027 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5028 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
5030 make_keepalive(kalive
, 1, 0, 0);
5031 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5032 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
5034 make_keepalive(kalive
, 1, 1000, 1000);
5035 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5036 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
5038 make_keepalive(kalive
, 1, 10000, 10000);
5039 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5040 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
5042 make_keepalive(kalive
, 1, 100, 100);
5043 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5044 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
5046 make_keepalive(kalive
, 0, 100, 100);
5047 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
5048 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
5052 if (tcp_socketpair(&src
, &dst
) != 0)
5054 ok(0, "creating socket pair failed, skipping test\n");
5058 /* test FIONREAD on TCP sockets */
5059 optval
= 0xdeadbeef;
5060 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
5061 ok(ret
== 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5062 ok(optval
== 0, "FIONREAD should have returned 0 bytes, got %d instead\n", optval
);
5064 optval
= 0xdeadbeef;
5065 ok(send(src
, "TEST", 4, 0) == 4, "failed to send test data\n");
5067 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
5068 ok(ret
== 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
5069 ok(optval
== 4, "FIONREAD should have returned 4 bytes, got %d instead\n", optval
);
5071 /* trying to read from an OOB inlined socket with MSG_OOB results in WSAEINVAL */
5072 set_blocking(dst
, FALSE
);
5074 SetLastError(0xdeadbeef);
5075 ret
= recv(dst
, &data
, 1, i
);
5076 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5077 ret
= GetLastError();
5078 ok(ret
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", ret
);
5079 bufs
.len
= sizeof(char);
5081 ret
= WSARecv(dst
, &bufs
, 1, &bytes_rec
, &i
, NULL
, NULL
);
5082 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5083 ret
= GetLastError();
5084 ok(ret
== WSAEWOULDBLOCK
, "expected 10035, got %d\n", ret
);
5086 ret
= setsockopt(dst
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
5087 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
5089 SetLastError(0xdeadbeef);
5090 ret
= recv(dst
, &data
, 1, i
);
5091 if (ret
== SOCKET_ERROR
)
5093 ret
= GetLastError();
5094 ok(ret
== WSAEINVAL
, "expected 10022, got %d\n", ret
);
5095 bufs
.len
= sizeof(char);
5097 ret
= WSARecv(dst
, &bufs
, 1, &bytes_rec
, &i
, NULL
, NULL
);
5098 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
5099 ret
= GetLastError();
5100 ok(ret
== WSAEINVAL
, "expected 10022, got %d\n", ret
);
5102 else ok(broken(ret
== 1) /* <= NT4 */, "expected error, got 1\n");
5105 optval
= 0xdeadbeef;
5106 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
5107 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
5108 ok(optval
== 0xdeadbeef, "FIONREAD should not have changed last error, got %d instead\n", optval
);
5112 static BOOL drain_pause
= FALSE
;
5113 static DWORD WINAPI
drain_socket_thread(LPVOID arg
)
5116 SOCKET sock
= *(SOCKET
*)arg
;
5119 while ((ret
= recv(sock
, buffer
, sizeof(buffer
), 0)) != 0)
5123 if (WSAGetLastError() == WSAEWOULDBLOCK
)
5127 FD_SET(sock
, &readset
);
5128 select(sock
+1, &readset
, NULL
, NULL
, NULL
);
5139 static void test_send(void)
5141 SOCKET src
= INVALID_SOCKET
;
5142 SOCKET dst
= INVALID_SOCKET
;
5143 HANDLE hThread
= NULL
;
5144 const int buflen
= 1024*1024;
5145 char *buffer
= NULL
;
5146 int ret
, i
, zero
= 0;
5150 DWORD id
, bytes_sent
, dwRet
;
5151 DWORD expected_time
, connect_time
;
5154 memset(&ov
, 0, sizeof(ov
));
5156 if (tcp_socketpair(&src
, &dst
) != 0)
5158 ok(0, "creating socket pair failed, skipping test\n");
5161 expected_time
= GetTickCount();
5163 set_blocking(dst
, FALSE
);
5164 /* force disable buffering so we can get a pending overlapped request */
5165 ret
= setsockopt(dst
, SOL_SOCKET
, SO_SNDBUF
, (char *) &zero
, sizeof(zero
));
5166 ok(!ret
, "setsockopt SO_SNDBUF failed: %d - %d\n", ret
, GetLastError());
5168 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
5169 if (hThread
== NULL
)
5171 ok(0, "CreateThread failed, error %d\n", GetLastError());
5175 buffer
= HeapAlloc(GetProcessHeap(), 0, buflen
);
5178 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
5182 /* fill the buffer with some nonsense */
5183 for (i
= 0; i
< buflen
; ++i
)
5185 buffer
[i
] = (char) i
;
5188 ret
= send(src
, buffer
, buflen
, 0);
5190 ok(ret
== buflen
, "send should have sent %d bytes, but it only sent %d\n", buflen
, ret
);
5192 ok(0, "send failed, error %d\n", WSAGetLastError());
5197 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5198 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
5203 WSASetLastError(12345);
5204 ret
= WSASend(dst
, &buf
, 1, &bytes_sent
, 0, &ov
, NULL
);
5205 ok((ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
) || broken(bytes_sent
== buflen
),
5206 "Failed to start overlapped send %d - %d - %d/%d\n", ret
, WSAGetLastError(), bytes_sent
, buflen
);
5208 /* don't check for completion yet, we may need to drain the buffer while still sending */
5209 set_blocking(src
, FALSE
);
5210 for (i
= 0; i
< buflen
; ++i
)
5214 ret
= recv(src
, buffer
, 1, 0);
5215 while (ret
== SOCKET_ERROR
&& GetLastError() == WSAEWOULDBLOCK
&& j
< 100)
5219 ret
= recv(src
, buffer
, 1, 0);
5222 ok(ret
== 1, "Failed to receive data %d - %d (got %d/%d)\n", ret
, GetLastError(), i
, buflen
);
5226 ok(buffer
[0] == (char) i
, "Received bad data at position %d\n", i
);
5229 dwRet
= WaitForSingleObject(ov
.hEvent
, 1000);
5230 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
5231 if (dwRet
== WAIT_OBJECT_0
)
5233 bret
= GetOverlappedResult((HANDLE
)dst
, &ov
, &bytes_sent
, FALSE
);
5234 ok((bret
&& bytes_sent
== buflen
) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
5235 "Got %d instead of %d (%d - %d)\n", bytes_sent
, buflen
, bret
, GetLastError());
5238 WSASetLastError(12345);
5239 ret
= WSASend(INVALID_SOCKET
, &buf
, 1, NULL
, 0, &ov
, NULL
);
5240 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
5241 "WSASend failed %d - %d\n", ret
, WSAGetLastError());
5243 WSASetLastError(12345);
5244 ret
= WSASend(dst
, &buf
, 1, NULL
, 0, &ov
, NULL
);
5245 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
,
5246 "Failed to start overlapped send %d - %d\n", ret
, WSAGetLastError());
5248 expected_time
= (GetTickCount() - expected_time
) / 1000;
5250 connect_time
= 0xdeadbeef;
5251 optlen
= sizeof(connect_time
);
5252 ret
= getsockopt(dst
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
5253 ok(!ret
, "getsockopt failed %d\n", WSAGetLastError());
5254 ok(connect_time
>= expected_time
&& connect_time
<= expected_time
+ 1,
5255 "unexpected connect time %u, expected %u\n", connect_time
, expected_time
);
5257 connect_time
= 0xdeadbeef;
5258 optlen
= sizeof(connect_time
);
5259 ret
= getsockopt(src
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
5260 ok(!ret
, "getsockopt failed %d\n", WSAGetLastError());
5261 ok(connect_time
>= expected_time
&& connect_time
<= expected_time
+ 1,
5262 "unexpected connect time %u, expected %u\n", connect_time
, expected_time
);
5265 if (src
!= INVALID_SOCKET
)
5267 if (dst
!= INVALID_SOCKET
)
5269 if (hThread
!= NULL
)
5271 dwRet
= WaitForSingleObject(hThread
, 500);
5272 ok(dwRet
== WAIT_OBJECT_0
, "failed to wait for thread termination: %d\n", GetLastError());
5273 CloseHandle(hThread
);
5276 CloseHandle(ov
.hEvent
);
5277 HeapFree(GetProcessHeap(), 0, buffer
);
5280 typedef struct async_message
5284 struct async_message
*next
;
5287 static struct async_message
*messages_received
;
5289 #define WM_SOCKET (WM_USER+100)
5290 static LRESULT CALLBACK
ws2_test_WndProc(HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
5292 struct async_message
*message
;
5297 message
= HeapAlloc(GetProcessHeap(), 0, sizeof(*message
));
5298 message
->socket
= (SOCKET
) wparam
;
5299 message
->lparam
= lparam
;
5300 message
->next
= NULL
;
5302 if (messages_received
)
5304 struct async_message
*last
= messages_received
;
5305 while (last
->next
) last
= last
->next
;
5306 last
->next
= message
;
5309 messages_received
= message
;
5313 return DefWindowProcA(hwnd
, msg
, wparam
, lparam
);
5316 static void get_event_details(int event
, int *bit
, char *name
)
5321 if (bit
) *bit
= FD_ACCEPT_BIT
;
5322 if (name
) strcpy(name
, "FD_ACCEPT");
5325 if (bit
) *bit
= FD_CONNECT_BIT
;
5326 if (name
) strcpy(name
, "FD_CONNECT");
5329 if (bit
) *bit
= FD_READ_BIT
;
5330 if (name
) strcpy(name
, "FD_READ");
5333 if (bit
) *bit
= FD_OOB_BIT
;
5334 if (name
) strcpy(name
, "FD_OOB");
5337 if (bit
) *bit
= FD_WRITE_BIT
;
5338 if (name
) strcpy(name
, "FD_WRITE");
5341 if (bit
) *bit
= FD_CLOSE_BIT
;
5342 if (name
) strcpy(name
, "FD_CLOSE");
5346 if (name
) sprintf(name
, "bad%x", event
);
5350 static const char *dbgstr_event_seq(const LPARAM
*seq
)
5352 static char message
[1024];
5360 get_event_details(WSAGETSELECTEVENT(*seq
), NULL
, name
);
5361 len
+= sprintf(message
+ len
, "%s(%d) ", name
, WSAGETSELECTERROR(*seq
));
5365 strcpy( message
+ len
, "]" );
5369 static char *dbgstr_event_seq_result(SOCKET s
, WSANETWORKEVENTS
*netEvents
)
5371 static char message
[1024];
5372 struct async_message
*curr
= messages_received
;
5373 int index
, error
, bit
= 0;
5383 if (bit
>= FD_MAX_EVENTS
) break;
5384 if ( !(netEvents
->lNetworkEvents
& (1 << bit
)) )
5389 get_event_details(1 << bit
, &index
, name
);
5390 error
= netEvents
->iErrorCode
[index
];
5396 if (curr
->socket
!= s
)
5401 get_event_details(WSAGETSELECTEVENT(curr
->lparam
), NULL
, name
);
5402 error
= WSAGETSELECTERROR(curr
->lparam
);
5406 len
+= sprintf(message
+ len
, "%s(%d) ", name
, error
);
5409 strcpy( message
+ len
, "]" );
5413 static void flush_events(SOCKET s
, HANDLE hEvent
)
5415 WSANETWORKEVENTS netEvents
;
5416 struct async_message
*prev
= NULL
, *curr
= messages_received
;
5420 if (hEvent
!= INVALID_HANDLE_VALUE
)
5422 dwRet
= WaitForSingleObject(hEvent
, 100);
5423 if (dwRet
== WAIT_OBJECT_0
)
5425 ret
= WSAEnumNetworkEvents(s
, hEvent
, &netEvents
);
5427 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
5434 if (curr
->socket
== s
)
5436 if (prev
) prev
->next
= curr
->next
;
5437 else messages_received
= curr
->next
;
5439 HeapFree(GetProcessHeap(), 0, curr
);
5441 if (prev
) curr
= prev
->next
;
5442 else curr
= messages_received
;
5453 static int match_event_sequence(SOCKET s
, WSANETWORKEVENTS
*netEvents
, const LPARAM
*seq
)
5455 int event
, index
, error
, events
;
5456 struct async_message
*curr
;
5460 events
= netEvents
->lNetworkEvents
;
5463 event
= WSAGETSELECTEVENT(*seq
);
5464 error
= WSAGETSELECTERROR(*seq
);
5465 get_event_details(event
, &index
, NULL
);
5467 if (!(events
& event
) && index
!= -1)
5469 if (events
& event
&& index
!= -1)
5471 if (netEvents
->iErrorCode
[index
] != error
)
5482 curr
= messages_received
;
5485 if (curr
->socket
== s
)
5487 if (!*seq
) return 0;
5488 if (*seq
!= curr
->lparam
) return 0;
5499 /* checks for a sequence of events, (order only checked if window is used) */
5500 static void ok_event_sequence(SOCKET s
, HANDLE hEvent
, const LPARAM
*seq
, const LPARAM
**broken_seqs
, int completelyBroken
)
5503 WSANETWORKEVENTS events
, *netEvents
= NULL
;
5507 if (hEvent
!= INVALID_HANDLE_VALUE
)
5509 netEvents
= &events
;
5511 dwRet
= WaitForSingleObject(hEvent
, 200);
5512 if (dwRet
== WAIT_OBJECT_0
)
5514 ret
= WSAEnumNetworkEvents(s
, hEvent
, netEvents
);
5517 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
5522 memset(netEvents
, 0, sizeof(*netEvents
));
5527 /* Run the message loop a little */
5528 while (PeekMessageA( &msg
, 0, 0, 0, PM_REMOVE
))
5530 DispatchMessageA(&msg
);
5534 if (match_event_sequence(s
, netEvents
, seq
))
5536 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq
));
5537 flush_events(s
, hEvent
);
5543 for (; *broken_seqs
; broken_seqs
++)
5545 if (match_event_sequence(s
, netEvents
, *broken_seqs
))
5547 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s
, netEvents
), dbgstr_event_seq(seq
));
5548 flush_events(s
, hEvent
);
5554 winetest_ok(broken(completelyBroken
), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq
),
5555 dbgstr_event_seq_result(s
, netEvents
));
5556 flush_events(s
, hEvent
);
5559 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
5561 static void test_events(int useMessages
)
5563 SOCKET server
= INVALID_SOCKET
;
5564 SOCKET src
= INVALID_SOCKET
, src2
= INVALID_SOCKET
;
5565 SOCKET dst
= INVALID_SOCKET
, dst2
= INVALID_SOCKET
;
5566 struct sockaddr_in addr
;
5567 HANDLE hThread
= NULL
;
5568 HANDLE hEvent
= INVALID_HANDLE_VALUE
, hEvent2
= INVALID_HANDLE_VALUE
;
5569 WNDCLASSEXA wndclass
;
5571 char *buffer
= NULL
;
5572 int bufferSize
= 1024*1024;
5576 DWORD bytesReturned
;
5582 static char szClassName
[] = "wstestclass";
5583 const LPARAM
*broken_seq
[3];
5584 static const LPARAM empty_seq
[] = { 0 };
5585 static const LPARAM close_seq
[] = { WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
5586 static const LPARAM write_seq
[] = { WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
5587 static const LPARAM read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
5588 static const LPARAM oob_seq
[] = { WSAMAKESELECTREPLY(FD_OOB
, 0), 0 };
5589 static const LPARAM connect_seq
[] = { WSAMAKESELECTREPLY(FD_CONNECT
, 0),
5590 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
5591 static const LPARAM read_read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
5592 WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
5593 static const LPARAM read_write_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
5594 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
5595 static const LPARAM read_close_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
5596 WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
5598 memset(&ov
, 0, sizeof(ov
));
5599 memset(&ov2
, 0, sizeof(ov2
));
5601 /* don't use socketpair, we want connection event */
5602 src
= socket(AF_INET
, SOCK_STREAM
, 0);
5603 if (src
== INVALID_SOCKET
)
5605 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5609 ret
= set_blocking(src
, TRUE
);
5610 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
5612 src2
= socket(AF_INET
, SOCK_STREAM
, 0);
5613 if (src2
== INVALID_SOCKET
)
5615 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5619 ret
= set_blocking(src2
, TRUE
);
5620 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
5623 if (getsockopt(src
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&bret
, &len
) == SOCKET_ERROR
)
5625 ok(0, "failed to get oobinline status, %d\n", GetLastError());
5628 ok(bret
== FALSE
, "OOB not inline\n");
5632 trace("Event test using messages\n");
5634 wndclass
.cbSize
= sizeof(wndclass
);
5635 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
5636 wndclass
.lpfnWndProc
= ws2_test_WndProc
;
5637 wndclass
.cbClsExtra
= 0;
5638 wndclass
.cbWndExtra
= 0;
5639 wndclass
.hInstance
= GetModuleHandleA(NULL
);
5640 wndclass
.hIcon
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
5641 wndclass
.hIconSm
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
5642 wndclass
.hCursor
= LoadCursorA(NULL
, (LPCSTR
)IDC_ARROW
);
5643 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
5644 wndclass
.lpszClassName
= szClassName
;
5645 wndclass
.lpszMenuName
= NULL
;
5646 RegisterClassExA(&wndclass
);
5648 hWnd
= CreateWindowA(szClassName
, "WS2Test", WS_OVERLAPPEDWINDOW
,
5649 0, 0, 500, 500, NULL
, NULL
, GetModuleHandleA(NULL
), NULL
);
5652 ok(0, "failed to create window: %d\n", GetLastError());
5656 ret
= WSAAsyncSelect(src
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
5659 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
5663 ok(set_blocking(src
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
5664 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5666 ret
= WSAAsyncSelect(src2
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
5669 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
5673 ok(set_blocking(src2
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
5674 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5678 trace("Event test using events\n");
5680 hEvent
= WSACreateEvent();
5681 if (hEvent
== INVALID_HANDLE_VALUE
)
5683 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5687 hEvent2
= WSACreateEvent();
5688 if (hEvent2
== INVALID_HANDLE_VALUE
)
5690 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
5694 ret
= WSAEventSelect(src
, hEvent
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
5697 ok(0, "WSAEventSelect failed, error %d\n", ret
);
5701 ok(set_blocking(src
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
5702 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5704 ret
= WSAEventSelect(src2
, hEvent2
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
5707 ok(0, "WSAEventSelect failed, error %d\n", ret
);
5711 ok(set_blocking(src2
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
5712 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
5715 server
= socket(AF_INET
, SOCK_STREAM
, 0);
5716 if (server
== INVALID_SOCKET
)
5718 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5722 memset(&addr
, 0, sizeof(addr
));
5723 addr
.sin_family
= AF_INET
;
5724 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5725 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
5728 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5733 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
5736 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5740 ret
= listen(server
, 2);
5743 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5747 ret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
5748 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
5750 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5754 ret
= connect(src2
, (struct sockaddr
*)&addr
, sizeof(addr
));
5755 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
5757 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5762 dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
5763 if (dst
== INVALID_SOCKET
)
5765 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5770 dst2
= accept(server
, (struct sockaddr
*)&addr
, &len
);
5771 if (dst2
== INVALID_SOCKET
)
5773 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
5777 closesocket(server
);
5778 server
= INVALID_SOCKET
;
5780 /* On Windows it seems when a non-blocking socket sends to a
5781 blocking socket on the same host, the send() is BLOCKING,
5782 so make both sockets non-blocking. src is already non-blocking
5783 from the async select */
5785 if (set_blocking(dst
, FALSE
))
5787 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
5791 buffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, bufferSize
);
5794 ok(0, "could not allocate memory for test\n");
5798 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5799 if (ov
.hEvent
== NULL
)
5801 ok(0, "could not create event object, errno = %d\n", GetLastError());
5805 ov2
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5806 if (ov2
.hEvent
== NULL
)
5808 ok(0, "could not create event object, errno = %d\n", GetLastError());
5812 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
5813 ok_event_seq(src
, hEvent
, connect_seq
, NULL
, 1);
5814 ok_event_seq(src2
, hEvent2
, connect_seq
, NULL
, 1);
5815 /* broken on all windows - FD_CONNECT error is garbage */
5817 /* Test simple send/recv */
5818 SetLastError(0xdeadbeef);
5819 ret
= send(dst
, buffer
, 100, 0);
5820 ok(ret
== 100, "Failed to send buffer %d err %d\n", ret
, GetLastError());
5821 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5822 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5824 SetLastError(0xdeadbeef);
5825 ret
= recv(src
, buffer
, 1, MSG_PEEK
);
5826 ok(ret
== 1, "Failed to peek at recv buffer %d err %d\n", ret
, GetLastError());
5827 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5828 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5830 SetLastError(0xdeadbeef);
5831 ret
= recv(src
, buffer
, 50, 0);
5832 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
5833 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5834 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5836 ret
= recv(src
, buffer
, 50, 0);
5837 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
5838 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
5840 /* fun fact - events are re-enabled even on failure, but only for messages */
5841 ret
= send(dst
, "1", 1, 0);
5842 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
5843 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5845 ret
= recv(src
, buffer
, -1, 0);
5846 ok(ret
== SOCKET_ERROR
&& (GetLastError() == WSAEFAULT
|| GetLastError() == WSAENOBUFS
),
5847 "Failed to recv buffer %d err %d\n", ret
, GetLastError());
5850 broken_seq
[0] = empty_seq
; /* win9x */
5851 broken_seq
[1] = NULL
;
5852 todo_wine
ok_event_seq(src
, hEvent
, read_seq
, broken_seq
, 0);
5855 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
5857 SetLastError(0xdeadbeef);
5858 ret
= recv(src
, buffer
, 1, 0);
5859 ok(ret
== 1, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
5860 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5861 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
5863 /* Interaction with overlapped */
5864 bufs
.len
= sizeof(char);
5866 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
5867 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
5868 "WSARecv failed - %d error %d\n", ret
, GetLastError());
5870 bufs
.len
= sizeof(char);
5871 bufs
.buf
= buffer
+1;
5872 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov2
, NULL
);
5873 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
5874 "WSARecv failed - %d error %d\n", ret
, GetLastError());
5876 ret
= send(dst
, "12", 2, 0);
5877 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
5878 broken_seq
[0] = read_read_seq
; /* win9x */
5879 broken_seq
[1] = NULL
;
5880 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
5882 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
5883 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
5884 if (dwRet
== WAIT_OBJECT_0
)
5886 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
5887 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
5888 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
5889 ok(buffer
[0] == '1', "Got %c instead of 1\n", buffer
[0]);
5892 dwRet
= WaitForSingleObject(ov2
.hEvent
, 100);
5893 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
5894 if (dwRet
== WAIT_OBJECT_0
)
5896 bret
= GetOverlappedResult((HANDLE
)src
, &ov2
, &bytesReturned
, FALSE
);
5897 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
5898 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
5899 ok(buffer
[1] == '2', "Got %c instead of 2\n", buffer
[1]);
5902 SetLastError(0xdeadbeef);
5903 ret
= send(dst
, "1", 1, 0);
5904 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
5905 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
5906 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
5908 ret
= recv(src
, buffer
, 1, 0);
5909 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
5910 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
5912 /* Notifications are delivered as soon as possible, blocked only on
5913 * async requests on the same type */
5914 bufs
.len
= sizeof(char);
5916 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
5917 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
5918 "WSARecv failed - %d error %d\n", ret
, GetLastError());
5921 ret
= send(dst
, "1", 1, MSG_OOB
);
5922 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
5923 ok_event_seq(src
, hEvent
, oob_seq
, NULL
, 0);
5926 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
5927 ok(dwRet
== WAIT_TIMEOUT
, "OOB message activated read?: %d - %d\n", dwRet
, GetLastError());
5929 ret
= send(dst
, "2", 1, 0);
5930 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
5931 broken_seq
[0] = read_seq
; /* win98 */
5932 broken_seq
[1] = NULL
;
5933 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
5935 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
5936 ok(dwRet
== WAIT_OBJECT_0
|| broken(dwRet
== WAIT_TIMEOUT
),
5937 "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
5938 if (dwRet
== WAIT_OBJECT_0
)
5940 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
5941 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
5942 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
5943 ok(buffer
[0] == '2', "Got %c instead of 2\n", buffer
[0]);
5945 else if (dwRet
== WAIT_TIMEOUT
)
5947 /* this happens on win98. We get an FD_READ later on the next test */
5948 CancelIo((HANDLE
) src
);
5952 ret
= recv(src
, buffer
, 1, MSG_OOB
);
5953 todo_wine
ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
5954 /* We get OOB notification, but no data on wine */
5955 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
5958 /* Flood the send queue */
5959 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
5960 if (hThread
== NULL
)
5962 ok(0, "CreateThread failed, error %d\n", GetLastError());
5966 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
5967 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
5969 /* Now if we send a ton of data and the 'server' does not drain it fast
5970 * enough (set drain_pause to be sure), the socket send buffer will only
5971 * take some of it, and we will get a short write. This will trigger
5972 * another FD_WRITE event as soon as data is sent and more space becomes
5973 * available, but not any earlier. */
5977 ret
= send(src
, buffer
, bufferSize
, 0);
5978 } while (ret
== bufferSize
);
5979 drain_pause
= FALSE
;
5980 if (ret
>= 0 || WSAGetLastError() == WSAEWOULDBLOCK
)
5982 Sleep(400); /* win9x */
5983 broken_seq
[0] = read_write_seq
;
5984 broken_seq
[1] = NULL
;
5985 ok_event_seq(src
, hEvent
, write_seq
, broken_seq
, 0);
5989 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
5992 /* Test how FD_CLOSE is handled */
5993 ret
= send(dst
, "12", 2, 0);
5994 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
5996 /* Wait a little and let the send complete */
5999 dst
= INVALID_SOCKET
;
6002 /* We can never implement this in wine, best we can hope for is
6003 sending FD_CLOSE after the reads complete */
6004 broken_seq
[0] = read_seq
; /* win9x */
6005 broken_seq
[1] = NULL
;
6006 todo_wine
ok_event_seq(src
, hEvent
, read_close_seq
, broken_seq
, 0);
6008 ret
= recv(src
, buffer
, 1, 0);
6009 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6010 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
6012 ret
= recv(src
, buffer
, 1, 0);
6013 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6014 /* want it? it's here, but you can't have it */
6015 broken_seq
[0] = close_seq
; /* win9x */
6016 broken_seq
[1] = NULL
;
6017 todo_wine
ok_event_seq(src
, hEvent
, empty_seq
, /* wine sends FD_CLOSE here */
6020 /* Test how FD_CLOSE is handled */
6021 ret
= send(dst2
, "12", 2, 0);
6022 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
6025 shutdown(dst2
, SD_SEND
);
6028 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
6029 regressions, don't mark them as todo_wine, and mark windows as broken */
6030 broken_seq
[0] = read_close_seq
;
6031 broken_seq
[1] = close_seq
;
6032 broken_seq
[2] = NULL
;
6033 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
6035 ret
= recv(src2
, buffer
, 1, 0);
6036 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6037 broken_seq
[0] = close_seq
; /* win98 */
6038 broken_seq
[1] = NULL
;
6039 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
6041 ret
= recv(src2
, buffer
, 1, 0);
6042 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
6043 broken_seq
[0] = empty_seq
;
6044 broken_seq
[1] = NULL
;
6045 ok_event_seq(src2
, hEvent2
, close_seq
, broken_seq
, 0);
6047 ret
= send(src2
, "1", 1, 0);
6048 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
6049 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
6051 ret
= send(src2
, "1", 1, 0);
6052 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
6053 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
6057 ret
= WSAAsyncSelect(src
, hWnd
, WM_SOCKET
, 0);
6060 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
6064 ret
= set_blocking(src
, TRUE
);
6065 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
6067 ret
= WSAAsyncSelect(src2
, hWnd
, WM_SOCKET
, 0);
6070 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
6074 ret
= set_blocking(src2
, TRUE
);
6075 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
6079 ret
= WSAEventSelect(src
, hEvent2
, 0);
6082 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
6086 ret
= set_blocking(src
, TRUE
);
6087 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
6089 ret
= WSAEventSelect(src2
, hEvent2
, 0);
6092 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
6096 ret
= set_blocking(src2
, TRUE
);
6097 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
6101 if (src
!= INVALID_SOCKET
)
6103 flush_events(src
, hEvent
);
6106 if (src2
!= INVALID_SOCKET
)
6108 flush_events(src2
, hEvent2
);
6111 HeapFree(GetProcessHeap(), 0, buffer
);
6112 if (server
!= INVALID_SOCKET
)
6113 closesocket(server
);
6114 if (dst
!= INVALID_SOCKET
)
6116 if (dst2
!= INVALID_SOCKET
)
6118 if (hThread
!= NULL
)
6119 CloseHandle(hThread
);
6121 DestroyWindow(hWnd
);
6123 CloseHandle(hEvent
);
6124 if (hEvent2
!= NULL
)
6125 CloseHandle(hEvent2
);
6126 if (ov
.hEvent
!= NULL
)
6127 CloseHandle(ov
.hEvent
);
6128 if (ov2
.hEvent
!= NULL
)
6129 CloseHandle(ov2
.hEvent
);
6132 static void test_ipv6only(void)
6134 SOCKET v4
= INVALID_SOCKET
,
6135 v6
= INVALID_SOCKET
;
6136 struct sockaddr_in sin4
;
6137 struct sockaddr_in6 sin6
;
6140 memset(&sin4
, 0, sizeof(sin4
));
6141 sin4
.sin_family
= AF_INET
;
6142 sin4
.sin_port
= htons(SERVERPORT
);
6144 memset(&sin6
, 0, sizeof(sin6
));
6145 sin6
.sin6_family
= AF_INET6
;
6146 sin6
.sin6_port
= htons(SERVERPORT
);
6148 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
6149 if (v6
== INVALID_SOCKET
) {
6150 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
6151 WSAGetLastError(), WSAEAFNOSUPPORT
);
6154 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
6156 skip("Could not bind IPv6 address (LastError: %d).\n",
6161 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
6162 if (v4
== INVALID_SOCKET
) {
6163 skip("Could not create IPv4 socket (LastError: %d).\n",
6167 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
6168 ok(!ret
, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
6169 WSAGetLastError(), WSAEADDRINUSE
);
6172 if (v4
!= INVALID_SOCKET
)
6174 if (v6
!= INVALID_SOCKET
)
6178 static void test_WSASendMsg(void)
6181 struct sockaddr_in sendaddr
, sockaddr
;
6182 GUID WSASendMsg_GUID
= WSAID_WSASENDMSG
;
6183 LPFN_WSASENDMSG pWSASendMsg
= NULL
;
6184 char teststr
[12] = "hello world", buffer
[32];
6187 DWORD bytesSent
, err
;
6190 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
6192 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
6193 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6195 /* Obtain the WSASendMsg function */
6196 WSAIoctl(sock
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSASendMsg_GUID
, sizeof(WSASendMsg_GUID
),
6197 &pWSASendMsg
, sizeof(pWSASendMsg
), &err
, NULL
, NULL
);
6201 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
6205 /* fake address for now */
6206 sendaddr
.sin_family
= AF_INET
;
6207 sendaddr
.sin_port
= htons(139);
6208 sendaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6210 memset(&msg
, 0, sizeof(msg
));
6211 iovec
[0].buf
= teststr
;
6212 iovec
[0].len
= sizeof(teststr
);
6213 iovec
[1].buf
= teststr
;
6214 iovec
[1].len
= sizeof(teststr
) / 2;
6215 msg
.name
= (struct sockaddr
*) &sendaddr
;
6216 msg
.namelen
= sizeof(sendaddr
);
6217 msg
.lpBuffers
= iovec
;
6218 msg
.dwBufferCount
= 1; /* send only one buffer for now */
6220 WSASetLastError(0xdeadbeef);
6221 ret
= pWSASendMsg(INVALID_SOCKET
, &msg
, 0, NULL
, NULL
, NULL
);
6222 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6223 err
= WSAGetLastError();
6224 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
6226 WSASetLastError(0xdeadbeef);
6227 ret
= pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
);
6228 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6229 err
= WSAGetLastError();
6230 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
6232 WSASetLastError(0xdeadbeef);
6233 ret
= pWSASendMsg(sock
, NULL
, 0, &bytesSent
, NULL
, NULL
);
6234 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6235 err
= WSAGetLastError();
6236 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
6238 WSASetLastError(0xdeadbeef);
6239 ret
= pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
);
6240 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6241 err
= WSAGetLastError();
6242 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
6246 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
6247 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6249 dst
= socket(AF_INET
, SOCK_DGRAM
, 0);
6250 ok(dst
!= INVALID_SOCKET
, "socket() failed\n");
6252 memset(&sockaddr
, 0, sizeof(sockaddr
));
6253 sockaddr
.sin_family
= AF_INET
;
6254 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6255 ok(!bind(dst
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
)),
6256 "bind should have worked\n");
6258 /* read address to find out the port number to be used in send */
6259 memset(&sendaddr
, 0, sizeof(sendaddr
));
6260 addrlen
= sizeof(sendaddr
);
6261 ok(!getsockname(dst
, (struct sockaddr
*) &sendaddr
, &addrlen
),
6262 "getsockname should have worked\n");
6263 ok(sendaddr
.sin_port
, "socket port should be != 0\n");
6265 /* ensure the sending socket is not bound */
6266 WSASetLastError(0xdeadbeef);
6267 addrlen
= sizeof(sockaddr
);
6268 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
6269 ok(ret
== SOCKET_ERROR
, "getsockname should have failed\n");
6270 err
= WSAGetLastError();
6271 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
6273 set_blocking(sock
, TRUE
);
6276 SetLastError(0xdeadbeef);
6277 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
6278 ok(!ret
, "WSASendMsg should have worked\n");
6279 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6280 "Expected 0, got %d\n", GetLastError());
6281 ok(bytesSent
== iovec
[0].len
, "incorret bytes sent, expected %d, sent %d\n",
6282 iovec
[0].len
, bytesSent
);
6285 addrlen
= sizeof(sockaddr
);
6286 memset(buffer
, 0, sizeof(buffer
));
6287 SetLastError(0xdeadbeef);
6288 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
6289 ok(ret
== bytesSent
, "got %d, expected %d\n",
6291 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6293 /* A successful call to WSASendMsg must have bound the socket */
6294 addrlen
= sizeof(sockaddr
);
6295 sockaddr
.sin_port
= 0;
6296 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6297 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
6298 ok(!ret
, "getsockname should have worked\n");
6299 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
6300 inet_ntoa(sockaddr
.sin_addr
));
6301 ok(sockaddr
.sin_port
, "sin_port should be != 0\n");
6303 msg
.dwBufferCount
= 2; /* send both buffers */
6306 SetLastError(0xdeadbeef);
6307 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
6308 ok(!ret
, "WSASendMsg should have worked\n");
6309 ok(bytesSent
== iovec
[0].len
+ iovec
[1].len
, "incorret bytes sent, expected %d, sent %d\n",
6310 iovec
[0].len
+ iovec
[1].len
, bytesSent
);
6311 ok(GetLastError() == 0 || broken(GetLastError() == 0xdeadbeef) /* Win <= 2008 */,
6312 "Expected 0, got %d\n", GetLastError());
6315 addrlen
= sizeof(sockaddr
);
6316 memset(buffer
, 0, sizeof(buffer
));
6317 SetLastError(0xdeadbeef);
6318 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
6319 ok(ret
== bytesSent
, "got %d, expected %d\n",
6321 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6326 /* a bad call to WSASendMsg will also bind the socket */
6327 addrlen
= sizeof(sockaddr
);
6328 sockaddr
.sin_port
= 0;
6329 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6330 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
6331 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6332 ok(pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
6334 ok(!getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have worked\n");
6335 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
6336 inet_ntoa(sockaddr
.sin_addr
));
6337 ok(sockaddr
.sin_port
, "sin_port should be > 0\n");
6341 /* a bad call without msg parameter will not trigger the auto-bind */
6342 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
6343 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6344 ok(pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
6345 ok(getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have failed\n");
6346 err
= WSAGetLastError();
6347 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
6350 /* SOCK_STREAM sockets are not supported */
6352 sock
= socket(AF_INET
, SOCK_STREAM
, 0);
6353 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
6354 SetLastError(0xdeadbeef);
6355 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
6356 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
6357 err
= WSAGetLastError();
6359 ok(err
== WSAEINVAL
, "expected 10014, got %d instead\n", err
);
6363 static void test_WSASendTo(void)
6366 struct sockaddr_in addr
;
6367 char buf
[12] = "hello world";
6372 addr
.sin_family
= AF_INET
;
6373 addr
.sin_port
= htons(139);
6374 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6375 data_buf
.len
= sizeof(buf
);
6378 if( (s
= socket(AF_INET
, SOCK_DGRAM
, 0)) == INVALID_SOCKET
) {
6379 ok(0, "socket() failed error: %d\n", WSAGetLastError());
6383 WSASetLastError(12345);
6384 ret
= WSASendTo(INVALID_SOCKET
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
6385 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
6386 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
6388 WSASetLastError(12345);
6389 ret
= WSASendTo(s
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
6390 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
6391 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
6393 WSASetLastError(12345);
6394 if(WSASendTo(s
, &data_buf
, 1, &bytesSent
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
)) {
6395 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
6398 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
6399 "a successful call to WSASendTo()\n");
6402 static DWORD WINAPI
recv_thread(LPVOID arg
)
6404 SOCKET sock
= *(SOCKET
*)arg
;
6411 wsa
.len
= sizeof(buffer
);
6412 ov
.hEvent
= WSACreateEvent();
6413 WSARecv(sock
, &wsa
, 1, NULL
, &flags
, &ov
, NULL
);
6415 WaitForSingleObject(ov
.hEvent
, 1000);
6416 WSACloseEvent(ov
.hEvent
);
6420 static void test_WSARecv(void)
6422 SOCKET src
, dest
, server
= INVALID_SOCKET
;
6426 DWORD bytesReturned
, flags
, id
;
6428 struct sockaddr_in addr
;
6434 tcp_socketpair(&src
, &dest
);
6435 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
6437 skip("failed to create sockets\n");
6441 memset(&ov
, 0, sizeof(ov
));
6446 /* Send 4 bytes and receive in two calls of 2 */
6447 SetLastError(0xdeadbeef);
6448 iret
= send(src
, "test", 4, 0);
6449 ok(iret
== 4, "Expected 4, got %d\n", iret
);
6450 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6451 SetLastError(0xdeadbeef);
6452 bytesReturned
= 0xdeadbeef;
6453 iret
= WSARecv(dest
, &bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
6454 ok(!iret
, "Expected 0, got %d\n", iret
);
6455 ok(bytesReturned
, "Expected 2, got %d\n", bytesReturned
);
6456 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6457 SetLastError(0xdeadbeef);
6458 bytesReturned
= 0xdeadbeef;
6459 iret
= WSARecv(dest
, &bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
6460 ok(!iret
, "Expected 0, got %d\n", iret
);
6461 ok(bytesReturned
, "Expected 2, got %d\n", bytesReturned
);
6462 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6465 SetLastError(0xdeadbeef);
6466 iret
= send(src
, "test", 4, 0);
6467 ok(iret
== 4, "Expected 4, got %d\n", iret
);
6468 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6469 SetLastError(0xdeadbeef);
6470 bytesReturned
= 0xdeadbeef;
6471 iret
= WSARecv(dest
, &bufs
, 1, &bytesReturned
, &flags
, NULL
, NULL
);
6472 ok(!iret
, "Expected 0, got %d\n", iret
);
6473 ok(bytesReturned
, "Expected 4, got %d\n", bytesReturned
);
6474 ok(GetLastError() == ERROR_SUCCESS
, "Expected 0, got %d\n", GetLastError());
6476 bufs
.len
= sizeof(buf
);
6478 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6479 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
6485 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
6486 ok(!iret
, "Failed to set linger %d\n", GetLastError());
6488 iret
= WSARecv(dest
, &bufs
, 1, NULL
, &flags
, &ov
, NULL
);
6489 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
6491 iret
= WSARecv(dest
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
6492 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
6495 src
= INVALID_SOCKET
;
6497 dwret
= WaitForSingleObject(ov
.hEvent
, 1000);
6498 ok(dwret
== WAIT_OBJECT_0
, "Waiting for disconnect event failed with %d + errno %d\n", dwret
, GetLastError());
6500 bret
= GetOverlappedResult((HANDLE
)dest
, &ov
, &bytesReturned
, FALSE
);
6501 todo_wine
ok(!bret
&& (GetLastError() == ERROR_NETNAME_DELETED
|| broken(GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */),
6502 "Did not get disconnect event: %d, error %d\n", bret
, GetLastError());
6503 ok(bytesReturned
== 0, "Bytes received is %d\n", bytesReturned
);
6505 dest
= INVALID_SOCKET
;
6507 src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
6508 ok(src
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
6509 if (src
== INVALID_SOCKET
) goto end
;
6511 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
6512 ok(server
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
6513 if (server
== INVALID_SOCKET
) goto end
;
6515 memset(&addr
, 0, sizeof(addr
));
6516 addr
.sin_family
= AF_INET
;
6517 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6518 iret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
6522 iret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
6525 iret
= listen(server
, 1);
6528 iret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
6532 dest
= accept(server
, (struct sockaddr
*)&addr
, &len
);
6533 ok(dest
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
6534 if (dest
== INVALID_SOCKET
) goto end
;
6536 send(src
, "test message", sizeof("test message"), 0);
6537 thread
= CreateThread(NULL
, 0, recv_thread
, &dest
, 0, &id
);
6538 WaitForSingleObject(thread
, 3000);
6539 CloseHandle(thread
);
6542 if (server
!= INVALID_SOCKET
)
6543 closesocket(server
);
6544 if (dest
!= INVALID_SOCKET
)
6546 if (src
!= INVALID_SOCKET
)
6549 WSACloseEvent(ov
.hEvent
);
6552 #define POLL_CLEAR() ix = 0
6553 #define POLL_SET(s, ev) {fds[ix].fd = s; fds[ix++].events = ev;}
6554 #define POLL_ISSET(s, rev) poll_isset(fds, ix, s, rev)
6555 static BOOL
poll_isset(WSAPOLLFD
*fds
, int max
, SOCKET s
, int rev
)
6558 for (k
= 0; k
< max
; k
++)
6559 if (fds
[k
].fd
== s
&& (fds
[k
].revents
== rev
)) return TRUE
;
6563 static void test_WSAPoll(void)
6565 int ix
, ret
, err
, poll_timeout
;
6566 SOCKET fdListen
, fdRead
, fdWrite
;
6567 struct sockaddr_in address
;
6569 static char tmp_buf
[1024];
6571 HANDLE thread_handle
;
6574 if (!pWSAPoll
) /* >= Vista */
6576 skip("WSAPoll is unsupported, some tests will be skipped.\n");
6580 /* Invalid parameters test */
6581 SetLastError(0xdeadbeef);
6582 ret
= pWSAPoll(NULL
, 0, 0);
6583 err
= GetLastError();
6584 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6585 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
6586 SetLastError(0xdeadbeef);
6587 ret
= pWSAPoll(NULL
, 1, 0);
6588 err
= GetLastError();
6589 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6590 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
6591 SetLastError(0xdeadbeef);
6592 ret
= pWSAPoll(NULL
, 0, 1);
6593 err
= GetLastError();
6594 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6595 ok(err
== WSAEINVAL
, "expected 10022, got %d\n", err
);
6596 SetLastError(0xdeadbeef);
6597 ret
= pWSAPoll(NULL
, 1, 1);
6598 err
= GetLastError();
6599 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6600 ok(err
== WSAEFAULT
, "expected 10014, got %d\n", err
);
6602 /* WSAPoll() tries to mime the unix poll() call. The following tests do:
6603 * - check if a connection attempt ended with success or error;
6604 * - check if a pending connection is waiting for acceptance;
6605 * - check for data to read, availability for write and OOB data
6607 memset(&address
, 0, sizeof(address
));
6608 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6609 address
.sin_family
= AF_INET
;
6610 len
= sizeof(address
);
6611 fdListen
= setup_server_socket(&address
, &len
);
6614 /* When no events are pending poll returns 0 with no error */
6616 POLL_SET(fdListen
, POLLIN
);
6617 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6618 ok(ret
== 0, "expected 0, got %d\n", ret
);
6620 /* Test listening socket connection attempt notifications */
6621 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
6623 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
6624 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6625 ok(ret
== 1, "expected 1, got %d\n", ret
);
6626 ok(POLL_ISSET(fdListen
, POLLRDNORM
), "fdListen socket events incorrect\n");
6627 len
= sizeof(address
);
6628 fdRead
= accept(fdListen
, (struct sockaddr
*) &address
, &len
);
6629 ok(fdRead
!= INVALID_SOCKET
, "expected a valid socket\n");
6631 /* Test client side connection attempt notifications */
6633 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
6634 POLL_SET(fdRead
, POLLIN
| POLLOUT
);
6635 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
6636 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6637 ok(ret
== 2, "expected 2, got %d\n", ret
);
6638 ok(POLL_ISSET(fdWrite
, POLLWRNORM
), "fdWrite socket events incorrect\n");
6639 ok(POLL_ISSET(fdRead
, POLLWRNORM
), "fdRead socket events incorrect\n");
6642 err
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
6643 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
6644 ok(id
== 0, "expected 0, got %d\n", id
);
6646 /* Test data receiving notifications */
6647 ret
= send(fdWrite
, "1234", 4, 0);
6648 ok(ret
== 4, "expected 4, got %d\n", ret
);
6650 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
6651 POLL_SET(fdRead
, POLLIN
);
6652 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6653 ok(ret
== 1, "expected 1, got %d\n", ret
);
6654 ok(POLL_ISSET(fdRead
, POLLRDNORM
), "fdRead socket events incorrect\n");
6655 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
6656 ok(ret
== 4, "expected 4, got %d\n", ret
);
6657 ok(!strcmp(tmp_buf
, "1234"), "data received differs from sent\n");
6659 /* Test OOB data notifications */
6660 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
6661 ok(ret
== 1, "expected 1, got %d\n", ret
);
6663 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
6664 POLL_SET(fdRead
, POLLIN
);
6665 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6666 ok(ret
== 1, "expected 1, got %d\n", ret
);
6667 ok(POLL_ISSET(fdRead
, POLLRDBAND
), "fdRead socket events incorrect\n");
6669 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
6670 ok(ret
== 1, "expected 1, got %d\n", ret
);
6671 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
6673 /* If the socket is OOBINLINED the notification is like normal data */
6675 ret
= setsockopt(fdRead
, SOL_SOCKET
, SO_OOBINLINE
, (char*) &ret
, sizeof(ret
));
6676 ok(ret
== 0, "expected 0, got %d\n", ret
);
6677 ret
= send(fdWrite
, "A", 1, MSG_OOB
);
6678 ok(ret
== 1, "expected 1, got %d\n", ret
);
6680 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
6681 POLL_SET(fdRead
, POLLIN
| POLLOUT
);
6682 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6683 ok(ret
== 1, "expected 1, got %d\n", ret
);
6685 SetLastError(0xdeadbeef);
6686 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), MSG_OOB
);
6687 ok(ret
== SOCKET_ERROR
, "expected -1, got %d\n", ret
);
6688 ok(GetLastError() == WSAEINVAL
, "expected 10022, got %d\n", GetLastError());
6689 ret
= recv(fdRead
, tmp_buf
, sizeof(tmp_buf
), 0);
6690 ok(ret
== 1, "expected 1, got %d\n", ret
);
6691 ok(tmp_buf
[0] == 'A', "expected 'A', got 0x%02X\n", tmp_buf
[0]);
6693 /* Test connection closed notifications */
6694 ret
= closesocket(fdRead
);
6695 ok(ret
== 0, "expected 0, got %d\n", ret
);
6697 POLL_SET(fdListen
, POLLIN
| POLLOUT
);
6698 POLL_SET(fdWrite
, POLLIN
);
6699 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6700 ok(ret
== 1, "expected 1, got %d\n", ret
);
6702 ok(POLL_ISSET(fdWrite
, POLLHUP
), "fdWrite socket events incorrect\n");
6703 ret
= recv(fdWrite
, tmp_buf
, sizeof(tmp_buf
), 0);
6704 ok(ret
== 0, "expected 0, got %d\n", ret
);
6706 /* When a connection is attempted to a non-listening socket due to a bug
6707 * in the MS code it will never be notified. This is a long standing issue
6708 * that will never be fixed for compatibility reasons so we have to deal
6709 * with it manually. */
6710 ret
= closesocket(fdWrite
);
6711 ok(ret
== 0, "expected 0, got %d\n", ret
);
6712 ret
= closesocket(fdListen
);
6713 ok(ret
== 0, "expected 0, got %d\n", ret
);
6714 len
= sizeof(address
);
6715 fdWrite
= setup_connector_socket(&address
, len
, TRUE
);
6717 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
6718 poll_timeout
= 2000;
6719 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6721 ok(ret
== 0, "expected 0, got %d\n", ret
);
6724 err
= getsockopt(fdWrite
, SOL_SOCKET
, SO_ERROR
, (char*)&id
, &len
);
6725 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
6726 ok(id
== WSAECONNREFUSED
, "expected 10061, got %d\n", id
);
6727 closesocket(fdWrite
);
6729 /* Try poll() on a closed socket after connection */
6730 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
6731 closesocket(fdRead
);
6733 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
6734 POLL_SET(fdRead
, POLLIN
| POLLOUT
);
6735 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6736 ok(ret
== 1, "expected 1, got %d\n", ret
);
6737 ok(POLL_ISSET(fdRead
, POLLNVAL
), "fdRead socket events incorrect\n");
6739 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
6740 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6741 ok(ret
== 1, "expected 1, got %d\n", ret
);
6743 ok(POLL_ISSET(fdWrite
, POLLWRNORM
| POLLHUP
) || broken(POLL_ISSET(fdWrite
, POLLWRNORM
)) /* <= 2008 */,
6744 "fdWrite socket events incorrect\n");
6745 closesocket(fdWrite
);
6747 /* Close the socket currently being polled in a thread */
6748 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
6749 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
6750 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
6752 POLL_SET(fdWrite
, POLLIN
| POLLOUT
);
6753 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6754 ok(ret
== 1, "expected 1, got %d\n", ret
);
6755 ok(POLL_ISSET(fdWrite
, POLLWRNORM
), "fdWrite socket events incorrect\n");
6756 WaitForSingleObject (thread_handle
, 1000);
6757 closesocket(fdRead
);
6758 /* test again with less flags - behavior changes */
6759 ok(!tcp_socketpair(&fdRead
, &fdWrite
), "creating socket pair failed\n");
6760 thread_handle
= CreateThread(NULL
, 0, SelectCloseThread
, &fdWrite
, 0, &id
);
6761 ok(thread_handle
!= NULL
, "CreateThread failed unexpectedly: %d\n", GetLastError());
6763 POLL_SET(fdWrite
, POLLIN
);
6764 ret
= pWSAPoll(fds
, ix
, poll_timeout
);
6765 ok(ret
== 1, "expected 1, got %d\n", ret
);
6767 ok(POLL_ISSET(fdWrite
, POLLNVAL
), "fdWrite socket events incorrect\n");
6768 WaitForSingleObject (thread_handle
, 1000);
6769 closesocket(fdRead
);
6775 static void test_GetAddrInfoW(void)
6777 static const WCHAR port
[] = {'8','0',0};
6778 static const WCHAR empty
[] = {0};
6779 static const WCHAR localhost
[] = {'l','o','c','a','l','h','o','s','t',0};
6780 static const WCHAR nxdomain
[] =
6781 {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
6782 static const WCHAR zero
[] = {'0',0};
6784 ADDRINFOW
*result
, *result2
, *p
, hint
;
6786 DWORD size
= sizeof(name
)/sizeof(WCHAR
);
6788 if (!pGetAddrInfoW
|| !pFreeAddrInfoW
)
6790 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
6793 memset(&hint
, 0, sizeof(ADDRINFOW
));
6795 GetComputerNameExW( ComputerNamePhysicalDnsHostname
, name
, &size
);
6797 result
= (ADDRINFOW
*)0xdeadbeef;
6798 WSASetLastError(0xdeadbeef);
6799 ret
= pGetAddrInfoW(NULL
, NULL
, NULL
, &result
);
6800 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
6801 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
6802 ok(result
== NULL
, "got %p\n", result
);
6805 WSASetLastError(0xdeadbeef);
6806 ret
= pGetAddrInfoW(empty
, NULL
, NULL
, &result
);
6807 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6808 ok(result
!= NULL
, "GetAddrInfoW failed\n");
6809 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6810 pFreeAddrInfoW(result
);
6813 ret
= pGetAddrInfoW(NULL
, zero
, NULL
, &result
);
6814 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6815 ok(result
!= NULL
, "GetAddrInfoW failed\n");
6818 ret
= pGetAddrInfoW(NULL
, empty
, NULL
, &result2
);
6819 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6820 ok(result2
!= NULL
, "GetAddrInfoW failed\n");
6821 compare_addrinfow(result
, result2
);
6822 pFreeAddrInfoW(result
);
6823 pFreeAddrInfoW(result2
);
6826 ret
= pGetAddrInfoW(empty
, zero
, NULL
, &result
);
6827 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6828 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6829 ok(result
!= NULL
, "GetAddrInfoW failed\n");
6832 ret
= pGetAddrInfoW(empty
, empty
, NULL
, &result2
);
6833 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6834 ok(result2
!= NULL
, "GetAddrInfoW failed\n");
6835 compare_addrinfow(result
, result2
);
6836 pFreeAddrInfoW(result
);
6837 pFreeAddrInfoW(result2
);
6840 ret
= pGetAddrInfoW(localhost
, NULL
, NULL
, &result
);
6841 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6842 pFreeAddrInfoW(result
);
6845 ret
= pGetAddrInfoW(localhost
, empty
, NULL
, &result
);
6846 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6847 pFreeAddrInfoW(result
);
6850 ret
= pGetAddrInfoW(localhost
, zero
, NULL
, &result
);
6851 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6852 pFreeAddrInfoW(result
);
6855 ret
= pGetAddrInfoW(localhost
, port
, NULL
, &result
);
6856 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6857 pFreeAddrInfoW(result
);
6860 ret
= pGetAddrInfoW(localhost
, NULL
, &hint
, &result
);
6861 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6862 pFreeAddrInfoW(result
);
6865 SetLastError(0xdeadbeef);
6866 ret
= pGetAddrInfoW(localhost
, port
, &hint
, &result
);
6867 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6868 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6869 pFreeAddrInfoW(result
);
6871 /* try to get information from the computer name, result is the same
6872 * as if requesting with an empty host name. */
6873 ret
= pGetAddrInfoW(name
, NULL
, NULL
, &result
);
6874 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6875 ok(result
!= NULL
, "GetAddrInfoW failed\n");
6877 ret
= pGetAddrInfoW(empty
, NULL
, NULL
, &result2
);
6878 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6879 ok(result2
!= NULL
, "GetAddrInfoW failed\n");
6880 compare_addrinfow(result
, result2
);
6881 pFreeAddrInfoW(result
);
6882 pFreeAddrInfoW(result2
);
6884 ret
= pGetAddrInfoW(name
, empty
, NULL
, &result
);
6885 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6886 ok(result
!= NULL
, "GetAddrInfoW failed\n");
6888 ret
= pGetAddrInfoW(empty
, empty
, NULL
, &result2
);
6889 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
6890 ok(result2
!= NULL
, "GetAddrInfoW failed\n");
6891 compare_addrinfow(result
, result2
);
6892 pFreeAddrInfoW(result
);
6893 pFreeAddrInfoW(result2
);
6895 result
= (ADDRINFOW
*)0xdeadbeef;
6896 WSASetLastError(0xdeadbeef);
6897 ret
= pGetAddrInfoW(NULL
, NULL
, NULL
, &result
);
6900 skip("nxdomain returned success. Broken ISP redirects?\n");
6903 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
6904 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
6905 ok(result
== NULL
, "got %p\n", result
);
6907 result
= (ADDRINFOW
*)0xdeadbeef;
6908 WSASetLastError(0xdeadbeef);
6909 ret
= pGetAddrInfoW(nxdomain
, NULL
, NULL
, &result
);
6912 skip("nxdomain returned success. Broken ISP redirects?\n");
6915 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
6916 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
6917 ok(result
== NULL
, "got %p\n", result
);
6919 for (i
= 0;i
< (sizeof(hinttests
) / sizeof(hinttests
[0]));i
++)
6921 hint
.ai_family
= hinttests
[i
].family
;
6922 hint
.ai_socktype
= hinttests
[i
].socktype
;
6923 hint
.ai_protocol
= hinttests
[i
].protocol
;
6926 SetLastError(0xdeadbeef);
6927 ret
= pGetAddrInfoW(localhost
, NULL
, &hint
, &result
);
6930 if (hinttests
[i
].error
)
6931 ok(0, "test %d: GetAddrInfoW succeeded unexpectedly\n", i
);
6937 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
6938 if (hinttests
[i
].family
== AF_UNSPEC
)
6939 ok(p
->ai_family
== AF_INET
|| p
->ai_family
== AF_INET6
,
6940 "test %d: expected AF_INET or AF_INET6, got %d\n",
6943 ok(p
->ai_family
== hinttests
[i
].family
,
6944 "test %d: expected family %d, got %d\n",
6945 i
, hinttests
[i
].family
, p
->ai_family
);
6947 ok(p
->ai_socktype
== hinttests
[i
].socktype
,
6948 "test %d: expected type %d, got %d\n",
6949 i
, hinttests
[i
].socktype
, p
->ai_socktype
);
6950 ok(p
->ai_protocol
== hinttests
[i
].protocol
,
6951 "test %d: expected protocol %d, got %d\n",
6952 i
, hinttests
[i
].protocol
, p
->ai_protocol
);
6957 pFreeAddrInfoW(result
);
6961 DWORD err
= WSAGetLastError();
6962 if (hinttests
[i
].error
)
6963 ok(hinttests
[i
].error
== err
, "test %d: GetAddrInfoW failed with error %d, expected %d\n",
6964 i
, err
, hinttests
[i
].error
);
6966 ok(0, "test %d: GetAddrInfoW failed with %d (err %d)\n", i
, ret
, err
);
6971 static void test_getaddrinfo(void)
6974 ADDRINFOA
*result
, *result2
, *p
, hint
;
6976 DWORD size
= sizeof(name
);
6978 if (!pgetaddrinfo
|| !pfreeaddrinfo
)
6980 win_skip("getaddrinfo and/or freeaddrinfo not present\n");
6983 memset(&hint
, 0, sizeof(ADDRINFOA
));
6984 GetComputerNameExA( ComputerNamePhysicalDnsHostname
, name
, &size
);
6986 result
= (ADDRINFOA
*)0xdeadbeef;
6987 WSASetLastError(0xdeadbeef);
6988 ret
= pgetaddrinfo(NULL
, NULL
, NULL
, &result
);
6989 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
6990 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
6991 ok(result
== NULL
, "got %p\n", result
);
6994 WSASetLastError(0xdeadbeef);
6995 ret
= pgetaddrinfo("", NULL
, NULL
, &result
);
6996 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
6997 ok(result
!= NULL
, "getaddrinfo failed\n");
6998 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
6999 pfreeaddrinfo(result
);
7002 ret
= pgetaddrinfo(NULL
, "0", NULL
, &result
);
7003 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7004 ok(result
!= NULL
, "getaddrinfo failed\n");
7007 ret
= pgetaddrinfo(NULL
, "", NULL
, &result2
);
7008 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7009 ok(result2
!= NULL
, "getaddrinfo failed\n");
7010 compare_addrinfo(result
, result2
);
7011 pfreeaddrinfo(result
);
7012 pfreeaddrinfo(result2
);
7015 WSASetLastError(0xdeadbeef);
7016 ret
= pgetaddrinfo("", "0", NULL
, &result
);
7017 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7018 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7019 ok(result
!= NULL
, "getaddrinfo failed\n");
7022 ret
= pgetaddrinfo("", "", NULL
, &result2
);
7023 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7024 ok(result2
!= NULL
, "getaddrinfo failed\n");
7025 compare_addrinfo(result
, result2
);
7026 pfreeaddrinfo(result
);
7027 pfreeaddrinfo(result2
);
7030 ret
= pgetaddrinfo("localhost", NULL
, NULL
, &result
);
7031 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7032 pfreeaddrinfo(result
);
7035 ret
= pgetaddrinfo("localhost", "", NULL
, &result
);
7036 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7037 pfreeaddrinfo(result
);
7040 ret
= pgetaddrinfo("localhost", "0", NULL
, &result
);
7041 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7042 pfreeaddrinfo(result
);
7045 ret
= pgetaddrinfo("localhost", "80", NULL
, &result
);
7046 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7047 pfreeaddrinfo(result
);
7050 ret
= pgetaddrinfo("localhost", NULL
, &hint
, &result
);
7051 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7052 pfreeaddrinfo(result
);
7055 WSASetLastError(0xdeadbeef);
7056 ret
= pgetaddrinfo("localhost", "80", &hint
, &result
);
7057 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7058 ok(WSAGetLastError() == 0, "expected 0, got %d\n", WSAGetLastError());
7059 pfreeaddrinfo(result
);
7061 /* try to get information from the computer name, result is the same
7062 * as if requesting with an empty host name. */
7063 ret
= pgetaddrinfo(name
, NULL
, NULL
, &result
);
7064 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7065 ok(result
!= NULL
, "getaddrinfo failed\n");
7067 ret
= pgetaddrinfo("", NULL
, NULL
, &result2
);
7068 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7069 ok(result2
!= NULL
, "getaddrinfo failed\n");
7070 compare_addrinfo(result
, result2
);
7071 pfreeaddrinfo(result
);
7072 pfreeaddrinfo(result2
);
7074 ret
= pgetaddrinfo(name
, "", NULL
, &result
);
7075 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7076 ok(result
!= NULL
, "getaddrinfo failed\n");
7078 ret
= pgetaddrinfo("", "", NULL
, &result2
);
7079 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
7080 ok(result2
!= NULL
, "getaddrinfo failed\n");
7081 compare_addrinfo(result
, result2
);
7082 pfreeaddrinfo(result
);
7083 pfreeaddrinfo(result2
);
7085 result
= (ADDRINFOA
*)0xdeadbeef;
7086 WSASetLastError(0xdeadbeef);
7087 ret
= pgetaddrinfo("nxdomain.codeweavers.com", NULL
, NULL
, &result
);
7090 skip("nxdomain returned success. Broken ISP redirects?\n");
7093 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
7094 ok(WSAGetLastError() == WSAHOST_NOT_FOUND
, "expected 11001, got %d\n", WSAGetLastError());
7095 ok(result
== NULL
, "got %p\n", result
);
7097 for (i
= 0;i
< (sizeof(hinttests
) / sizeof(hinttests
[0]));i
++)
7099 hint
.ai_family
= hinttests
[i
].family
;
7100 hint
.ai_socktype
= hinttests
[i
].socktype
;
7101 hint
.ai_protocol
= hinttests
[i
].protocol
;
7104 SetLastError(0xdeadbeef);
7105 ret
= pgetaddrinfo("localhost", NULL
, &hint
, &result
);
7108 if (hinttests
[i
].error
)
7109 ok(0, "test %d: getaddrinfo succeeded unexpectedly\n", i
);
7115 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
7116 if (hinttests
[i
].family
== AF_UNSPEC
)
7117 ok(p
->ai_family
== AF_INET
|| p
->ai_family
== AF_INET6
,
7118 "test %d: expected AF_INET or AF_INET6, got %d\n",
7121 ok(p
->ai_family
== hinttests
[i
].family
,
7122 "test %d: expected family %d, got %d\n",
7123 i
, hinttests
[i
].family
, p
->ai_family
);
7125 ok(p
->ai_socktype
== hinttests
[i
].socktype
,
7126 "test %d: expected type %d, got %d\n",
7127 i
, hinttests
[i
].socktype
, p
->ai_socktype
);
7128 ok(p
->ai_protocol
== hinttests
[i
].protocol
,
7129 "test %d: expected protocol %d, got %d\n",
7130 i
, hinttests
[i
].protocol
, p
->ai_protocol
);
7135 pfreeaddrinfo(result
);
7139 DWORD err
= WSAGetLastError();
7140 if (hinttests
[i
].error
)
7141 ok(hinttests
[i
].error
== err
, "test %d: getaddrinfo failed with error %d, expected %d\n",
7142 i
, err
, hinttests
[i
].error
);
7144 ok(0, "test %d: getaddrinfo failed with %d (err %d)\n", i
, ret
, err
);
7149 static void test_ConnectEx(void)
7151 SOCKET listener
= INVALID_SOCKET
;
7152 SOCKET acceptor
= INVALID_SOCKET
;
7153 SOCKET connector
= INVALID_SOCKET
;
7154 struct sockaddr_in address
, conaddress
;
7156 OVERLAPPED overlapped
;
7157 LPFN_CONNECTEX pConnectEx
;
7158 GUID connectExGuid
= WSAID_CONNECTEX
;
7159 DWORD bytesReturned
;
7165 memset(&overlapped
, 0, sizeof(overlapped
));
7167 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
7168 if (listener
== INVALID_SOCKET
) {
7169 skip("could not create listener socket, error %d\n", WSAGetLastError());
7173 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7174 if (connector
== INVALID_SOCKET
) {
7175 skip("could not create connector socket, error %d\n", WSAGetLastError());
7179 memset(&address
, 0, sizeof(address
));
7180 address
.sin_family
= AF_INET
;
7181 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7182 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
7184 skip("failed to bind, error %d\n", WSAGetLastError());
7188 addrlen
= sizeof(address
);
7189 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
7191 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
7195 if (set_blocking(listener
, TRUE
)) {
7196 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7200 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectExGuid
, sizeof(connectExGuid
),
7201 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
7203 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret
, WSAGetLastError());
7207 bret
= pConnectEx(INVALID_SOCKET
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
7208 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "ConnectEx on invalid socket "
7209 "returned %d + errno %d\n", bret
, WSAGetLastError());
7211 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
7212 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "ConnectEx on a unbound socket "
7213 "returned %d + errno %d\n", bret
, WSAGetLastError());
7214 if (bret
== TRUE
|| WSAGetLastError() != WSAEINVAL
)
7216 acceptor
= accept(listener
, NULL
, NULL
);
7217 if (acceptor
!= INVALID_SOCKET
) {
7218 closesocket(acceptor
);
7219 acceptor
= INVALID_SOCKET
;
7222 closesocket(connector
);
7223 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7224 if (connector
== INVALID_SOCKET
) {
7225 skip("could not create connector socket, error %d\n", WSAGetLastError());
7230 /* ConnectEx needs a bound socket */
7231 memset(&conaddress
, 0, sizeof(conaddress
));
7232 conaddress
.sin_family
= AF_INET
;
7233 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7234 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
7236 skip("failed to bind, error %d\n", WSAGetLastError());
7240 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, NULL
);
7241 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "ConnectEx on a NULL overlapped "
7242 "returned %d + errno %d\n", bret
, WSAGetLastError());
7244 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
7245 if (overlapped
.hEvent
== NULL
) {
7246 skip("could not create event object, errno = %d\n", GetLastError());
7250 iret
= listen(listener
, 1);
7252 skip("listening failed, errno = %d\n", WSAGetLastError());
7256 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
7257 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
7258 "returned %d + errno %d\n", bret
, WSAGetLastError());
7259 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
7260 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
7262 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
7263 ok(bret
, "Connecting failed, error %d\n", GetLastError());
7264 ok(bytesReturned
== 0, "Bytes sent is %d\n", bytesReturned
);
7266 closesocket(connector
);
7267 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7268 if (connector
== INVALID_SOCKET
) {
7269 skip("could not create connector socket, error %d\n", WSAGetLastError());
7272 /* ConnectEx needs a bound socket */
7273 memset(&conaddress
, 0, sizeof(conaddress
));
7274 conaddress
.sin_family
= AF_INET
;
7275 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7276 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
7278 skip("failed to bind, error %d\n", WSAGetLastError());
7282 acceptor
= accept(listener
, NULL
, NULL
);
7283 if (acceptor
!= INVALID_SOCKET
) {
7284 closesocket(acceptor
);
7290 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, buffer
, 3, &bytesReturned
, &overlapped
);
7291 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
7292 "returned %d + errno %d\n", bret
, WSAGetLastError());
7293 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
7294 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
7296 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
7297 ok(bret
, "Connecting failed, error %d\n", GetLastError());
7298 ok(bytesReturned
== 3, "Bytes sent is %d\n", bytesReturned
);
7300 acceptor
= accept(listener
, NULL
, NULL
);
7301 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket error %d\n", WSAGetLastError());
7303 bytesReturned
= recv(acceptor
, buffer
, 3, 0);
7305 ok(bytesReturned
== 3, "Didn't get all sent data, got only %d\n", bytesReturned
);
7306 ok(buffer
[0] == '1' && buffer
[1] == '2' && buffer
[2] == '3',
7307 "Failed to get the right data, expected '123', got '%s'\n", buffer
);
7309 closesocket(connector
);
7310 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7311 if (connector
== INVALID_SOCKET
) {
7312 skip("could not create connector socket, error %d\n", WSAGetLastError());
7315 /* ConnectEx needs a bound socket */
7316 memset(&conaddress
, 0, sizeof(conaddress
));
7317 conaddress
.sin_family
= AF_INET
;
7318 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7319 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
7321 skip("failed to bind, error %d\n", WSAGetLastError());
7325 if (acceptor
!= INVALID_SOCKET
) {
7326 closesocket(acceptor
);
7327 acceptor
= INVALID_SOCKET
;
7330 /* Connect with error */
7331 closesocket(listener
);
7332 listener
= INVALID_SOCKET
;
7334 address
.sin_port
= htons(1);
7336 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
7337 ok(bret
== FALSE
&& GetLastError(), "ConnectEx to bad destination failed: "
7338 "returned %d + errno %d\n", bret
, GetLastError());
7340 if (GetLastError() == ERROR_IO_PENDING
)
7342 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
7343 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
7345 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
7346 ok(bret
== FALSE
&& GetLastError() == ERROR_CONNECTION_REFUSED
,
7347 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
7350 ok(GetLastError() == WSAECONNREFUSED
,
7351 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
7355 if (overlapped
.hEvent
)
7356 WSACloseEvent(overlapped
.hEvent
);
7357 if (listener
!= INVALID_SOCKET
)
7358 closesocket(listener
);
7359 if (acceptor
!= INVALID_SOCKET
)
7360 closesocket(acceptor
);
7361 if (connector
!= INVALID_SOCKET
)
7362 closesocket(connector
);
7365 static void test_AcceptEx(void)
7367 SOCKET listener
= INVALID_SOCKET
;
7368 SOCKET acceptor
= INVALID_SOCKET
;
7369 SOCKET connector
= INVALID_SOCKET
;
7370 SOCKET connector2
= INVALID_SOCKET
;
7371 struct sockaddr_in bindAddress
, peerAddress
, *readBindAddress
, *readRemoteAddress
;
7372 int socklen
, optlen
;
7373 GUID acceptExGuid
= WSAID_ACCEPTEX
, getAcceptExGuid
= WSAID_GETACCEPTEXSOCKADDRS
;
7374 LPFN_ACCEPTEX pAcceptEx
= NULL
;
7375 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs
= NULL
;
7376 fd_set fds_accept
, fds_send
;
7377 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
7379 DWORD bytesReturned
, connect_time
;
7380 char buffer
[1024], ipbuffer
[32];
7381 OVERLAPPED overlapped
;
7382 int iret
, localSize
= sizeof(struct sockaddr_in
), remoteSize
= localSize
;
7386 memset(&overlapped
, 0, sizeof(overlapped
));
7388 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
7389 if (listener
== INVALID_SOCKET
) {
7390 skip("could not create listener socket, error %d\n", WSAGetLastError());
7394 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7395 if (acceptor
== INVALID_SOCKET
) {
7396 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7400 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7401 if (connector
== INVALID_SOCKET
) {
7402 skip("could not create connector socket, error %d\n", WSAGetLastError());
7406 memset(&bindAddress
, 0, sizeof(bindAddress
));
7407 bindAddress
.sin_family
= AF_INET
;
7408 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7409 iret
= bind(listener
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7411 skip("failed to bind, error %d\n", WSAGetLastError());
7415 socklen
= sizeof(bindAddress
);
7416 iret
= getsockname(listener
, (struct sockaddr
*)&bindAddress
, &socklen
);
7418 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
7422 if (set_blocking(listener
, FALSE
)) {
7423 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7427 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
7428 &pAcceptEx
, sizeof(pAcceptEx
), &bytesReturned
, NULL
, NULL
);
7430 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret
, WSAGetLastError());
7434 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &getAcceptExGuid
, sizeof(getAcceptExGuid
),
7435 &pGetAcceptExSockaddrs
, sizeof(pGetAcceptExSockaddrs
), &bytesReturned
, NULL
, NULL
);
7437 skip("WSAIoctl failed to get GetAcceptExSockaddrs with ret %d + errno %d\n", iret
, WSAGetLastError());
7441 bret
= pAcceptEx(INVALID_SOCKET
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7442 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7443 &bytesReturned
, &overlapped
);
7444 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid listening socket "
7445 "returned %d + errno %d\n", bret
, WSAGetLastError());
7447 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7448 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7449 &bytesReturned
, &overlapped
);
7451 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on a non-listening socket "
7452 "returned %d + errno %d\n", bret
, WSAGetLastError());
7454 iret
= listen(listener
, 5);
7456 skip("listening failed, errno = %d\n", WSAGetLastError());
7460 bret
= pAcceptEx(listener
, INVALID_SOCKET
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7461 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7462 &bytesReturned
, &overlapped
);
7463 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid accepting socket "
7464 "returned %d + errno %d\n", bret
, WSAGetLastError());
7466 bret
= pAcceptEx(listener
, acceptor
, NULL
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7467 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7468 &bytesReturned
, &overlapped
);
7470 (WSAGetLastError() == WSAEINVAL
||
7471 broken(WSAGetLastError() == WSAEFAULT
)), /* NT4 */
7472 "AcceptEx on NULL buffer returned %d + errno %d\n", bret
, WSAGetLastError());
7474 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
7475 &bytesReturned
, &overlapped
);
7476 ok(bret
== FALSE
&& (WSAGetLastError() == ERROR_IO_PENDING
|| broken(WSAGetLastError() == WSAEINVAL
)) /* NT4 */,
7477 "AcceptEx on too small local address size returned %d + errno %d\n",
7478 bret
, WSAGetLastError());
7479 bret
= CancelIo((HANDLE
) listener
);
7480 ok(bret
, "Failed to cancel pending accept socket\n");
7482 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 15,
7483 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
7484 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx on too small local address "
7485 "size returned %d + errno %d\n",
7486 bret
, WSAGetLastError());
7487 bret
= CancelIo((HANDLE
) listener
);
7488 ok(bret
, "Failed to cancel pending accept socket\n");
7490 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16, 0,
7491 &bytesReturned
, &overlapped
);
7492 ok(bret
== FALSE
&& (WSAGetLastError() == WSAEFAULT
|| broken(WSAGetLastError() == WSAEINVAL
)) /* NT4 */,
7493 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
7495 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
7496 sizeof(struct sockaddr_in
) + 15, &bytesReturned
, &overlapped
);
7497 ok(bret
== FALSE
&& (WSAGetLastError() == ERROR_IO_PENDING
|| broken(WSAGetLastError() == WSAEINVAL
)) /* NT4 */,
7498 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
7499 bret
= CancelIo((HANDLE
) listener
);
7500 ok(bret
, "Failed to cancel pending accept socket\n");
7502 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
7503 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7504 &bytesReturned
, NULL
);
7505 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
7506 "returned %d + errno %d\n", bret
, WSAGetLastError());
7508 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, 0, &bytesReturned
, NULL
);
7509 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
7510 "returned %d + errno %d\n", bret
, WSAGetLastError());
7512 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
7513 if (overlapped
.hEvent
== NULL
) {
7514 skip("could not create event object, errno = %d\n", GetLastError());
7518 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
7519 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7520 &bytesReturned
, &overlapped
);
7521 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7523 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
7524 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7525 &bytesReturned
, &overlapped
);
7526 todo_wine
ok((bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
) || broken(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) /* NT4 */,
7527 "AcceptEx on already pending socket returned %d + errno %d\n", bret
, WSAGetLastError());
7528 if (bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) {
7529 /* We need to cancel this call, otherwise things fail */
7530 bret
= CancelIo((HANDLE
) listener
);
7531 ok(bret
, "Failed to cancel failed test. Bailing...\n");
7533 WaitForSingleObject(overlapped
.hEvent
, 0);
7535 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
7536 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7537 &bytesReturned
, &overlapped
);
7538 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7541 iret
= connect(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7542 todo_wine
ok((iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
) || broken(!iret
) /* NT4 */,
7543 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret
, WSAGetLastError());
7544 if (!iret
|| (iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
)) {
7545 /* We need to cancel this call, otherwise things fail */
7546 closesocket(acceptor
);
7547 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7548 if (acceptor
== INVALID_SOCKET
) {
7549 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7553 bret
= CancelIo((HANDLE
) listener
);
7554 ok(bret
, "Failed to cancel failed test. Bailing...\n");
7557 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
7558 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7559 &bytesReturned
, &overlapped
);
7560 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7563 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7564 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7566 dwret
= WaitForSingleObject(overlapped
.hEvent
, INFINITE
);
7567 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7569 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7570 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
7571 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
7573 closesocket(connector
);
7574 connector
= INVALID_SOCKET
;
7575 closesocket(acceptor
);
7577 /* Test short reads */
7579 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7580 if (acceptor
== INVALID_SOCKET
) {
7581 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7584 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7585 if (connector
== INVALID_SOCKET
) {
7586 skip("could not create connector socket, error %d\n", WSAGetLastError());
7589 bret
= pAcceptEx(listener
, acceptor
, buffer
, 2,
7590 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7591 &bytesReturned
, &overlapped
);
7592 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7594 connect_time
= 0xdeadbeef;
7595 optlen
= sizeof(connect_time
);
7596 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
7597 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
7598 ok(connect_time
== ~0u, "unexpected connect time %u\n", connect_time
);
7600 /* AcceptEx() still won't complete until we send data */
7601 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7602 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7604 connect_time
= 0xdeadbeef;
7605 optlen
= sizeof(connect_time
);
7606 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
7607 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
7608 ok(connect_time
< 0xdeadbeef, "unexpected connect time %u\n", connect_time
);
7610 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
7611 ok(dwret
== WAIT_TIMEOUT
, "Waiting for accept event timeout failed with %d + errno %d\n", dwret
, GetLastError());
7613 iret
= getsockname( connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
7614 ok( !iret
, "getsockname failed.\n");
7616 /* AcceptEx() could complete any time now */
7617 iret
= send(connector
, buffer
, 1, 0);
7618 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
7620 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7621 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7623 /* Check if the buffer from AcceptEx is decoded correctly */
7624 pGetAcceptExSockaddrs(buffer
, 2, sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7625 (struct sockaddr
**)&readBindAddress
, &localSize
,
7626 (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
7627 strcpy( ipbuffer
, inet_ntoa(readBindAddress
->sin_addr
));
7628 ok( readBindAddress
->sin_addr
.s_addr
== bindAddress
.sin_addr
.s_addr
,
7629 "Local socket address is different %s != %s\n",
7630 ipbuffer
, inet_ntoa(bindAddress
.sin_addr
));
7631 ok( readBindAddress
->sin_port
== bindAddress
.sin_port
,
7632 "Local socket port is different: %d != %d\n",
7633 readBindAddress
->sin_port
, bindAddress
.sin_port
);
7634 strcpy( ipbuffer
, inet_ntoa(readRemoteAddress
->sin_addr
));
7635 ok( readRemoteAddress
->sin_addr
.s_addr
== peerAddress
.sin_addr
.s_addr
,
7636 "Remote socket address is different %s != %s\n",
7637 ipbuffer
, inet_ntoa(peerAddress
.sin_addr
));
7638 ok( readRemoteAddress
->sin_port
== peerAddress
.sin_port
,
7639 "Remote socket port is different: %d != %d\n",
7640 readRemoteAddress
->sin_port
, peerAddress
.sin_port
);
7642 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7643 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
7644 ok(bytesReturned
== 1, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
7646 closesocket(connector
);
7647 connector
= INVALID_SOCKET
;
7648 closesocket(acceptor
);
7650 /* Test CF_DEFER & AcceptEx interaction */
7652 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7653 if (acceptor
== INVALID_SOCKET
) {
7654 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7657 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7658 if (connector
== INVALID_SOCKET
) {
7659 skip("could not create connector socket, error %d\n", WSAGetLastError());
7662 connector2
= socket(AF_INET
, SOCK_STREAM
, 0);
7663 if (connector
== INVALID_SOCKET
) {
7664 skip("could not create connector socket, error %d\n", WSAGetLastError());
7668 if (set_blocking(connector
, FALSE
)) {
7669 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7673 if (set_blocking(connector2
, FALSE
)) {
7674 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
7678 /* Connect socket #1 */
7679 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7680 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7682 FD_ZERO ( &fds_accept
);
7683 FD_ZERO ( &fds_send
);
7685 FD_SET ( listener
, &fds_accept
);
7686 FD_SET ( connector
, &fds_send
);
7692 for (i
= 0; i
< 4000; ++i
)
7694 fd_set fds_openaccept
= fds_accept
, fds_opensend
= fds_send
;
7696 wsa_ok ( ( select ( 0, &fds_openaccept
, &fds_opensend
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
7697 "acceptex test(%d): could not select on socket, errno %d\n" );
7699 /* check for incoming requests */
7700 if ( FD_ISSET ( listener
, &fds_openaccept
) ) {
7703 SOCKET tmp
= WSAAccept(listener
, NULL
, NULL
, (LPCONDITIONPROC
) AlwaysDeferConditionFunc
, 0);
7704 ok(tmp
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
7705 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
7706 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7707 &bytesReturned
, &overlapped
);
7708 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7710 else if (got
== 2) {
7711 /* this should be socket #2 */
7712 SOCKET tmp
= accept(listener
, NULL
, NULL
);
7713 ok(tmp
!= INVALID_SOCKET
, "accept failed %d\n", WSAGetLastError());
7717 ok(FALSE
, "Got more than 2 connections?\n");
7720 if ( conn1
&& FD_ISSET ( connector2
, &fds_opensend
) ) {
7721 /* Send data on second socket, and stop */
7722 send(connector2
, "2", 1, 0);
7723 FD_CLR ( connector2
, &fds_send
);
7727 if ( FD_ISSET ( connector
, &fds_opensend
) ) {
7728 /* Once #1 is connected, allow #2 to connect */
7731 send(connector
, "1", 1, 0);
7732 FD_CLR ( connector
, &fds_send
);
7734 iret
= connect(connector2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7735 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7736 FD_SET ( connector2
, &fds_send
);
7740 ok (got
== 2 || broken(got
== 1) /* NT4 */,
7741 "Did not get both connections, got %d\n", got
);
7743 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
7744 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7746 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7747 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
7748 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
7750 set_blocking(acceptor
, TRUE
);
7751 iret
= recv( acceptor
, buffer
, 2, 0);
7752 ok(iret
== 1, "Failed to get data, %d, errno: %d\n", iret
, WSAGetLastError());
7754 ok(buffer
[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer
[0]);
7756 closesocket(connector
);
7757 connector
= INVALID_SOCKET
;
7758 closesocket(acceptor
);
7760 /* clean up in case of failures */
7761 while ((acceptor
= accept(listener
, NULL
, NULL
)) != INVALID_SOCKET
)
7762 closesocket(acceptor
);
7764 /* Disconnect during receive? */
7766 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7767 if (acceptor
== INVALID_SOCKET
) {
7768 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7771 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7772 if (connector
== INVALID_SOCKET
) {
7773 skip("could not create connector socket, error %d\n", WSAGetLastError());
7776 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7777 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7778 &bytesReturned
, &overlapped
);
7779 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7781 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7782 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
7784 closesocket(connector
);
7785 connector
= INVALID_SOCKET
;
7787 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7788 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7790 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7791 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
7792 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
7794 closesocket(acceptor
);
7796 /* Test closing with pending requests */
7798 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7799 if (acceptor
== INVALID_SOCKET
) {
7800 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7803 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7804 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7805 &bytesReturned
, &overlapped
);
7806 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7808 closesocket(acceptor
);
7810 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7811 todo_wine
ok(dwret
== WAIT_OBJECT_0
|| broken(dwret
== WAIT_TIMEOUT
) /* NT4/2000 */,
7812 "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7814 if (dwret
!= WAIT_TIMEOUT
) {
7815 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7816 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
7819 bret
= CancelIo((HANDLE
) listener
);
7820 ok(bret
, "Failed to cancel failed test. Bailing...\n");
7822 WaitForSingleObject(overlapped
.hEvent
, 0);
7825 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7826 if (acceptor
== INVALID_SOCKET
) {
7827 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7830 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7831 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7832 &bytesReturned
, &overlapped
);
7833 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7835 CancelIo((HANDLE
) acceptor
);
7837 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7838 ok(dwret
== WAIT_TIMEOUT
, "Waiting for timeout failed with %d + errno %d\n", dwret
, GetLastError());
7840 closesocket(acceptor
);
7842 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
7843 if (acceptor
== INVALID_SOCKET
) {
7844 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7847 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
7848 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7849 &bytesReturned
, &overlapped
);
7850 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
7852 closesocket(listener
);
7853 listener
= INVALID_SOCKET
;
7855 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
7856 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
7858 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
7859 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
7862 if (overlapped
.hEvent
)
7863 WSACloseEvent(overlapped
.hEvent
);
7864 if (listener
!= INVALID_SOCKET
)
7865 closesocket(listener
);
7866 if (acceptor
!= INVALID_SOCKET
)
7867 closesocket(acceptor
);
7868 if (connector
!= INVALID_SOCKET
)
7869 closesocket(connector
);
7870 if (connector2
!= INVALID_SOCKET
)
7871 closesocket(connector2
);
7874 static void test_DisconnectEx(void)
7876 SOCKET listener
, acceptor
, connector
;
7877 LPFN_DISCONNECTEX pDisconnectEx
;
7878 GUID disconnectExGuid
= WSAID_DISCONNECTEX
;
7879 struct sockaddr_in address
;
7880 DWORD num_bytes
, flags
;
7881 OVERLAPPED overlapped
;
7885 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7886 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket, error %d\n", WSAGetLastError());
7888 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &disconnectExGuid
, sizeof(disconnectExGuid
),
7889 &pDisconnectEx
, sizeof(pDisconnectEx
), &num_bytes
, NULL
, NULL
);
7892 win_skip("WSAIoctl failed to get DisconnectEx, error %d\n", WSAGetLastError());
7893 closesocket(connector
);
7897 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
7898 ok(listener
!= INVALID_SOCKET
, "failed to create listener socket, error %d\n", WSAGetLastError());
7900 memset(&address
, 0, sizeof(address
));
7901 address
.sin_family
= AF_INET
;
7902 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
7903 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
7904 ok(iret
== 0, "failed to bind, error %d\n", WSAGetLastError());
7906 addrlen
= sizeof(address
);
7907 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
7908 ok(iret
== 0, "failed to lookup bind address, error %d\n", WSAGetLastError());
7910 iret
= listen(listener
, 1);
7911 ok(iret
== 0, "failed to listen, error %d\n", WSAGetLastError());
7913 set_blocking(listener
, TRUE
);
7915 memset(&overlapped
, 0, sizeof(overlapped
));
7916 bret
= pDisconnectEx(INVALID_SOCKET
, &overlapped
, 0, 0);
7917 ok(bret
== FALSE
, "DisconnectEx unexpectedly succeeded\n");
7918 ok(WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %d\n", WSAGetLastError());
7920 memset(&overlapped
, 0, sizeof(overlapped
));
7921 bret
= pDisconnectEx(connector
, &overlapped
, 0, 0);
7922 ok(bret
== FALSE
, "DisconnectEx unexpectedly succeeded\n");
7923 todo_wine
ok(WSAGetLastError() == WSAENOTCONN
, "expected WSAENOTCONN, got %d\n", WSAGetLastError());
7925 iret
= connect(connector
, (struct sockaddr
*)&address
, addrlen
);
7926 ok(iret
== 0, "failed to connect, error %d\n", WSAGetLastError());
7928 acceptor
= accept(listener
, NULL
, NULL
);
7929 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket, error %d\n", WSAGetLastError());
7931 memset(&overlapped
, 0, sizeof(overlapped
));
7932 overlapped
.hEvent
= WSACreateEvent();
7933 ok(overlapped
.hEvent
!= WSA_INVALID_EVENT
, "WSACreateEvent failed, error %d\n", WSAGetLastError());
7934 bret
= pDisconnectEx(connector
, &overlapped
, 0, 0);
7936 ok(overlapped
.Internal
== STATUS_PENDING
, "expected STATUS_PENDING, got %08lx\n", overlapped
.Internal
);
7937 else if (WSAGetLastError() == ERROR_IO_PENDING
)
7938 bret
= WSAGetOverlappedResult(connector
, &overlapped
, &num_bytes
, TRUE
, &flags
);
7939 ok(bret
, "DisconnectEx failed, error %d\n", WSAGetLastError());
7940 WSACloseEvent(overlapped
.hEvent
);
7942 iret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
7943 ok(iret
!= 0, "connect unexpectedly succeeded\n");
7944 ok(WSAGetLastError() == WSAEISCONN
, "expected WSAEISCONN, got %d\n", WSAGetLastError());
7946 closesocket(acceptor
);
7947 closesocket(connector
);
7949 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7950 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket, error %d\n", WSAGetLastError());
7952 iret
= connect(connector
, (struct sockaddr
*)&address
, addrlen
);
7953 ok(iret
== 0, "failed to connect, error %d\n", WSAGetLastError());
7955 acceptor
= accept(listener
, NULL
, NULL
);
7956 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket, error %d\n", WSAGetLastError());
7958 bret
= pDisconnectEx(connector
, NULL
, 0, 0);
7959 ok(bret
, "DisconnectEx failed, error %d\n", WSAGetLastError());
7961 iret
= connect(connector
, (struct sockaddr
*)&address
, sizeof(address
));
7962 ok(iret
!= 0, "connect unexpectedly succeeded\n");
7963 ok(WSAGetLastError() == WSAEISCONN
, "expected WSAEISCONN, got %d\n", WSAGetLastError());
7965 closesocket(acceptor
);
7966 closesocket(connector
);
7967 closesocket(listener
);
7970 #define compare_file(h,s,o) compare_file2(h,s,o,__FILE__,__LINE__)
7972 static void compare_file2(HANDLE handle
, SOCKET sock
, int offset
, const char *file
, int line
)
7974 char buf1
[256], buf2
[256];
7978 SetFilePointer(handle
, offset
, NULL
, FILE_BEGIN
);
7981 DWORD n1
= 0, n2
= 0;
7983 success
= ReadFile(handle
, buf1
, sizeof(buf1
), &n1
, NULL
);
7984 ok_(file
,line
)(success
, "Failed to read from file.\n");
7985 if (success
&& n1
== 0)
7989 n2
= recv(sock
, buf2
, n1
, 0);
7990 ok_(file
,line
)(n1
== n2
, "Block %d size mismatch (%d != %d)\n", i
, n1
, n2
);
7991 ok_(file
,line
)(memcmp(buf1
, buf2
, n2
) == 0, "Block %d failed\n", i
);
7996 static void test_TransmitFile(void)
7998 DWORD num_bytes
, err
, file_size
, total_sent
;
7999 GUID transmitFileGuid
= WSAID_TRANSMITFILE
;
8000 LPFN_TRANSMITFILE pTransmitFile
= NULL
;
8001 HANDLE file
= INVALID_HANDLE_VALUE
;
8002 char header_msg
[] = "hello world";
8003 char footer_msg
[] = "goodbye!!!";
8004 char system_ini_path
[MAX_PATH
];
8005 struct sockaddr_in bindAddress
;
8006 TRANSMIT_FILE_BUFFERS buffers
;
8007 SOCKET client
, server
, dest
;
8013 memset( &ov
, 0, sizeof(ov
) );
8015 /* Setup sockets for testing TransmitFile */
8016 client
= socket(AF_INET
, SOCK_STREAM
, 0);
8017 server
= socket(AF_INET
, SOCK_STREAM
, 0);
8018 if (client
== INVALID_SOCKET
|| server
== INVALID_SOCKET
)
8020 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8023 iret
= WSAIoctl(client
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &transmitFileGuid
, sizeof(transmitFileGuid
),
8024 &pTransmitFile
, sizeof(pTransmitFile
), &num_bytes
, NULL
, NULL
);
8027 skip("WSAIoctl failed to get TransmitFile with ret %d + errno %d\n", iret
, WSAGetLastError());
8030 GetSystemWindowsDirectoryA(system_ini_path
, MAX_PATH
);
8031 strcat(system_ini_path
, "\\system.ini");
8032 file
= CreateFileA(system_ini_path
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_ALWAYS
, 0x0, NULL
);
8033 if (file
== INVALID_HANDLE_VALUE
)
8035 skip("Unable to open a file to transmit.\n");
8038 file_size
= GetFileSize(file
, NULL
);
8040 /* Test TransmitFile with an invalid socket */
8041 bret
= pTransmitFile(INVALID_SOCKET
, file
, 0, 0, NULL
, NULL
, 0);
8042 err
= WSAGetLastError();
8043 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8044 ok(err
== WSAENOTSOCK
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTSOCK
);
8046 /* Test a bogus TransmitFile without a connected socket */
8047 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, TF_REUSE_SOCKET
);
8048 err
= WSAGetLastError();
8049 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8050 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTCONN
);
8052 /* Setup a properly connected socket for transfers */
8053 memset(&bindAddress
, 0, sizeof(bindAddress
));
8054 bindAddress
.sin_family
= AF_INET
;
8055 bindAddress
.sin_port
= htons(9375);
8056 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8057 iret
= bind(server
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8060 skip("failed to bind(), error %d\n", WSAGetLastError());
8063 iret
= listen(server
, 1);
8066 skip("failed to listen(), error %d\n", WSAGetLastError());
8069 iret
= connect(client
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8072 skip("failed to connect(), error %d\n", WSAGetLastError());
8075 len
= sizeof(bindAddress
);
8076 dest
= accept(server
, (struct sockaddr
*)&bindAddress
, &len
);
8077 if (dest
== INVALID_SOCKET
)
8079 skip("failed to accept(), error %d\n", WSAGetLastError());
8082 if (set_blocking(dest
, FALSE
))
8084 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8088 /* Test TransmitFile with no possible buffer */
8089 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
8090 ok(bret
, "TransmitFile failed unexpectedly.\n");
8091 iret
= recv(dest
, buf
, sizeof(buf
), 0);
8092 ok(iret
== -1, "Returned an unexpected buffer from TransmitFile (%d != -1).\n", iret
);
8094 /* Test TransmitFile with only buffer data */
8095 buffers
.Head
= &header_msg
[0];
8096 buffers
.HeadLength
= sizeof(header_msg
)+1;
8097 buffers
.Tail
= &footer_msg
[0];
8098 buffers
.TailLength
= sizeof(footer_msg
)+1;
8099 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, &buffers
, 0);
8100 ok(bret
, "TransmitFile failed unexpectedly.\n");
8101 iret
= recv(dest
, buf
, sizeof(buf
), 0);
8102 ok(iret
== sizeof(header_msg
)+sizeof(footer_msg
)+2,
8103 "Returned an unexpected buffer from TransmitFile: %d\n", iret
);
8104 ok(memcmp(&buf
[0], &header_msg
[0], sizeof(header_msg
)+1) == 0,
8105 "TransmitFile header buffer did not match!\n");
8106 ok(memcmp(&buf
[sizeof(header_msg
)+1], &footer_msg
[0], sizeof(footer_msg
)+1) == 0,
8107 "TransmitFile footer buffer did not match!\n");
8109 /* Test TransmitFile with only file data */
8110 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, NULL
, 0);
8111 ok(bret
, "TransmitFile failed unexpectedly.\n");
8112 compare_file(file
, dest
, 0);
8114 /* Test TransmitFile with both file and buffer data */
8115 buffers
.Head
= &header_msg
[0];
8116 buffers
.HeadLength
= sizeof(header_msg
)+1;
8117 buffers
.Tail
= &footer_msg
[0];
8118 buffers
.TailLength
= sizeof(footer_msg
)+1;
8119 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8120 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, &buffers
, 0);
8121 ok(bret
, "TransmitFile failed unexpectedly.\n");
8122 iret
= recv(dest
, buf
, sizeof(header_msg
)+1, 0);
8123 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)+1) == 0,
8124 "TransmitFile header buffer did not match!\n");
8125 compare_file(file
, dest
, 0);
8126 iret
= recv(dest
, buf
, sizeof(footer_msg
)+1, 0);
8127 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)+1) == 0,
8128 "TransmitFile footer buffer did not match!\n");
8130 /* Test overlapped TransmitFile */
8131 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
8132 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
8134 skip("Could not create event object, some tests will be skipped. errno = %d\n",
8138 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8139 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
8140 err
= WSAGetLastError();
8141 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8142 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n",
8143 err
, ERROR_IO_PENDING
);
8144 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
8145 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
8146 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
8147 ok(total_sent
== file_size
,
8148 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8149 total_sent
, file_size
);
8150 compare_file(file
, dest
, 0);
8152 /* Test overlapped TransmitFile w/ start offset */
8153 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
8154 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
8156 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
8159 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8161 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, NULL
, 0);
8162 err
= WSAGetLastError();
8163 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8164 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, ERROR_IO_PENDING
);
8165 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
8166 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
8167 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
8168 ok(total_sent
== (file_size
- ov
.Offset
),
8169 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8170 total_sent
, file_size
- ov
.Offset
);
8171 compare_file(file
, dest
, ov
.Offset
);
8173 /* Test overlapped TransmitFile w/ file and buffer data */
8174 ov
.hEvent
= CreateEventW(NULL
, FALSE
, FALSE
, NULL
);
8175 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
8177 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
8180 buffers
.Head
= &header_msg
[0];
8181 buffers
.HeadLength
= sizeof(header_msg
)+1;
8182 buffers
.Tail
= &footer_msg
[0];
8183 buffers
.TailLength
= sizeof(footer_msg
)+1;
8184 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8186 bret
= pTransmitFile(client
, file
, 0, 0, &ov
, &buffers
, 0);
8187 err
= WSAGetLastError();
8188 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8189 ok(err
== ERROR_IO_PENDING
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, ERROR_IO_PENDING
);
8190 iret
= WaitForSingleObject(ov
.hEvent
, 2000);
8191 ok(iret
== WAIT_OBJECT_0
, "Overlapped TransmitFile failed.\n");
8192 WSAGetOverlappedResult(client
, &ov
, &total_sent
, FALSE
, NULL
);
8193 ok(total_sent
== (file_size
+ buffers
.HeadLength
+ buffers
.TailLength
),
8194 "Overlapped TransmitFile sent an unexpected number of bytes (%d != %d).\n",
8195 total_sent
, file_size
+ buffers
.HeadLength
+ buffers
.TailLength
);
8196 iret
= recv(dest
, buf
, sizeof(header_msg
)+1, 0);
8197 ok(memcmp(buf
, &header_msg
[0], sizeof(header_msg
)+1) == 0,
8198 "TransmitFile header buffer did not match!\n");
8199 compare_file(file
, dest
, 0);
8200 iret
= recv(dest
, buf
, sizeof(footer_msg
)+1, 0);
8201 ok(memcmp(buf
, &footer_msg
[0], sizeof(footer_msg
)+1) == 0,
8202 "TransmitFile footer buffer did not match!\n");
8204 /* Test TransmitFile w/ TF_DISCONNECT */
8205 SetFilePointer(file
, 0, NULL
, FILE_BEGIN
);
8206 bret
= pTransmitFile(client
, file
, 0, 0, NULL
, NULL
, TF_DISCONNECT
);
8207 ok(bret
, "TransmitFile failed unexpectedly.\n");
8208 compare_file(file
, dest
, 0);
8209 closesocket(client
);
8210 ok(send(client
, "test", 4, 0) == -1, "send() after TF_DISCONNECT succeeded unexpectedly.\n");
8211 err
= WSAGetLastError();
8212 todo_wine
ok(err
== WSAENOTSOCK
, "send() after TF_DISCONNECT triggered unexpected errno (%d != %d)\n",
8215 /* Test TransmitFile with a UDP datagram socket */
8216 client
= socket(AF_INET
, SOCK_DGRAM
, 0);
8217 bret
= pTransmitFile(client
, NULL
, 0, 0, NULL
, NULL
, 0);
8218 err
= WSAGetLastError();
8219 ok(!bret
, "TransmitFile succeeded unexpectedly.\n");
8220 ok(err
== WSAENOTCONN
, "TransmitFile triggered unexpected errno (%d != %d)\n", err
, WSAENOTCONN
);
8224 CloseHandle(ov
.hEvent
);
8225 closesocket(client
);
8226 closesocket(server
);
8229 static void test_getpeername(void)
8232 struct sockaddr_in sa
, sa_out
;
8233 SOCKADDR_STORAGE ss
;
8235 const char buf
[] = "hello world";
8238 /* Test the parameter validation order. */
8239 ret
= getpeername(INVALID_SOCKET
, NULL
, NULL
);
8240 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8241 ok(WSAGetLastError() == WSAENOTSOCK
,
8242 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
8244 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
8245 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8246 if (sock
== INVALID_SOCKET
)
8248 skip("Socket creation failed with %d\n", WSAGetLastError());
8252 ret
= getpeername(sock
, NULL
, NULL
);
8253 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8254 ok(WSAGetLastError() == WSAENOTCONN
||
8255 broken(WSAGetLastError() == WSAEFAULT
), /* Win9x and WinMe */
8256 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8258 memset(&sa
, 0, sizeof(sa
));
8259 sa
.sin_family
= AF_INET
;
8260 sa
.sin_port
= htons(139);
8261 sa
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
8263 /* sendto does not change a socket's connection state. */
8264 ret
= sendto(sock
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
8265 ok(ret
!= SOCKET_ERROR
,
8266 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
8268 ret
= getpeername(sock
, NULL
, NULL
);
8269 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8270 ok(WSAGetLastError() == WSAENOTCONN
||
8271 broken(WSAGetLastError() == WSAEFAULT
), /* Win9x and WinMe */
8272 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
8274 ret
= connect(sock
, (struct sockaddr
*)&sa
, sizeof(sa
));
8276 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
8278 ret
= getpeername(sock
, NULL
, NULL
);
8279 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8280 ok(WSAGetLastError() == WSAEFAULT
,
8281 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8283 /* Test crashes on Wine. */
8286 ret
= getpeername(sock
, (void*)0xdeadbeef, (void*)0xcafebabe);
8287 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
8288 ok(WSAGetLastError() == WSAEFAULT
,
8289 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8292 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, NULL
);
8293 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
8294 ok(WSAGetLastError() == WSAEFAULT
,
8295 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8298 ret
= getpeername(sock
, NULL
, &sa_len
);
8299 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
8300 ok(WSAGetLastError() == WSAEFAULT
,
8301 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8302 ok(!sa_len
, "got %d\n", sa_len
);
8305 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
8306 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
8307 ok(WSAGetLastError() == WSAEFAULT
,
8308 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
8309 ok(!sa_len
, "got %d\n", sa_len
);
8311 sa_len
= sizeof(ss
);
8312 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
8313 ok(ret
== 0, "Expected getpeername to return 0, got %d\n", ret
);
8314 ok(!memcmp(&sa
, &ss
, sizeof(sa
)),
8315 "Expected the returned structure to be identical to the connect structure\n");
8316 ok(sa_len
== sizeof(sa
), "got %d\n", sa_len
);
8321 static void test_sioRoutingInterfaceQuery(void)
8325 SOCKADDR_IN sin
= { 0 }, sout
= { 0 };
8326 DWORD bytesReturned
;
8328 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
8329 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8330 if (sock
== INVALID_SOCKET
)
8332 skip("Socket creation failed with %d\n", WSAGetLastError());
8335 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, NULL
, 0, NULL
, 0, NULL
,
8337 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
8338 "expected WSAEFAULT, got %d\n", WSAGetLastError());
8339 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
8340 NULL
, 0, NULL
, NULL
, NULL
);
8341 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
8342 "expected WSAEFAULT, got %d\n", WSAGetLastError());
8343 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
8344 NULL
, 0, &bytesReturned
, NULL
, NULL
);
8345 ok(ret
== SOCKET_ERROR
&&
8346 (WSAGetLastError() == WSAEFAULT
/* Win98 */ ||
8347 WSAGetLastError() == WSAEINVAL
/* NT4 */||
8348 WSAGetLastError() == WSAEAFNOSUPPORT
),
8349 "expected WSAEFAULT or WSAEINVAL or WSAEAFNOSUPPORT, got %d\n",
8351 sin
.sin_family
= AF_INET
;
8352 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
8353 NULL
, 0, &bytesReturned
, NULL
, NULL
);
8354 ok(ret
== SOCKET_ERROR
&&
8355 (WSAGetLastError() == WSAEFAULT
/* Win98 */ ||
8356 WSAGetLastError() == WSAEINVAL
),
8357 "expected WSAEFAULT or WSAEINVAL, got %d\n", WSAGetLastError());
8358 sin
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
8359 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
8360 NULL
, 0, &bytesReturned
, NULL
, NULL
);
8361 ok(ret
== SOCKET_ERROR
&&
8362 (WSAGetLastError() == WSAEINVAL
/* NT4 */ ||
8363 WSAGetLastError() == WSAEFAULT
),
8364 "expected WSAEINVAL or WSAEFAULT, got %d\n", WSAGetLastError());
8365 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
8366 &sout
, sizeof(sout
), &bytesReturned
, NULL
, NULL
);
8367 ok(!ret
|| broken(WSAGetLastError() == WSAEINVAL
/* NT4 */),
8368 "WSAIoctl failed: %d\n", WSAGetLastError());
8371 ok(sout
.sin_family
== AF_INET
, "expected AF_INET, got %d\n",
8373 /* We expect the source address to be INADDR_LOOPBACK as well, but
8374 * there's no guarantee that a route to the loopback address exists,
8375 * so rather than introduce spurious test failures we do not test the
8382 static void test_sioAddressListChange(void)
8384 struct sockaddr_in bindAddress
;
8385 struct in_addr net_address
;
8386 WSAOVERLAPPED overlapped
;
8393 if (!winetest_interactive
)
8395 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, interactive tests must be enabled\n");
8399 /* Use gethostbyname to find the list of local network interfaces */
8400 h
= gethostbyname("");
8403 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, gethostbyname failed with %u\n",
8407 for (acount
= 0; h
->h_addr_list
[acount
]; acount
++);
8410 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, test requires a network card.\n");
8413 net_address
.s_addr
= *(ULONG
*) h
->h_addr_list
[0];
8415 /* Bind an overlapped socket to the first found network interface */
8416 sock
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8417 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
8418 if (sock
== INVALID_SOCKET
)
8420 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, socket creation failed with %u\n",
8424 memset(&bindAddress
, 0, sizeof(bindAddress
));
8425 bindAddress
.sin_family
= AF_INET
;
8426 bindAddress
.sin_addr
.s_addr
= net_address
.s_addr
;
8427 ret
= bind(sock
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
8430 skip("Cannot test SIO_ADDRESS_LIST_CHANGE, failed to bind, error %u\n", WSAGetLastError());
8434 /* Wait for address changes, request that the user connects/disconnects an interface */
8435 memset(&overlapped
, 0, sizeof(overlapped
));
8436 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
8437 ret
= WSAIoctl(sock
, SIO_ADDRESS_LIST_CHANGE
, NULL
, 0, NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8438 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
8439 ok(WSAGetLastError() == WSA_IO_PENDING
, "Expected pending last error %d\n", WSAGetLastError());
8440 trace("Testing socket-based ipv4 address list change notification. Please connect/disconnect or"
8441 " change the ipv4 address of any of the local network interfaces (10 second timeout).\n");
8442 ret
= WaitForSingleObject(overlapped
.hEvent
, 10000);
8443 ok(ret
== WAIT_OBJECT_0
, "failed to get overlapped event %u\n", ret
);
8449 static void test_synchronous_WSAIoctl(void)
8451 HANDLE previous_port
, io_port
;
8452 WSAOVERLAPPED overlapped
, *olp
;
8460 previous_port
= CreateIoCompletionPort( INVALID_HANDLE_VALUE
, NULL
, 0, 0 );
8461 ok( previous_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
8463 socket
= WSASocketW( AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
8464 ok( socket
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError() );
8466 io_port
= CreateIoCompletionPort( (HANDLE
)socket
, previous_port
, 0, 0 );
8467 ok( io_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
8470 memset( &overlapped
, 0, sizeof(overlapped
) );
8471 res
= WSAIoctl( socket
, FIONBIO
, &on
, sizeof(on
), NULL
, 0, &num_bytes
, &overlapped
, NULL
);
8472 ok( !res
, "WSAIoctl failed %d\n", WSAGetLastError() );
8474 ret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 10000 );
8475 ok( ret
, "failed to get completion status %u\n", GetLastError() );
8477 CloseHandle( io_port
);
8478 closesocket( socket
);
8479 CloseHandle( previous_port
);
8482 #define WM_ASYNCCOMPLETE (WM_USER + 100)
8483 static HWND
create_async_message_window(void)
8485 static const char class_name
[] = "ws2_32 async message window class";
8487 WNDCLASSEXA wndclass
;
8490 wndclass
.cbSize
= sizeof(wndclass
);
8491 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
8492 wndclass
.lpfnWndProc
= DefWindowProcA
;
8493 wndclass
.cbClsExtra
= 0;
8494 wndclass
.cbWndExtra
= 0;
8495 wndclass
.hInstance
= GetModuleHandleA(NULL
);
8496 wndclass
.hIcon
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
8497 wndclass
.hIconSm
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
8498 wndclass
.hCursor
= LoadCursorA(NULL
, (LPCSTR
)IDC_ARROW
);
8499 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
8500 wndclass
.lpszClassName
= class_name
;
8501 wndclass
.lpszMenuName
= NULL
;
8503 RegisterClassExA(&wndclass
);
8505 hWnd
= CreateWindowA(class_name
, "ws2_32 async message window", WS_OVERLAPPEDWINDOW
,
8506 0, 0, 500, 500, NULL
, NULL
, GetModuleHandleA(NULL
), NULL
);
8509 ok(0, "failed to create window: %u\n", GetLastError());
8516 static void test_WSAAsyncGetServByPort(void)
8518 HWND hwnd
= create_async_message_window();
8520 char buffer
[MAXGETHOSTSTRUCT
];
8525 /* FIXME: The asynchronous window messages should be tested. */
8527 /* Parameters are not checked when initiating the asynchronous operation. */
8528 ret
= WSAAsyncGetServByPort(NULL
, 0, 0, NULL
, NULL
, 0);
8529 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
8531 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, 0, NULL
, NULL
, 0);
8532 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
8534 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, htons(80), NULL
, NULL
, 0);
8535 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
8537 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, htons(80), NULL
, buffer
, MAXGETHOSTSTRUCT
);
8538 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
8540 DestroyWindow(hwnd
);
8543 static void test_WSAAsyncGetServByName(void)
8545 HWND hwnd
= create_async_message_window();
8547 char buffer
[MAXGETHOSTSTRUCT
];
8552 /* FIXME: The asynchronous window messages should be tested. */
8554 /* Parameters are not checked when initiating the asynchronous operation. */
8555 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "", NULL
, NULL
, 0);
8556 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
8558 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "", "", buffer
, MAXGETHOSTSTRUCT
);
8559 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
8561 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "http", NULL
, NULL
, 0);
8562 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
8564 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "http", "tcp", buffer
, MAXGETHOSTSTRUCT
);
8565 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
8567 DestroyWindow(hwnd
);
8571 * Provide consistent initialization for the AcceptEx IOCP tests.
8573 static SOCKET
setup_iocp_src(struct sockaddr_in
*bindAddress
)
8575 SOCKET src
, ret
= INVALID_SOCKET
;
8578 src
= socket(AF_INET
, SOCK_STREAM
, 0);
8579 if (src
== INVALID_SOCKET
)
8581 skip("could not create listener socket, error %d\n", WSAGetLastError());
8585 memset(bindAddress
, 0, sizeof(*bindAddress
));
8586 bindAddress
->sin_family
= AF_INET
;
8587 bindAddress
->sin_addr
.s_addr
= inet_addr("127.0.0.1");
8588 iret
= bind(src
, (struct sockaddr
*)bindAddress
, sizeof(*bindAddress
));
8591 skip("failed to bind, error %d\n", WSAGetLastError());
8595 socklen
= sizeof(*bindAddress
);
8596 iret
= getsockname(src
, (struct sockaddr
*)bindAddress
, &socklen
);
8598 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
8602 if (set_blocking(src
, FALSE
))
8604 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
8608 iret
= listen(src
, 5);
8611 skip("listening failed, errno = %d\n", WSAGetLastError());
8617 if (src
!= ret
&& ret
== INVALID_SOCKET
)
8622 static void test_completion_port(void)
8624 HANDLE previous_port
, io_port
;
8625 WSAOVERLAPPED ov
, *olp
;
8626 SOCKET src
, dest
, dup
, connector
= INVALID_SOCKET
;
8627 WSAPROTOCOL_INFOA info
;
8630 DWORD num_bytes
, flags
;
8635 struct sockaddr_in bindAddress
;
8636 GUID acceptExGuid
= WSAID_ACCEPTEX
;
8637 LPFN_ACCEPTEX pAcceptEx
= NULL
;
8639 memset(buf
, 0, sizeof(buf
));
8640 previous_port
= CreateIoCompletionPort(INVALID_HANDLE_VALUE
, NULL
, 0, 0);
8641 ok( previous_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
8643 memset(&ov
, 0, sizeof(ov
));
8645 tcp_socketpair(&src
, &dest
);
8646 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
8648 skip("failed to create sockets\n");
8652 bufs
.len
= sizeof(buf
);
8658 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
8659 ok(!iret
, "Failed to set linger %d\n", GetLastError());
8661 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, previous_port
, 125, 0 );
8662 ok(io_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
8664 SetLastError(0xdeadbeef);
8666 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
8667 ok(iret
== SOCKET_ERROR
, "WSARecv returned %d\n", iret
);
8668 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8673 src
= INVALID_SOCKET
;
8675 SetLastError(0xdeadbeef);
8677 num_bytes
= 0xdeadbeef;
8678 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8680 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8681 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
8682 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
, "Last error was %d\n", GetLastError());
8683 ok(key
== 125, "Key is %lu\n", key
);
8684 ok(num_bytes
== 0, "Number of bytes received is %u\n", num_bytes
);
8685 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8687 SetLastError(0xdeadbeef);
8689 num_bytes
= 0xdeadbeef;
8690 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8692 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8693 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
8694 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8695 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8696 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8697 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8699 if (dest
!= INVALID_SOCKET
)
8702 memset(&ov
, 0, sizeof(ov
));
8704 tcp_socketpair(&src
, &dest
);
8705 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
8707 skip("failed to create sockets\n");
8711 bufs
.len
= sizeof(buf
);
8717 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
8718 ok(!iret
, "Failed to set linger %d\n", GetLastError());
8720 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 125, 0);
8721 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8723 set_blocking(dest
, FALSE
);
8726 src
= INVALID_SOCKET
;
8730 num_bytes
= 0xdeadbeef;
8731 SetLastError(0xdeadbeef);
8733 iret
= WSASend(dest
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
8734 ok(iret
== SOCKET_ERROR
, "WSASend failed - %d\n", iret
);
8735 ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
8736 ok(num_bytes
== 0xdeadbeef, "Managed to send %d\n", num_bytes
);
8738 SetLastError(0xdeadbeef);
8740 num_bytes
= 0xdeadbeef;
8741 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8743 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8744 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
8745 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8746 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8747 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8748 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8750 if (dest
!= INVALID_SOCKET
)
8753 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
8754 if (dest
== INVALID_SOCKET
)
8756 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
8760 iret
= WSAIoctl(dest
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
8761 &pAcceptEx
, sizeof(pAcceptEx
), &num_bytes
, NULL
, NULL
);
8764 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret
, WSAGetLastError());
8768 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
8770 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
8773 SetLastError(0xdeadbeef);
8775 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8776 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8778 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8779 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8781 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
8782 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8785 src
= INVALID_SOCKET
;
8787 SetLastError(0xdeadbeef);
8789 num_bytes
= 0xdeadbeef;
8790 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8792 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8793 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8794 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8795 ok(key
== 125, "Key is %lu\n", key
);
8796 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8797 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8798 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8800 SetLastError(0xdeadbeef);
8802 num_bytes
= 0xdeadbeef;
8803 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8804 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8805 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8806 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8807 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8808 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8809 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8811 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
8813 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
8816 SetLastError(0xdeadbeef);
8818 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
8819 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8821 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8822 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8824 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8825 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8828 src
= INVALID_SOCKET
;
8830 SetLastError(0xdeadbeef);
8832 num_bytes
= 0xdeadbeef;
8833 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8835 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8836 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8837 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8838 ok(key
== 125, "Key is %lu\n", key
);
8839 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8840 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8841 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8843 SetLastError(0xdeadbeef);
8845 num_bytes
= 0xdeadbeef;
8846 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8847 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8848 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8849 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8850 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8851 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8852 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8854 /* Test IOCP with duplicated handle */
8856 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
8859 SetLastError(0xdeadbeef);
8861 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
8862 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8864 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
8865 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
8866 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
8868 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8869 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8871 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8872 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8874 SetLastError(0xdeadbeef);
8876 num_bytes
= 0xdeadbeef;
8877 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8878 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8879 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8880 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8881 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8882 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8883 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8886 src
= INVALID_SOCKET
;
8888 dup
= INVALID_SOCKET
;
8890 SetLastError(0xdeadbeef);
8892 num_bytes
= 0xdeadbeef;
8893 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8894 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8895 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8896 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8897 ok(key
== 125, "Key is %lu\n", key
);
8898 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8899 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8900 ok(olp
&& olp
->Internal
== (ULONG
)STATUS_CANCELLED
, "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8902 SetLastError(0xdeadbeef);
8904 num_bytes
= 0xdeadbeef;
8905 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8906 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8907 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8908 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8909 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8910 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8911 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8913 /* Test IOCP with duplicated handle (closing duplicated handle) */
8915 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
8918 SetLastError(0xdeadbeef);
8920 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
8921 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8923 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
8924 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
8925 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
8927 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8928 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8930 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8931 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
8934 dup
= INVALID_SOCKET
;
8936 SetLastError(0xdeadbeef);
8938 num_bytes
= 0xdeadbeef;
8939 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8940 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8941 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8942 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8943 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8944 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8945 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8947 SetLastError(0xdeadbeef);
8949 num_bytes
= 0xdeadbeef;
8950 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8951 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8952 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8953 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8954 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8955 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8956 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8959 src
= INVALID_SOCKET
;
8961 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
8962 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8963 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
8964 ok(key
== 125, "Key is %lu\n", key
);
8965 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
8966 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
8967 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
8969 SetLastError(0xdeadbeef);
8971 num_bytes
= 0xdeadbeef;
8972 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
8973 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
8974 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
8975 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
8976 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
8977 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
8978 ok(!olp
, "Overlapped structure is at %p\n", olp
);
8980 /* Test IOCP with duplicated handle (closing original handle) */
8982 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
8985 SetLastError(0xdeadbeef);
8987 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
8988 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
8990 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
8991 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
8992 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
8994 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
8995 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
8997 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
8998 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9001 src
= INVALID_SOCKET
;
9003 SetLastError(0xdeadbeef);
9005 num_bytes
= 0xdeadbeef;
9006 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9007 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9008 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9009 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9010 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9011 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9012 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9015 dup
= INVALID_SOCKET
;
9017 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9018 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9019 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
9020 ok(key
== 125, "Key is %lu\n", key
);
9021 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9022 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9023 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9025 SetLastError(0xdeadbeef);
9027 num_bytes
= 0xdeadbeef;
9028 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9029 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9030 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9031 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9032 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9033 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9034 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9036 /* Test IOCP without AcceptEx */
9038 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9041 SetLastError(0xdeadbeef);
9043 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9044 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9047 src
= INVALID_SOCKET
;
9049 SetLastError(0xdeadbeef);
9051 num_bytes
= 0xdeadbeef;
9052 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9053 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9054 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9055 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9056 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9057 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9058 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9062 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9065 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
9066 if (connector
== INVALID_SOCKET
) {
9067 skip("could not create connector socket, error %d\n", WSAGetLastError());
9071 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9072 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9074 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
9075 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9077 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9078 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9080 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9081 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9083 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9084 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9086 closesocket(connector
);
9087 connector
= INVALID_SOCKET
;
9089 SetLastError(0xdeadbeef);
9091 num_bytes
= 0xdeadbeef;
9092 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9094 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9095 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
9096 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9097 ok(key
== 125, "Key is %lu\n", key
);
9098 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9099 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9100 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9102 SetLastError(0xdeadbeef);
9104 num_bytes
= 0xdeadbeef;
9105 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9106 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9107 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9108 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9109 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9110 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9111 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9113 if (dest
!= INVALID_SOCKET
)
9115 if (src
!= INVALID_SOCKET
)
9120 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9123 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
9124 if (dest
== INVALID_SOCKET
)
9126 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
9130 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
9131 if (connector
== INVALID_SOCKET
) {
9132 skip("could not create connector socket, error %d\n", WSAGetLastError());
9136 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9137 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9139 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
9140 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9142 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9143 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9145 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9146 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9148 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9149 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9151 iret
= send(connector
, buf
, 1, 0);
9152 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
9157 dest
= INVALID_SOCKET
;
9159 SetLastError(0xdeadbeef);
9161 num_bytes
= 0xdeadbeef;
9162 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9164 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9165 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
9166 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
9167 ok(key
== 125, "Key is %lu\n", key
);
9168 ok(num_bytes
== 1, "Number of bytes transferred is %u\n", num_bytes
);
9169 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9170 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9172 SetLastError(0xdeadbeef);
9174 num_bytes
= 0xdeadbeef;
9175 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9176 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9177 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9178 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9179 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9180 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9181 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9183 if (src
!= INVALID_SOCKET
)
9185 if (connector
!= INVALID_SOCKET
)
9186 closesocket(connector
);
9190 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
9193 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
9194 if (dest
== INVALID_SOCKET
)
9196 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
9200 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
9201 if (connector
== INVALID_SOCKET
) {
9202 skip("could not create connector socket, error %d\n", WSAGetLastError());
9206 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
9207 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9209 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
9210 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
9212 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
9213 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
9215 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
9216 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
9218 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
9219 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
9222 dest
= INVALID_SOCKET
;
9224 SetLastError(0xdeadbeef);
9226 num_bytes
= 0xdeadbeef;
9227 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9229 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
9230 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9231 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
||
9232 GetLastError() == ERROR_OPERATION_ABORTED
||
9233 GetLastError() == ERROR_CONNECTION_ABORTED
||
9234 GetLastError() == ERROR_PIPE_NOT_CONNECTED
/* win 2000 */,
9235 "Last error was %d\n", GetLastError());
9236 ok(key
== 125, "Key is %lu\n", key
);
9237 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
9238 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
9239 todo_wine
ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
||
9240 olp
->Internal
== (ULONG
)STATUS_CANCELLED
||
9241 olp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
||
9242 olp
->Internal
== (ULONG
)STATUS_PIPE_DISCONNECTED
/* win 2000 */),
9243 "Internal status is %lx\n", olp
? olp
->Internal
: 0);
9245 SetLastError(0xdeadbeef);
9247 num_bytes
= 0xdeadbeef;
9248 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
9249 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
9250 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
9251 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
9252 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
9253 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
9254 ok(!olp
, "Overlapped structure is at %p\n", olp
);
9258 if (dest
!= INVALID_SOCKET
)
9260 if (src
!= INVALID_SOCKET
)
9262 if (connector
!= INVALID_SOCKET
)
9263 closesocket(connector
);
9264 CloseHandle(previous_port
);
9267 static void test_address_list_query(void)
9269 SOCKET_ADDRESS_LIST
*address_list
;
9270 DWORD bytes_returned
, size
;
9275 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
9276 ok(s
!= INVALID_SOCKET
, "Failed to create socket, error %d.\n", WSAGetLastError());
9279 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, 0, &bytes_returned
, NULL
, NULL
);
9280 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9281 if(WSAGetLastError() == WSAEINVAL
)
9283 win_skip("Windows <= NT4 is not supported in this test\n");
9287 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9288 ok(bytes_returned
>= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]),
9289 "Got unexpected bytes_returned %u.\n", bytes_returned
);
9291 size
= bytes_returned
;
9293 address_list
= HeapAlloc(GetProcessHeap(), 0, size
* 2);
9294 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
, size
* 2, &bytes_returned
, NULL
, NULL
);
9295 ok(!ret
, "Got unexpected ret %d, error %d.\n", ret
, WSAGetLastError());
9296 ok(bytes_returned
== size
, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned
, size
);
9298 bytes_returned
= FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[address_list
->iAddressCount
]);
9299 for (i
= 0; i
< address_list
->iAddressCount
; ++i
)
9301 bytes_returned
+= address_list
->Address
[i
].iSockaddrLength
;
9303 ok(size
== bytes_returned
, "Got unexpected size %u, expected %u.\n", size
, bytes_returned
);
9305 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
, size
, NULL
, NULL
, NULL
);
9306 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9307 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9309 bytes_returned
= 0xdeadbeef;
9310 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, NULL
, size
, &bytes_returned
, NULL
, NULL
);
9311 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9312 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9313 ok(bytes_returned
== size
, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned
, size
);
9315 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
, 1, &bytes_returned
, NULL
, NULL
);
9316 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9317 ok(WSAGetLastError() == WSAEINVAL
, "Got unexpected error %d.\n", WSAGetLastError());
9318 ok(bytes_returned
== 0, "Got unexpected bytes_returned %u.\n", bytes_returned
);
9320 ret
= WSAIoctl(s
, SIO_ADDRESS_LIST_QUERY
, NULL
, 0, address_list
,
9321 FIELD_OFFSET(SOCKET_ADDRESS_LIST
, Address
[0]), &bytes_returned
, NULL
, NULL
);
9322 ok(ret
== SOCKET_ERROR
, "Got unexpected ret %d.\n", ret
);
9323 ok(WSAGetLastError() == WSAEFAULT
, "Got unexpected error %d.\n", WSAGetLastError());
9324 ok(bytes_returned
== size
, "Got unexpected bytes_returned %u, expected %u.\n", bytes_returned
, size
);
9326 HeapFree(GetProcessHeap(), 0, address_list
);
9330 static DWORD WINAPI
inet_ntoa_thread_proc(void *param
)
9334 HANDLE
*event
= param
;
9336 addr
= inet_addr("4.3.2.1");
9337 ok(addr
== htonl(0x04030201), "expected 0x04030201, got %08x\n", addr
);
9338 str
= inet_ntoa(*(struct in_addr
*)&addr
);
9339 ok(!strcmp(str
, "4.3.2.1"), "expected 4.3.2.1, got %s\n", str
);
9342 WaitForSingleObject(event
[1], 3000);
9347 static void test_inet_ntoa(void)
9351 HANDLE thread
, event
[2];
9354 addr
= inet_addr("1.2.3.4");
9355 ok(addr
== htonl(0x01020304), "expected 0x01020304, got %08x\n", addr
);
9356 str
= inet_ntoa(*(struct in_addr
*)&addr
);
9357 ok(!strcmp(str
, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str
);
9359 event
[0] = CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
9360 event
[1] = CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
9362 thread
= CreateThread(NULL
, 0, inet_ntoa_thread_proc
, event
, 0, &tid
);
9363 WaitForSingleObject(event
[0], 3000);
9365 ok(!strcmp(str
, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str
);
9368 WaitForSingleObject(thread
, 3000);
9370 CloseHandle(event
[0]);
9371 CloseHandle(event
[1]);
9372 CloseHandle(thread
);
9375 static void test_WSALookupService(void)
9377 char buffer
[4096], strbuff
[128];
9378 WSAQUERYSETW
*qs
= NULL
;
9382 DWORD error
, offset
, bsize
;
9384 if (!pWSALookupServiceBeginW
|| !pWSALookupServiceEnd
|| !pWSALookupServiceNextW
)
9386 win_skip("WSALookupServiceBeginW or WSALookupServiceEnd or WSALookupServiceNextW not found\n");
9390 qs
= (WSAQUERYSETW
*)buffer
;
9391 memset(qs
, 0, sizeof(*qs
));
9393 /* invalid parameter tests */
9394 ret
= pWSALookupServiceBeginW(NULL
, 0, &hnd
);
9395 error
= WSAGetLastError();
9396 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
9398 ok(error
== WSAEFAULT
, "expected 10014, got %d\n", error
);
9400 ret
= pWSALookupServiceBeginW(qs
, 0, NULL
);
9401 error
= WSAGetLastError();
9402 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
9404 ok(error
== WSAEFAULT
, "expected 10014, got %d\n", error
);
9406 ret
= pWSALookupServiceBeginW(qs
, 0, &hnd
);
9407 error
= WSAGetLastError();
9408 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
9410 ok(error
== WSAEINVAL
9411 || broken(error
== ERROR_INVALID_PARAMETER
) /* == XP */
9412 || broken(error
== WSAEFAULT
) /* == NT */
9413 || broken(error
== WSASERVICE_NOT_FOUND
) /* == 2000 */,
9414 "expected 10022, got %d\n", error
);
9416 ret
= pWSALookupServiceEnd(NULL
);
9417 error
= WSAGetLastError();
9419 ok(ret
== SOCKET_ERROR
, "WSALookupServiceEnd should have failed\n");
9421 ok(error
== ERROR_INVALID_HANDLE
, "expected 6, got %d\n", error
);
9423 /* standard network list query */
9424 qs
->dwSize
= sizeof(*qs
);
9425 hnd
= (HANDLE
)0xdeadbeef;
9426 ret
= pWSALookupServiceBeginW(qs
, LUP_RETURN_ALL
| LUP_DEEP
, &hnd
);
9427 error
= WSAGetLastError();
9428 if(ret
&& error
== ERROR_INVALID_PARAMETER
)
9430 win_skip("the current WSALookupServiceBeginW test is not supported in win <= 2000\n");
9435 ok(!ret
, "WSALookupServiceBeginW failed unexpectedly with error %d\n", error
);
9437 ok(hnd
!= (HANDLE
)0xdeadbeef, "Handle was not filled\n");
9442 memset(qs
, 0, sizeof(*qs
));
9443 bsize
= sizeof(buffer
);
9445 if (pWSALookupServiceNextW(hnd
, 0, &bsize
, qs
) == SOCKET_ERROR
)
9447 error
= WSAGetLastError();
9448 if (error
== WSA_E_NO_MORE
) break;
9449 ok(0, "Error %d happened while listing services\n", error
);
9453 WideCharToMultiByte(CP_ACP
, 0, qs
->lpszServiceInstanceName
, -1,
9454 strbuff
, sizeof(strbuff
), NULL
, NULL
);
9455 trace("Network Name: %s\n", strbuff
);
9457 /* network data is written in the blob field */
9460 /* each network may have multiple NLA_BLOB information structures */
9463 netdata
= (PNLA_BLOB
) &qs
->lpBlob
->pBlobData
[offset
];
9464 switch (netdata
->header
.type
)
9467 trace("\tNLA Data Type: NLA_RAW_DATA\n");
9470 trace("\tNLA Data Type: NLA_INTERFACE\n");
9471 trace("\t\tType: %d\n", netdata
->data
.interfaceData
.dwType
);
9472 trace("\t\tSpeed: %d\n", netdata
->data
.interfaceData
.dwSpeed
);
9473 trace("\t\tAdapter Name: %s\n", netdata
->data
.interfaceData
.adapterName
);
9475 case NLA_802_1X_LOCATION
:
9476 trace("\tNLA Data Type: NLA_802_1X_LOCATION\n");
9477 trace("\t\tInformation: %s\n", netdata
->data
.locationData
.information
);
9479 case NLA_CONNECTIVITY
:
9480 switch (netdata
->data
.connectivity
.type
)
9482 case NLA_NETWORK_AD_HOC
:
9483 trace("\t\tNetwork Type: AD HOC\n");
9485 case NLA_NETWORK_MANAGED
:
9486 trace("\t\tNetwork Type: Managed\n");
9488 case NLA_NETWORK_UNMANAGED
:
9489 trace("\t\tNetwork Type: Unmanaged\n");
9491 case NLA_NETWORK_UNKNOWN
:
9492 trace("\t\tNetwork Type: Unknown\n");
9494 switch (netdata
->data
.connectivity
.internet
)
9496 case NLA_INTERNET_NO
:
9497 trace("\t\tInternet connectivity: No\n");
9499 case NLA_INTERNET_YES
:
9500 trace("\t\tInternet connectivity: Yes\n");
9502 case NLA_INTERNET_UNKNOWN
:
9503 trace("\t\tInternet connectivity: Unknown\n");
9508 trace("\tNLA Data Type: NLA_ICS\n");
9509 trace("\t\tSpeed: %d\n",
9510 netdata
->data
.ICS
.remote
.speed
);
9511 trace("\t\tType: %d\n",
9512 netdata
->data
.ICS
.remote
.type
);
9513 trace("\t\tState: %d\n",
9514 netdata
->data
.ICS
.remote
.state
);
9515 WideCharToMultiByte(CP_ACP
, 0, netdata
->data
.ICS
.remote
.machineName
, -1,
9516 strbuff
, sizeof(strbuff
), NULL
, NULL
);
9517 trace("\t\tMachine Name: %s\n", strbuff
);
9518 WideCharToMultiByte(CP_ACP
, 0, netdata
->data
.ICS
.remote
.sharedAdapterName
, -1,
9519 strbuff
, sizeof(strbuff
), NULL
, NULL
);
9520 trace("\t\tShared Adapter Name: %s\n", strbuff
);
9523 trace("\tNLA Data Type: Unknown\n");
9532 ret
= pWSALookupServiceEnd(hnd
);
9533 ok(!ret
, "WSALookupServiceEnd failed unexpectedly\n");
9536 static void test_WSAEnumNameSpaceProvidersA(void)
9538 LPWSANAMESPACE_INFOA name
= NULL
;
9539 DWORD ret
, error
, blen
= 0, i
;
9540 if (!pWSAEnumNameSpaceProvidersA
)
9542 win_skip("WSAEnumNameSpaceProvidersA not found\n");
9546 SetLastError(0xdeadbeef);
9547 ret
= pWSAEnumNameSpaceProvidersA(&blen
, name
);
9548 error
= WSAGetLastError();
9550 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
9552 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
9554 /* Invalid parameter tests */
9555 SetLastError(0xdeadbeef);
9556 ret
= pWSAEnumNameSpaceProvidersA(NULL
, name
);
9557 error
= WSAGetLastError();
9559 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
9561 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
9563 SetLastError(0xdeadbeef);
9564 ret
= pWSAEnumNameSpaceProvidersA(NULL
, NULL
);
9565 error
= WSAGetLastError();
9567 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
9569 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
9571 SetLastError(0xdeadbeef);
9572 ret
= pWSAEnumNameSpaceProvidersA(&blen
, NULL
);
9573 error
= WSAGetLastError();
9575 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
9577 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
9579 #ifdef __REACTOS__ /* ROSTESTS-233 */
9582 skip("Failed to get length needed for name space providers.\n");
9587 name
= HeapAlloc(GetProcessHeap(), 0, blen
);
9590 skip("Failed to alloc memory\n");
9594 ret
= pWSAEnumNameSpaceProvidersA(&blen
, name
);
9596 ok(ret
> 0, "Expected more than zero name space providers\n");
9598 for (i
= 0;i
< ret
; i
++)
9600 trace("Name space Identifier (%p): %s\n", name
[i
].lpszIdentifier
,
9601 name
[i
].lpszIdentifier
);
9602 switch (name
[i
].dwNameSpace
)
9605 trace("\tName space ID: NS_DNS (%u)\n", name
[i
].dwNameSpace
);
9608 trace("\tName space ID: NS_NLA (%u)\n", name
[i
].dwNameSpace
);
9611 trace("\tName space ID: Unknown (%u)\n", name
[i
].dwNameSpace
);
9614 trace("\tActive: %d\n", name
[i
].fActive
);
9615 trace("\tVersion: %d\n", name
[i
].dwVersion
);
9618 HeapFree(GetProcessHeap(), 0, name
);
9621 static void test_WSAEnumNameSpaceProvidersW(void)
9623 LPWSANAMESPACE_INFOW name
= NULL
;
9624 DWORD ret
, error
, blen
= 0, i
;
9625 if (!pWSAEnumNameSpaceProvidersW
)
9627 win_skip("WSAEnumNameSpaceProvidersW not found\n");
9631 SetLastError(0xdeadbeef);
9632 ret
= pWSAEnumNameSpaceProvidersW(&blen
, name
);
9633 error
= WSAGetLastError();
9635 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
9637 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
9639 /* Invalid parameter tests */
9640 SetLastError(0xdeadbeef);
9641 ret
= pWSAEnumNameSpaceProvidersW(NULL
, name
);
9642 error
= WSAGetLastError();
9644 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
9646 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
9648 SetLastError(0xdeadbeef);
9649 ret
= pWSAEnumNameSpaceProvidersW(NULL
, NULL
);
9650 error
= WSAGetLastError();
9652 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
9654 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
9656 SetLastError(0xdeadbeef);
9657 ret
= pWSAEnumNameSpaceProvidersW(&blen
, NULL
);
9658 error
= WSAGetLastError();
9660 ok(ret
== SOCKET_ERROR
, "Expected failure, got %u\n", ret
);
9662 ok(error
== WSAEFAULT
, "Expected 10014, got %u\n", error
);
9664 #ifdef __REACTOS__ /* ROSTESTS-233 */
9667 skip("Failed to get length needed for name space providers.\n");
9672 name
= HeapAlloc(GetProcessHeap(), 0, blen
);
9675 skip("Failed to alloc memory\n");
9679 ret
= pWSAEnumNameSpaceProvidersW(&blen
, name
);
9681 ok(ret
> 0, "Expected more than zero name space providers\n");
9683 for (i
= 0;i
< ret
; i
++)
9685 trace("Name space Identifier (%p): %s\n", name
[i
].lpszIdentifier
,
9686 wine_dbgstr_w(name
[i
].lpszIdentifier
));
9687 switch (name
[i
].dwNameSpace
)
9690 trace("\tName space ID: NS_DNS (%u)\n", name
[i
].dwNameSpace
);
9693 trace("\tName space ID: NS_NLA (%u)\n", name
[i
].dwNameSpace
);
9696 trace("\tName space ID: Unknown (%u)\n", name
[i
].dwNameSpace
);
9699 trace("\tActive: %d\n", name
[i
].fActive
);
9700 trace("\tVersion: %d\n", name
[i
].dwVersion
);
9703 HeapFree(GetProcessHeap(), 0, name
);
9706 /**************** Main program ***************/
9712 /* Leave these tests at the beginning. They depend on WSAStartup not having been
9713 * called, which is done by Init() below. */
9714 test_WithoutWSAStartup();
9715 test_WithWSAStartup();
9721 test_set_getsockopt();
9722 test_so_reuseaddr();
9724 test_extendedSocketOptions();
9726 for (i
= 0; i
< sizeof(tests
)/sizeof(tests
[0]); i
++)
9728 trace ( " **** STARTING TEST %d ****\n", i
);
9729 do_test ( &tests
[i
] );
9730 trace ( " **** TEST %d COMPLETE ****\n", i
);
9735 test_getservbyname();
9737 test_WSADuplicateSocket();
9738 test_WSAEnumNetworkEvents();
9740 test_WSAAddressToStringA();
9741 test_WSAAddressToStringW();
9743 test_WSAStringToAddressA();
9744 test_WSAStringToAddressW();
9753 test_addr_to_print();
9756 test_gethostbyname();
9757 test_gethostbyname_hack();
9769 test_TransmitFile();
9770 test_GetAddrInfoW();
9774 test_DisconnectEx();
9776 test_sioRoutingInterfaceQuery();
9777 test_sioAddressListChange();
9779 test_WSALookupService();
9780 test_WSAEnumNameSpaceProvidersA();
9781 test_WSAEnumNameSpaceProvidersW();
9783 test_WSAAsyncGetServByPort();
9784 test_WSAAsyncGetServByName();
9786 test_completion_port();
9787 test_address_list_query();
9789 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
9791 test_synchronous_WSAIoctl();