2 * Unit test suite for winsock functions
4 * Copyright 2002 Martin Wilck
5 * Copyright 2005 Thomas Kho
6 * Copyright 2008 Jeff Zaroyko
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #define WIN32_NO_STATUS
34 #include "wine/test.h"
36 #define MAX_CLIENTS 4 /* Max number of clients */
37 #define FIRST_CHAR 'A' /* First character in transferred pattern */
38 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
39 #define BIND_TRIES 6 /* Number of bind() attempts */
40 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
41 after server initialization, if something hangs */
43 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
45 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
46 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
48 #define SERVERIP "127.0.0.1" /* IP to bind to */
49 #define SERVERPORT 9374 /* Port number to bind to */
51 #define wsa_ok(op, cond, msg) \
55 if ( !(cond tmp) ) err = WSAGetLastError(); \
56 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
59 #define make_keepalive(k, enable, time, interval) \
61 k.keepalivetime = time; \
62 k.keepaliveinterval = interval;
64 /* Function pointers */
65 static void (WINAPI
*pfreeaddrinfo
)(struct addrinfo
*);
66 static int (WINAPI
*pgetaddrinfo
)(LPCSTR
,LPCSTR
,const struct addrinfo
*,struct addrinfo
**);
67 static void (WINAPI
*pFreeAddrInfoW
)(PADDRINFOW
);
68 static int (WINAPI
*pGetAddrInfoW
)(LPCWSTR
,LPCWSTR
,const ADDRINFOW
*,PADDRINFOW
*);
69 static PCSTR (WINAPI
*pInetNtop
)(INT
,LPVOID
,LPSTR
,ULONG
);
70 static int (WINAPI
*pWSALookupServiceBeginW
)(LPWSAQUERYSETW
,DWORD
,LPHANDLE
);
71 static int (WINAPI
*pWSALookupServiceEnd
)(HANDLE
);
72 static int (WINAPI
*pWSALookupServiceNextW
)(HANDLE
,DWORD
,LPDWORD
,LPWSAQUERYSETW
);
74 /**************** Structs and typedefs ***************/
76 typedef struct thread_info
82 /* Information in the server about open client connections */
83 typedef struct sock_info
86 struct sockaddr_in addr
;
87 struct sockaddr_in peer
;
93 /* Test parameters for both server & client */
94 typedef struct test_params
98 const char *inet_addr
;
105 /* server-specific test parameters */
106 typedef struct server_params
108 test_params
*general
;
113 /* client-specific test parameters */
114 typedef struct client_params
116 test_params
*general
;
121 /* This type combines all information for setting up a test scenario */
122 typedef struct test_setup
126 server_params srv_params
;
128 client_params clt_params
;
131 /* Thread local storage for server */
132 typedef struct server_memory
135 struct sockaddr_in addr
;
136 sock_info sock
[MAX_CLIENTS
];
139 /* Thread local storage for client */
140 typedef struct client_memory
143 struct sockaddr_in addr
;
148 /* SelectReadThread thread parameters */
149 typedef struct select_thread_params
153 } select_thread_params
;
155 /* Tests used in both getaddrinfo and GetAddrInfoW */
156 static const struct addr_hint_tests
158 int family
, socktype
, protocol
;
161 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_TCP
, 0 },
162 {AF_UNSPEC
, SOCK_STREAM
, IPPROTO_UDP
, 0 },
163 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_TCP
, 0 },
164 {AF_UNSPEC
, SOCK_DGRAM
, IPPROTO_UDP
, 0 },
165 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, 0 },
166 {AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, 0 },
167 {AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, 0 },
168 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, 0 },
169 {AF_UNSPEC
, 0, IPPROTO_TCP
, 0 },
170 {AF_UNSPEC
, 0, IPPROTO_UDP
, 0 },
171 {AF_UNSPEC
, SOCK_STREAM
, 0, 0 },
172 {AF_UNSPEC
, SOCK_DGRAM
, 0, 0 },
173 {AF_INET
, 0, IPPROTO_TCP
, 0 },
174 {AF_INET
, 0, IPPROTO_UDP
, 0 },
175 {AF_INET
, SOCK_STREAM
, 0, 0 },
176 {AF_INET
, SOCK_DGRAM
, 0, 0 },
177 {AF_UNSPEC
, 999, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
178 {AF_UNSPEC
, 999, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
179 {AF_INET
, 999, IPPROTO_TCP
, WSAESOCKTNOSUPPORT
},
180 {AF_INET
, 999, IPPROTO_UDP
, WSAESOCKTNOSUPPORT
},
181 {AF_UNSPEC
, SOCK_STREAM
, 999, 0 },
182 {AF_UNSPEC
, SOCK_STREAM
, 999, 0 },
183 {AF_INET
, SOCK_DGRAM
, 999, 0 },
184 {AF_INET
, SOCK_DGRAM
, 999, 0 },
187 /**************** Static variables ***************/
189 static DWORD tls
; /* Thread local storage index */
190 static HANDLE thread
[1+MAX_CLIENTS
];
191 static DWORD thread_id
[1+MAX_CLIENTS
];
192 static HANDLE server_ready
;
193 static HANDLE client_ready
[MAX_CLIENTS
];
194 static int client_id
;
196 /**************** General utility functions ***************/
198 static int tcp_socketpair(SOCKET
*src
, SOCKET
*dst
)
200 SOCKET server
= INVALID_SOCKET
;
201 struct sockaddr_in addr
;
205 *src
= INVALID_SOCKET
;
206 *dst
= INVALID_SOCKET
;
208 *src
= socket(AF_INET
, SOCK_STREAM
, 0);
209 if (*src
== INVALID_SOCKET
)
212 server
= socket(AF_INET
, SOCK_STREAM
, 0);
213 if (server
== INVALID_SOCKET
)
216 memset(&addr
, 0, sizeof(addr
));
217 addr
.sin_family
= AF_INET
;
218 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
219 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
224 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
228 ret
= listen(server
, 1);
232 ret
= connect(*src
, (struct sockaddr
*)&addr
, sizeof(addr
));
237 *dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
240 if (server
!= INVALID_SOCKET
)
242 if (*src
!= INVALID_SOCKET
&& *dst
!= INVALID_SOCKET
)
249 static void set_so_opentype ( BOOL overlapped
)
251 int optval
= !overlapped
, newval
, len
= sizeof (int);
253 ok ( setsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
254 (LPVOID
) &optval
, sizeof (optval
) ) == 0,
255 "setting SO_OPENTYPE failed\n" );
256 ok ( getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
,
257 (LPVOID
) &newval
, &len
) == 0,
258 "getting SO_OPENTYPE failed\n" );
259 ok ( optval
== newval
, "failed to set SO_OPENTYPE\n" );
262 static int set_blocking ( SOCKET s
, BOOL blocking
)
264 u_long val
= !blocking
;
265 return ioctlsocket ( s
, FIONBIO
, &val
);
268 static void fill_buffer ( char *buf
, int chunk_size
, int n_chunks
)
271 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
272 memset ( p
, c
, chunk_size
);
275 static int test_buffer ( char *buf
, int chunk_size
, int n_chunks
)
279 for ( c
= FIRST_CHAR
, p
= buf
; c
< FIRST_CHAR
+ n_chunks
; c
++, p
+= chunk_size
)
281 for ( i
= 0; i
< chunk_size
; i
++ )
282 if ( p
[i
] != c
) return i
;
288 * This routine is called when a client / server does not expect any more data,
289 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
291 static void read_zero_bytes ( SOCKET s
)
295 while ( ( tmp
= recv ( s
, buf
, 256, 0 ) ) > 0 )
297 ok ( n
<= 0, "garbage data received: %d bytes\n", n
);
300 static int do_synchronous_send ( SOCKET s
, char *buf
, int buflen
, int sendlen
, int flags
)
302 char* last
= buf
+ buflen
, *p
;
304 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
305 n
= send ( s
, p
, min ( sendlen
, last
- p
), flags
);
306 wsa_ok ( n
, 0 <=, "do_synchronous_send (%x): error %d\n" );
310 static int do_synchronous_recv ( SOCKET s
, char *buf
, int buflen
, int recvlen
)
312 char* last
= buf
+ buflen
, *p
;
314 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
315 n
= recv ( s
, p
, min ( recvlen
, last
- p
), 0 );
316 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
320 static int do_synchronous_recvfrom ( SOCKET s
, char *buf
, int buflen
,int flags
,struct sockaddr
*from
, int *fromlen
, int recvlen
)
322 char* last
= buf
+ buflen
, *p
;
324 for ( p
= buf
; n
> 0 && p
< last
; p
+= n
)
325 n
= recvfrom ( s
, p
, min ( recvlen
, last
- p
), 0, from
, fromlen
);
326 wsa_ok ( n
, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
331 * Call this routine right after thread startup.
332 * SO_OPENTYPE must by 0, regardless what the server did.
334 static void check_so_opentype (void)
338 getsockopt ( INVALID_SOCKET
, SOL_SOCKET
, SO_OPENTYPE
, (LPVOID
) &tmp
, &len
);
339 ok ( tmp
== 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp
);
342 static void compare_addrinfo (ADDRINFO
*a
, ADDRINFO
*b
)
344 for (; a
&& b
; a
= a
->ai_next
, b
= b
->ai_next
)
346 ok(a
->ai_flags
== b
->ai_flags
,
347 "Wrong flags %d != %d\n", a
->ai_flags
, b
->ai_flags
);
348 ok(a
->ai_family
== b
->ai_family
,
349 "Wrong family %d != %d\n", a
->ai_family
, b
->ai_family
);
350 ok(a
->ai_socktype
== b
->ai_socktype
,
351 "Wrong socktype %d != %d\n", a
->ai_socktype
, b
->ai_socktype
);
352 ok(a
->ai_protocol
== b
->ai_protocol
,
353 "Wrong protocol %d != %d\n", a
->ai_protocol
, b
->ai_protocol
);
354 ok(a
->ai_addrlen
== b
->ai_addrlen
,
355 "Wrong addrlen %lu != %lu\n", a
->ai_addrlen
, b
->ai_addrlen
);
356 ok(!memcmp(a
->ai_addr
, b
->ai_addr
, min(a
->ai_addrlen
, b
->ai_addrlen
)),
357 "Wrong address data\n");
358 if (a
->ai_canonname
&& b
->ai_canonname
)
360 ok(!strcmp(a
->ai_canonname
, b
->ai_canonname
), "Wrong canonical name '%s' != '%s'\n",
361 a
->ai_canonname
, b
->ai_canonname
);
364 ok(!a
->ai_canonname
&& !b
->ai_canonname
, "Expected both names absent (%p != %p)\n",
365 a
->ai_canonname
, b
->ai_canonname
);
367 ok(!a
&& !b
, "Expected both addresses null (%p != %p)\n", a
, b
);
370 static void compare_addrinfow (ADDRINFOW
*a
, ADDRINFOW
*b
)
372 for (; a
&& b
; a
= a
->ai_next
, b
= b
->ai_next
)
374 ok(a
->ai_flags
== b
->ai_flags
,
375 "Wrong flags %d != %d\n", a
->ai_flags
, b
->ai_flags
);
376 ok(a
->ai_family
== b
->ai_family
,
377 "Wrong family %d != %d\n", a
->ai_family
, b
->ai_family
);
378 ok(a
->ai_socktype
== b
->ai_socktype
,
379 "Wrong socktype %d != %d\n", a
->ai_socktype
, b
->ai_socktype
);
380 ok(a
->ai_protocol
== b
->ai_protocol
,
381 "Wrong protocol %d != %d\n", a
->ai_protocol
, b
->ai_protocol
);
382 ok(a
->ai_addrlen
== b
->ai_addrlen
,
383 "Wrong addrlen %lu != %lu\n", a
->ai_addrlen
, b
->ai_addrlen
);
384 ok(!memcmp(a
->ai_addr
, b
->ai_addr
, min(a
->ai_addrlen
, b
->ai_addrlen
)),
385 "Wrong address data\n");
386 if (a
->ai_canonname
&& b
->ai_canonname
)
388 ok(!lstrcmpW(a
->ai_canonname
, b
->ai_canonname
), "Wrong canonical name '%s' != '%s'\n",
389 wine_dbgstr_w(a
->ai_canonname
), wine_dbgstr_w(b
->ai_canonname
));
392 ok(!a
->ai_canonname
&& !b
->ai_canonname
, "Expected both names absent (%p != %p)\n",
393 a
->ai_canonname
, b
->ai_canonname
);
395 ok(!a
&& !b
, "Expected both addresses null (%p != %p)\n", a
, b
);
398 /**************** Server utility functions ***************/
401 * Even if we have closed our server socket cleanly,
402 * the OS may mark the address "in use" for some time -
403 * this happens with native Linux apps, too.
405 static void do_bind ( SOCKET s
, struct sockaddr
* addr
, int addrlen
)
407 int err
, wsaerr
= 0, n_try
= BIND_TRIES
;
409 while ( ( err
= bind ( s
, addr
, addrlen
) ) != 0 &&
410 ( wsaerr
= WSAGetLastError () ) == WSAEADDRINUSE
&&
413 trace ( "address in use, waiting ...\n" );
414 Sleep ( 1000 * BIND_SLEEP
);
416 ok ( err
== 0, "failed to bind: %d\n", wsaerr
);
419 static void server_start ( server_params
*par
)
422 test_params
*gen
= par
->general
;
423 server_memory
*mem
= LocalAlloc ( LPTR
, sizeof ( server_memory
) );
425 TlsSetValue ( tls
, mem
);
426 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
427 NULL
, 0, par
->sock_flags
);
428 ok ( mem
->s
!= INVALID_SOCKET
, "Server: WSASocket failed\n" );
430 mem
->addr
.sin_family
= AF_INET
;
431 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
432 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
434 for (i
= 0; i
< MAX_CLIENTS
; i
++)
436 mem
->sock
[i
].s
= INVALID_SOCKET
;
437 mem
->sock
[i
].buf
= LocalAlloc ( LPTR
, gen
->n_chunks
* gen
->chunk_size
);
438 mem
->sock
[i
].n_recvd
= 0;
439 mem
->sock
[i
].n_sent
= 0;
442 if ( gen
->sock_type
== SOCK_STREAM
)
443 do_bind ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof (mem
->addr
) );
446 static void server_stop (void)
449 server_memory
*mem
= TlsGetValue ( tls
);
451 for (i
= 0; i
< MAX_CLIENTS
; i
++ )
453 LocalFree ( mem
->sock
[i
].buf
);
454 if ( mem
->sock
[i
].s
!= INVALID_SOCKET
)
455 closesocket ( mem
->sock
[i
].s
);
457 ok ( closesocket ( mem
->s
) == 0, "closesocket failed\n" );
459 ExitThread ( GetCurrentThreadId () );
462 /**************** Client utilitiy functions ***************/
464 static void client_start ( client_params
*par
)
466 test_params
*gen
= par
->general
;
467 client_memory
*mem
= LocalAlloc (LPTR
, sizeof (client_memory
));
469 TlsSetValue ( tls
, mem
);
471 WaitForSingleObject ( server_ready
, INFINITE
);
473 mem
->s
= WSASocketA ( AF_INET
, gen
->sock_type
, gen
->sock_prot
,
474 NULL
, 0, par
->sock_flags
);
476 mem
->addr
.sin_family
= AF_INET
;
477 mem
->addr
.sin_addr
.s_addr
= inet_addr ( gen
->inet_addr
);
478 mem
->addr
.sin_port
= htons ( gen
->inet_port
);
480 ok ( mem
->s
!= INVALID_SOCKET
, "Client: WSASocket failed\n" );
482 mem
->send_buf
= LocalAlloc ( LPTR
, 2 * gen
->n_chunks
* gen
->chunk_size
);
483 mem
->recv_buf
= mem
->send_buf
+ gen
->n_chunks
* gen
->chunk_size
;
484 fill_buffer ( mem
->send_buf
, gen
->chunk_size
, gen
->n_chunks
);
486 SetEvent ( client_ready
[client_id
] );
487 /* Wait for the other clients to come up */
488 WaitForMultipleObjects ( min ( gen
->n_clients
, MAX_CLIENTS
), client_ready
, TRUE
, INFINITE
);
491 static void client_stop (void)
493 client_memory
*mem
= TlsGetValue ( tls
);
494 wsa_ok ( closesocket ( mem
->s
), 0 ==, "closesocket error (%x): %d\n" );
495 LocalFree ( mem
->send_buf
);
500 /**************** Servers ***************/
503 * simple_server: A very basic server doing synchronous IO.
505 static VOID WINAPI
simple_server ( server_params
*par
)
507 test_params
*gen
= par
->general
;
509 int pos
, n_recvd
, n_sent
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
510 id
= GetCurrentThreadId();
512 trace ( "simple_server (%x) starting\n", id
);
514 set_so_opentype ( FALSE
); /* non-overlapped */
515 server_start ( par
);
516 mem
= TlsGetValue ( tls
);
518 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
519 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "simple_server (%x): listen failed: %d\n");
521 trace ( "simple_server (%x) ready\n", id
);
522 SetEvent ( server_ready
); /* notify clients */
524 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
526 trace ( "simple_server (%x): waiting for client\n", id
);
528 /* accept a single connection */
529 tmp
= sizeof ( mem
->sock
[0].peer
);
530 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
531 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "simple_server (%x): accept failed: %d\n" );
533 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
534 "simple_server (%x): strange peer address\n", id
);
536 /* Receive data & check it */
537 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
538 ok ( n_recvd
== n_expected
,
539 "simple_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
540 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
541 ok ( pos
== -1, "simple_server (%x): test pattern error: %d\n", id
, pos
);
544 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
, 0 );
545 ok ( n_sent
== n_expected
,
546 "simple_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
549 read_zero_bytes ( mem
->sock
[0].s
);
550 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "simple_server (%x): closesocket error: %d\n" );
551 mem
->sock
[0].s
= INVALID_SOCKET
;
554 trace ( "simple_server (%x) exiting\n", id
);
559 * oob_server: A very basic server receiving out-of-band data.
561 static VOID WINAPI
oob_server ( server_params
*par
)
563 test_params
*gen
= par
->general
;
566 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
,
567 id
= GetCurrentThreadId();
569 trace ( "oob_server (%x) starting\n", id
);
571 set_so_opentype ( FALSE
); /* non-overlapped */
572 server_start ( par
);
573 mem
= TlsGetValue ( tls
);
575 wsa_ok ( set_blocking ( mem
->s
, TRUE
), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
576 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "oob_server (%x): listen failed: %d\n");
578 trace ( "oob_server (%x) ready\n", id
);
579 SetEvent ( server_ready
); /* notify clients */
581 trace ( "oob_server (%x): waiting for client\n", id
);
583 /* accept a single connection */
584 tmp
= sizeof ( mem
->sock
[0].peer
);
585 mem
->sock
[0].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[0].peer
, &tmp
);
586 wsa_ok ( mem
->sock
[0].s
, INVALID_SOCKET
!=, "oob_server (%x): accept failed: %d\n" );
588 ok ( mem
->sock
[0].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
589 "oob_server (%x): strange peer address\n", id
);
591 /* check initial atmark state */
592 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
593 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
595 /* Receive normal data */
596 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
597 ok ( n_recvd
== n_expected
,
598 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
599 pos
= test_buffer ( mem
->sock
[0].buf
, gen
->chunk_size
, gen
->n_chunks
);
600 ok ( pos
== -1, "oob_server (%x): test pattern error: %d\n", id
, pos
);
603 n_sent
= do_synchronous_send ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
, 0 );
604 ok ( n_sent
== n_expected
,
605 "oob_server (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
607 /* check atmark state */
608 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
609 ok ( atmark
== 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id
, atmark
);
611 /* Receive a part of the out-of-band data and check atmark state */
612 n_recvd
= do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, 8, par
->buflen
);
614 "oob_server (%x): received less data than expected: %d of %d\n", id
, n_recvd
, 8 );
617 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
618 todo_wine
ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %i\n", id
, atmark
);
620 /* Receive the rest of the out-of-band data and check atmark state */
621 do_synchronous_recv ( mem
->sock
[0].s
, mem
->sock
[0].buf
, n_expected
, par
->buflen
);
623 ioctlsocket ( mem
->sock
[0].s
, SIOCATMARK
, &atmark
);
624 todo_wine
ok ( atmark
== 0, "oob_server (%x): not at the OOB mark: %i\n", id
, atmark
);
627 wsa_ok ( closesocket ( mem
->sock
[0].s
), 0 ==, "oob_server (%x): closesocket error: %d\n" );
628 mem
->sock
[0].s
= INVALID_SOCKET
;
630 trace ( "oob_server (%x) exiting\n", id
);
635 * select_server: A non-blocking server.
637 static VOID WINAPI
select_server ( server_params
*par
)
639 test_params
*gen
= par
->general
;
641 int n_expected
= gen
->n_chunks
* gen
->chunk_size
, tmp
, i
,
642 id
= GetCurrentThreadId(), n_connections
= 0, n_sent
, n_recvd
,
643 n_set
, delta
, n_ready
;
644 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
645 fd_set fds_recv
, fds_send
, fds_openrecv
, fds_opensend
;
647 trace ( "select_server (%x) starting\n", id
);
649 set_so_opentype ( FALSE
); /* non-overlapped */
650 server_start ( par
);
651 mem
= TlsGetValue ( tls
);
653 wsa_ok ( set_blocking ( mem
->s
, FALSE
), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
654 wsa_ok ( listen ( mem
->s
, SOMAXCONN
), 0 ==, "select_server (%x): listen failed: %d\n");
656 trace ( "select_server (%x) ready\n", id
);
657 SetEvent ( server_ready
); /* notify clients */
659 FD_ZERO ( &fds_openrecv
);
660 FD_ZERO ( &fds_recv
);
661 FD_ZERO ( &fds_send
);
662 FD_ZERO ( &fds_opensend
);
664 FD_SET ( mem
->s
, &fds_openrecv
);
668 fds_recv
= fds_openrecv
;
669 fds_send
= fds_opensend
;
673 wsa_ok ( ( n_ready
= select ( 0, &fds_recv
, &fds_send
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
674 "select_server (%x): select() failed: %d\n" );
676 /* check for incoming requests */
677 if ( FD_ISSET ( mem
->s
, &fds_recv
) ) {
680 trace ( "select_server (%x): accepting client connection\n", id
);
682 /* accept a single connection */
683 tmp
= sizeof ( mem
->sock
[n_connections
].peer
);
684 mem
->sock
[n_connections
].s
= accept ( mem
->s
, (struct sockaddr
*) &mem
->sock
[n_connections
].peer
, &tmp
);
685 wsa_ok ( mem
->sock
[n_connections
].s
, INVALID_SOCKET
!=, "select_server (%x): accept() failed: %d\n" );
687 ok ( mem
->sock
[n_connections
].peer
.sin_addr
.s_addr
== inet_addr ( gen
->inet_addr
),
688 "select_server (%x): strange peer address\n", id
);
690 /* add to list of open connections */
691 FD_SET ( mem
->sock
[n_connections
].s
, &fds_openrecv
);
692 FD_SET ( mem
->sock
[n_connections
].s
, &fds_opensend
);
697 /* handle open requests */
699 for ( i
= 0; i
< n_connections
; i
++ )
701 if ( FD_ISSET( mem
->sock
[i
].s
, &fds_recv
) ) {
704 if ( mem
->sock
[i
].n_recvd
< n_expected
) {
705 /* Receive data & check it */
706 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 );
707 ok ( n_recvd
!= SOCKET_ERROR
, "select_server (%x): error in recv(): %d\n", id
, WSAGetLastError() );
708 mem
->sock
[i
].n_recvd
+= n_recvd
;
710 if ( mem
->sock
[i
].n_recvd
== n_expected
) {
711 int pos
= test_buffer ( mem
->sock
[i
].buf
, gen
->chunk_size
, gen
->n_chunks
);
712 ok ( pos
== -1, "select_server (%x): test pattern error: %d\n", id
, pos
);
713 FD_CLR ( mem
->sock
[i
].s
, &fds_openrecv
);
716 ok ( mem
->sock
[i
].n_recvd
<= n_expected
, "select_server (%x): received too many bytes: %d\n", id
, mem
->sock
[i
].n_recvd
);
720 /* only echo back what we've received */
721 delta
= mem
->sock
[i
].n_recvd
- mem
->sock
[i
].n_sent
;
723 if ( FD_ISSET ( mem
->sock
[i
].s
, &fds_send
) ) {
726 if ( ( delta
> 0 ) && ( mem
->sock
[i
].n_sent
< n_expected
) ) {
728 n_sent
= send ( mem
->sock
[i
].s
, mem
->sock
[i
].buf
+ mem
->sock
[i
].n_sent
, min ( delta
, par
->buflen
), 0 );
729 ok ( n_sent
!= SOCKET_ERROR
, "select_server (%x): error in send(): %d\n", id
, WSAGetLastError() );
730 mem
->sock
[i
].n_sent
+= n_sent
;
732 if ( mem
->sock
[i
].n_sent
== n_expected
) {
733 FD_CLR ( mem
->sock
[i
].s
, &fds_opensend
);
736 ok ( mem
->sock
[i
].n_sent
<= n_expected
, "select_server (%x): sent too many bytes: %d\n", id
, mem
->sock
[i
].n_sent
);
741 /* check that select returned the correct number of ready sockets */
742 ok ( ( n_set
== n_ready
), "select_server (%x): select() returns wrong number of ready sockets\n", id
);
744 /* check if all clients are done */
745 if ( ( fds_opensend
.fd_count
== 0 )
746 && ( fds_openrecv
.fd_count
== 1 ) /* initial socket that accepts clients */
747 && ( n_connections
== min ( gen
->n_clients
, MAX_CLIENTS
) ) ) {
752 for ( i
= 0; i
< min ( gen
->n_clients
, MAX_CLIENTS
); i
++ )
755 read_zero_bytes ( mem
->sock
[i
].s
);
756 wsa_ok ( closesocket ( mem
->sock
[i
].s
), 0 ==, "select_server (%x): closesocket error: %d\n" );
757 mem
->sock
[i
].s
= INVALID_SOCKET
;
760 trace ( "select_server (%x) exiting\n", id
);
764 /**************** Clients ***************/
767 * simple_client: A very basic client doing synchronous IO.
769 static VOID WINAPI
simple_client ( client_params
*par
)
771 test_params
*gen
= par
->general
;
773 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
775 id
= GetCurrentThreadId();
776 trace ( "simple_client (%x): starting\n", id
);
777 /* wait here because we want to call set_so_opentype before creating a socket */
778 WaitForSingleObject ( server_ready
, INFINITE
);
779 trace ( "simple_client (%x): server ready\n", id
);
781 check_so_opentype ();
782 set_so_opentype ( FALSE
); /* non-overlapped */
783 client_start ( par
);
784 mem
= TlsGetValue ( tls
);
787 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
788 0 ==, "simple_client (%x): connect error: %d\n" );
789 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
790 "simple_client (%x): failed to set blocking mode\n", id
);
791 trace ( "simple_client (%x) connected\n", id
);
793 /* send data to server */
794 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
, 0 );
795 ok ( n_sent
== n_expected
,
796 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
798 /* shutdown send direction */
799 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
801 /* Receive data echoed back & check it */
802 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, par
->buflen
);
803 ok ( n_recvd
== n_expected
,
804 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
807 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
808 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
811 read_zero_bytes ( mem
->s
);
812 trace ( "simple_client (%x) exiting\n", id
);
817 * oob_client: A very basic client sending out-of-band data.
819 static VOID WINAPI
oob_client ( client_params
*par
)
821 test_params
*gen
= par
->general
;
823 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
825 id
= GetCurrentThreadId();
826 trace ( "oob_client (%x): starting\n", id
);
827 /* wait here because we want to call set_so_opentype before creating a socket */
828 WaitForSingleObject ( server_ready
, INFINITE
);
829 trace ( "oob_client (%x): server ready\n", id
);
831 check_so_opentype ();
832 set_so_opentype ( FALSE
); /* non-overlapped */
833 client_start ( par
);
834 mem
= TlsGetValue ( tls
);
837 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
838 0 ==, "oob_client (%x): connect error: %d\n" );
839 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
840 "oob_client (%x): failed to set blocking mode\n", id
);
841 trace ( "oob_client (%x) connected\n", id
);
843 /* send data to server */
844 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
, 0 );
845 ok ( n_sent
== n_expected
,
846 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
848 /* Receive data echoed back & check it */
849 n_recvd
= do_synchronous_recv ( mem
->s
, mem
->recv_buf
, n_expected
, par
->buflen
);
850 ok ( n_recvd
== n_expected
,
851 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
852 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
853 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
855 /* send out-of-band data to server */
856 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
, MSG_OOB
);
857 ok ( n_sent
== n_expected
,
858 "oob_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
860 /* shutdown send direction */
861 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
864 read_zero_bytes ( mem
->s
);
865 trace ( "oob_client (%x) exiting\n", id
);
870 * simple_mixed_client: mixing send and recvfrom
872 static VOID WINAPI
simple_mixed_client ( client_params
*par
)
874 test_params
*gen
= par
->general
;
876 int pos
, n_sent
, n_recvd
, n_expected
= gen
->n_chunks
* gen
->chunk_size
, id
;
877 int fromLen
= sizeof(mem
->addr
);
878 struct sockaddr test
;
880 id
= GetCurrentThreadId();
881 trace ( "simple_client (%x): starting\n", id
);
882 /* wait here because we want to call set_so_opentype before creating a socket */
883 WaitForSingleObject ( server_ready
, INFINITE
);
884 trace ( "simple_client (%x): server ready\n", id
);
886 check_so_opentype ();
887 set_so_opentype ( FALSE
); /* non-overlapped */
888 client_start ( par
);
889 mem
= TlsGetValue ( tls
);
892 wsa_ok ( connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) ),
893 0 ==, "simple_client (%x): connect error: %d\n" );
894 ok ( set_blocking ( mem
->s
, TRUE
) == 0,
895 "simple_client (%x): failed to set blocking mode\n", id
);
896 trace ( "simple_client (%x) connected\n", id
);
898 /* send data to server */
899 n_sent
= do_synchronous_send ( mem
->s
, mem
->send_buf
, n_expected
, par
->buflen
, 0 );
900 ok ( n_sent
== n_expected
,
901 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n_sent
, n_expected
);
903 /* shutdown send direction */
904 wsa_ok ( shutdown ( mem
->s
, SD_SEND
), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
906 /* this shouldn't change, since lpFrom, is not updated on
907 connection oriented sockets - exposed by bug 11640
909 ((struct sockaddr_in
*)&test
)->sin_addr
.s_addr
= inet_addr("0.0.0.0");
911 /* Receive data echoed back & check it */
912 n_recvd
= do_synchronous_recvfrom ( mem
->s
,
916 (struct sockaddr
*)&test
,
919 ok ( n_recvd
== n_expected
,
920 "simple_client (%x): received less data than expected: %d of %d\n", id
, n_recvd
, n_expected
);
922 /* check that lpFrom was not updated */
925 inet_ntoa(((struct sockaddr_in
*)&test
)->sin_addr
),
926 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
929 pos
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
930 ok ( pos
== -1, "simple_client (%x): test pattern error: %d\n", id
, pos
);
933 read_zero_bytes ( mem
->s
);
934 trace ( "simple_client (%x) exiting\n", id
);
939 * event_client: An event-driven client
941 static void WINAPI
event_client ( client_params
*par
)
943 test_params
*gen
= par
->general
;
945 int id
= GetCurrentThreadId(), n_expected
= gen
->n_chunks
* gen
->chunk_size
,
948 WSANETWORKEVENTS wsa_events
;
949 char *send_last
, *recv_last
, *send_p
, *recv_p
;
950 LONG mask
= FD_READ
| FD_WRITE
| FD_CLOSE
;
952 trace ( "event_client (%x): starting\n", id
);
953 client_start ( par
);
954 trace ( "event_client (%x): server ready\n", id
);
956 mem
= TlsGetValue ( tls
);
958 /* Prepare event notification for connect, makes socket nonblocking */
959 event
= WSACreateEvent ();
960 WSAEventSelect ( mem
->s
, event
, FD_CONNECT
);
961 tmp
= connect ( mem
->s
, (struct sockaddr
*) &mem
->addr
, sizeof ( mem
->addr
) );
963 err
= WSAGetLastError ();
964 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): connect error: %d\n", id
, err
);
965 tmp
= WaitForSingleObject ( event
, INFINITE
);
966 ok ( tmp
== WAIT_OBJECT_0
, "event_client (%x): wait for connect event failed: %d\n", id
, tmp
);
967 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
968 ok ( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
969 err
= wsa_events
.iErrorCode
[ FD_CONNECT_BIT
];
970 ok ( err
== 0, "event_client (%x): connect error: %d\n", id
, err
);
974 trace ( "event_client (%x) connected\n", id
);
976 WSAEventSelect ( mem
->s
, event
, mask
);
978 recv_p
= mem
->recv_buf
;
979 recv_last
= mem
->recv_buf
+ n_expected
;
980 send_p
= mem
->send_buf
;
981 send_last
= mem
->send_buf
+ n_expected
;
985 err
= WaitForSingleObject ( event
, INFINITE
);
986 ok ( err
== WAIT_OBJECT_0
, "event_client (%x): wait failed\n", id
);
988 err
= WSAEnumNetworkEvents ( mem
->s
, event
, &wsa_events
);
989 ok( err
== 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id
, err
);
991 if ( wsa_events
.lNetworkEvents
& FD_WRITE
)
993 err
= wsa_events
.iErrorCode
[ FD_WRITE_BIT
];
994 ok ( err
== 0, "event_client (%x): FD_WRITE error code: %d\n", id
, err
);
999 n
= send ( mem
->s
, send_p
, min ( send_last
- send_p
, par
->buflen
), 0 );
1002 err
= WSAGetLastError ();
1003 ok ( err
== WSAEWOULDBLOCK
, "event_client (%x): send error: %d\n", id
, err
);
1008 while ( n
>= 0 && send_p
< send_last
);
1010 if ( send_p
== send_last
)
1012 trace ( "event_client (%x): all data sent - shutdown\n", id
);
1013 shutdown ( mem
->s
, SD_SEND
);
1015 WSAEventSelect ( mem
->s
, event
, mask
);
1018 if ( wsa_events
.lNetworkEvents
& FD_READ
)
1020 err
= wsa_events
.iErrorCode
[ FD_READ_BIT
];
1021 ok ( err
== 0, "event_client (%x): FD_READ error code: %d\n", id
, err
);
1022 if ( err
!= 0 ) break;
1024 /* First read must succeed */
1025 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
1026 wsa_ok ( n
, 0 <=, "event_client (%x): recv error: %d\n" );
1030 if ( recv_p
== recv_last
)
1033 trace ( "event_client (%x): all data received\n", id
);
1034 WSAEventSelect ( mem
->s
, event
, mask
);
1037 n
= recv ( mem
->s
, recv_p
, min ( recv_last
- recv_p
, par
->buflen
), 0 );
1038 if ( n
< 0 && ( err
= WSAGetLastError()) != WSAEWOULDBLOCK
)
1039 ok ( 0, "event_client (%x): read error: %d\n", id
, err
);
1043 if ( wsa_events
.lNetworkEvents
& FD_CLOSE
)
1045 trace ( "event_client (%x): close event\n", id
);
1046 err
= wsa_events
.iErrorCode
[ FD_CLOSE_BIT
];
1047 ok ( err
== 0, "event_client (%x): FD_CLOSE error code: %d\n", id
, err
);
1052 n
= send_p
- mem
->send_buf
;
1053 ok ( send_p
== send_last
,
1054 "simple_client (%x): sent less data than expected: %d of %d\n", id
, n
, n_expected
);
1055 n
= recv_p
- mem
->recv_buf
;
1056 ok ( recv_p
== recv_last
,
1057 "simple_client (%x): received less data than expected: %d of %d\n", id
, n
, n_expected
);
1058 n
= test_buffer ( mem
->recv_buf
, gen
->chunk_size
, gen
->n_chunks
);
1059 ok ( n
== -1, "event_client (%x): test pattern error: %d\n", id
, n
);
1062 WSACloseEvent ( event
);
1063 trace ( "event_client (%x) exiting\n", id
);
1067 /* Tests for WSAStartup */
1068 static void test_WithoutWSAStartup(void)
1072 WSASetLastError(0xdeadbeef);
1073 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
, "WSASocketA should have failed\n");
1074 err
= WSAGetLastError();
1075 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
1077 WSASetLastError(0xdeadbeef);
1078 ok(gethostbyname("localhost") == NULL
, "gethostbyname() succeeded unexpectedly\n");
1079 err
= WSAGetLastError();
1080 ok(err
== WSANOTINITIALISED
, "Expected 10093, received %d\n", err
);
1083 static void test_WithWSAStartup(void)
1086 WORD version
= MAKEWORD( 2, 2 );
1092 res
= WSAStartup( version
, &data
);
1093 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1095 ptr
= gethostbyname("localhost");
1096 ok(ptr
!= NULL
, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1098 ok(!tcp_socketpair(&src
, &dst
), "creating socket pair failed\n");
1100 res
= send(src
, "TEST", 4, 0);
1101 ok(res
== 4, "send failed with error %d\n", WSAGetLastError());
1105 res
= WSAStartup( version
, &data
);
1106 ok(res
== 0, "WSAStartup() failed unexpectedly: %d\n", res
);
1108 /* show that sockets are destroyed automatically after WSACleanup */
1110 SetLastError(0xdeadbeef);
1111 res
= send(src
, "TEST", 4, 0);
1112 error
= WSAGetLastError();
1113 ok(res
== SOCKET_ERROR
, "send should have failed\n");
1114 ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1116 SetLastError(0xdeadbeef);
1117 res
= closesocket(dst
);
1118 error
= WSAGetLastError();
1119 ok(res
== SOCKET_ERROR
, "closesocket should have failed\n");
1120 ok(error
== WSAENOTSOCK
, "expected 10038, got %d\n", error
);
1129 /**************** Main program utility functions ***************/
1131 static void Init (void)
1133 WORD ver
= MAKEWORD (2, 2);
1135 HMODULE hws2_32
= GetModuleHandleA("ws2_32.dll");
1137 pfreeaddrinfo
= (void *)GetProcAddress(hws2_32
, "freeaddrinfo");
1138 pgetaddrinfo
= (void *)GetProcAddress(hws2_32
, "getaddrinfo");
1139 pFreeAddrInfoW
= (void *)GetProcAddress(hws2_32
, "FreeAddrInfoW");
1140 pGetAddrInfoW
= (void *)GetProcAddress(hws2_32
, "GetAddrInfoW");
1141 pInetNtop
= (void *)GetProcAddress(hws2_32
, "inet_ntop");
1142 pWSALookupServiceBeginW
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceBeginW");
1143 pWSALookupServiceEnd
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceEnd");
1144 pWSALookupServiceNextW
= (void *)GetProcAddress(hws2_32
, "WSALookupServiceNextW");
1146 ok ( WSAStartup ( ver
, &data
) == 0, "WSAStartup failed\n" );
1150 static void Exit (void)
1155 err
= WSAGetLastError();
1156 ok ( ret
== 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret
, err
);
1158 err
= WSAGetLastError();
1159 ok ( (ret
== SOCKET_ERROR
&& err
== WSANOTINITIALISED
) ||
1160 broken(ret
== 0), /* WinME */
1161 "WSACleanup returned %d GetLastError is %d\n", ret
, err
);
1164 static void StartServer (LPTHREAD_START_ROUTINE routine
,
1165 test_params
*general
, server_params
*par
)
1167 par
->general
= general
;
1168 thread
[0] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[0] );
1169 ok ( thread
[0] != NULL
, "Failed to create server thread\n" );
1172 static void StartClients (LPTHREAD_START_ROUTINE routine
,
1173 test_params
*general
, client_params
*par
)
1176 par
->general
= general
;
1177 for ( i
= 1; i
<= min ( general
->n_clients
, MAX_CLIENTS
); i
++ )
1180 thread
[i
] = CreateThread ( NULL
, 0, routine
, par
, 0, &thread_id
[i
] );
1181 ok ( thread
[i
] != NULL
, "Failed to create client thread\n" );
1182 /* Make sure the client is up and running */
1183 WaitForSingleObject ( client_ready
[client_id
], INFINITE
);
1187 static void do_test( test_setup
*test
)
1189 DWORD i
, n
= min (test
->general
.n_clients
, MAX_CLIENTS
);
1192 server_ready
= CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1193 for (i
= 0; i
<= n
; i
++)
1194 client_ready
[i
] = CreateEventA ( NULL
, TRUE
, FALSE
, NULL
);
1196 StartServer ( test
->srv
, &test
->general
, &test
->srv_params
);
1197 StartClients ( test
->clt
, &test
->general
, &test
->clt_params
);
1198 WaitForSingleObject ( server_ready
, INFINITE
);
1200 wait
= WaitForMultipleObjects ( 1 + n
, thread
, TRUE
, 1000 * TEST_TIMEOUT
);
1201 ok ( wait
<= WAIT_OBJECT_0
+ n
,
1202 "some threads have not completed: %x\n", wait
);
1204 if ( ! ( wait
<= WAIT_OBJECT_0
+ n
) )
1206 for (i
= 0; i
<= n
; i
++)
1208 if ( WaitForSingleObject ( thread
[i
], 0 ) != WAIT_OBJECT_0
)
1210 trace ("terminating thread %08x\n", thread_id
[i
]);
1211 TerminateThread ( thread
[i
], 0 );
1215 CloseHandle ( server_ready
);
1216 for (i
= 0; i
<= n
; i
++)
1217 CloseHandle ( client_ready
[i
] );
1220 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1221 /* optname = SO_LINGER */
1222 static const LINGER linger_testvals
[] = {
1229 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1230 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1231 bug in the linux kernel (fixed in 2.6.8) */
1232 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1234 static void test_set_getsockopt(void)
1237 int i
, err
, lasterr
;
1241 WSAPROTOCOL_INFOA infoA
;
1242 WSAPROTOCOL_INFOW infoW
;
1243 char providername
[WSAPROTOCOL_LEN
+ 1];
1246 int family
, type
, proto
;
1248 {AF_INET
, SOCK_STREAM
, IPPROTO_TCP
},
1249 {AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
},
1250 {AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
},
1251 {AF_INET6
, SOCK_DGRAM
, IPPROTO_UDP
}
1254 s
= socket(AF_INET
, SOCK_STREAM
, 0);
1255 ok(s
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1256 if( s
== INVALID_SOCKET
) return;
1258 timeout
= SOCKTIMEOUT1
;
1259 size
= sizeof(timeout
);
1260 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1262 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1263 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1264 ok( timeout
== SOCKTIMEOUT1
, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1267 size
= sizeof(timeout
);
1268 err
= setsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, size
);
1270 err
= getsockopt(s
, SOL_SOCKET
, SO_RCVTIMEO
, (char *) &timeout
, &size
);
1271 ok( !err
, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1272 ok( timeout
== 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout
);
1275 timeout
= SOCKTIMEOUT2
; /* 997 seconds. See remark above */
1276 size
= sizeof(timeout
);
1277 err
= setsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, size
);
1279 err
= getsockopt(s
, SOL_SOCKET
, SO_SNDTIMEO
, (char *) &timeout
, &size
);
1280 ok( !err
, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1281 ok( timeout
== SOCKTIMEOUT2
, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout
);
1283 for( i
= 0; i
< sizeof(linger_testvals
)/sizeof(LINGER
);i
++) {
1284 size
= sizeof(lingval
);
1285 lingval
= linger_testvals
[i
];
1286 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, size
);
1288 err
= getsockopt(s
, SOL_SOCKET
, SO_LINGER
, (char *) &lingval
, &size
);
1289 ok( !err
, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1290 ok( !lingval
.l_onoff
== !linger_testvals
[i
].l_onoff
&&
1291 (lingval
.l_linger
== linger_testvals
[i
].l_linger
||
1292 (!lingval
.l_linger
&& !linger_testvals
[i
].l_onoff
))
1293 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i
,
1294 lingval
.l_onoff
, lingval
.l_linger
,
1295 linger_testvals
[i
].l_onoff
, linger_testvals
[i
].l_linger
);
1298 size
= sizeof(lingval
);
1299 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, size
);
1300 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1301 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1302 err
= setsockopt(s
, SOL_SOCKET
, SO_LINGER
, NULL
, 0);
1303 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1304 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1306 size
= sizeof(BOOL
);
1307 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, size
);
1308 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1309 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1310 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTLINGER
, NULL
, 0);
1311 ok(err
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
1312 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err
, WSAGetLastError());
1314 /* Test for erroneously passing a value instead of a pointer as optval */
1315 size
= sizeof(char);
1316 err
= setsockopt(s
, SOL_SOCKET
, SO_DONTROUTE
, (char *)1, size
);
1317 ok(err
== SOCKET_ERROR
, "setsockopt with optval being a value passed "
1318 "instead of failing.\n");
1319 lasterr
= WSAGetLastError();
1320 ok(lasterr
== WSAEFAULT
, "setsockopt with optval being a value "
1321 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1322 lasterr
, WSAEFAULT
);
1324 /* SO_RCVTIMEO with invalid values for level */
1325 size
= sizeof(timeout
);
1326 timeout
= SOCKTIMEOUT1
;
1327 SetLastError(0xdeadbeef);
1328 err
= setsockopt(s
, 0xffffffff, SO_RCVTIMEO
, (char *) &timeout
, size
);
1329 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1330 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1331 err
, WSAGetLastError());
1333 timeout
= SOCKTIMEOUT1
;
1334 SetLastError(0xdeadbeef);
1335 err
= setsockopt(s
, 0x00008000, SO_RCVTIMEO
, (char *) &timeout
, size
);
1336 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
1337 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1338 err
, WSAGetLastError());
1340 /* Test SO_ERROR set/get */
1341 SetLastError(0xdeadbeef);
1343 err
= setsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, size
);
1345 ok( !err
&& !WSAGetLastError(),
1346 "got %d with %d (expected 0 with 0)\n",
1347 err
, WSAGetLastError());
1349 SetLastError(0xdeadbeef);
1351 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1353 ok( !err
&& !WSAGetLastError(),
1354 "got %d with %d (expected 0 with 0)\n",
1355 err
, WSAGetLastError());
1357 ok (i
== 1234, "got %d (expected 1234)\n", i
);
1359 /* Test invalid optlen */
1360 SetLastError(0xdeadbeef);
1362 err
= getsockopt(s
, SOL_SOCKET
, SO_ERROR
, (char *) &i
, &size
);
1364 ok( (err
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEFAULT
),
1365 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1366 err
, WSAGetLastError());
1370 /* test SO_PROTOCOL_INFOA invalid parameters */
1371 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1372 "getsockopt should have failed\n");
1373 err
= WSAGetLastError();
1374 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1375 size
= sizeof(WSAPROTOCOL_INFOA
);
1376 ok(getsockopt(INVALID_SOCKET
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1377 "getsockopt should have failed\n");
1378 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1379 err
= WSAGetLastError();
1380 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
1381 s
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
1382 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, NULL
),
1383 "getsockopt should have failed\n");
1384 err
= WSAGetLastError();
1385 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1386 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, NULL
),
1387 "getsockopt should have failed\n");
1388 err
= WSAGetLastError();
1389 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1390 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, NULL
, &size
),
1391 "getsockopt should have failed\n");
1392 err
= WSAGetLastError();
1393 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1394 size
= sizeof(WSAPROTOCOL_INFOA
) / 2;
1395 ok(getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
),
1396 "getsockopt should have failed\n");
1397 err
= WSAGetLastError();
1398 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
1399 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1400 size
= sizeof(WSAPROTOCOL_INFOA
) * 2;
1401 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1402 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1403 ok(size
== sizeof(WSAPROTOCOL_INFOA
) * 2, "got size %d\n", size
);
1407 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1408 for (i
= 0; i
< sizeof(prottest
) / sizeof(prottest
[0]); i
++)
1410 s
= socket(prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1411 if (s
== INVALID_SOCKET
&& prottest
[i
].family
== AF_INET6
) continue;
1413 ok(s
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
1416 /* compare both A and W version */
1417 infoA
.szProtocol
[0] = 0;
1418 size
= sizeof(WSAPROTOCOL_INFOA
);
1419 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &infoA
, &size
);
1420 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1421 ok(size
== sizeof(WSAPROTOCOL_INFOA
), "got size %d\n", size
);
1423 infoW
.szProtocol
[0] = 0;
1424 size
= sizeof(WSAPROTOCOL_INFOW
);
1425 err
= getsockopt(s
, SOL_SOCKET
, SO_PROTOCOL_INFOW
, (char *) &infoW
, &size
);
1426 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
1427 ok(size
== sizeof(WSAPROTOCOL_INFOW
), "got size %d\n", size
);
1429 trace("provider name '%s', family %d, type %d, proto %d\n",
1430 infoA
.szProtocol
, prottest
[i
].family
, prottest
[i
].type
, prottest
[i
].proto
);
1432 ok(infoA
.szProtocol
[0] || broken(!infoA
.szProtocol
[0]) /* NT4 */,
1433 "WSAPROTOCOL_INFOA was not filled\n");
1434 ok(infoW
.szProtocol
[0] || broken(!infoA
.szProtocol
[0]) /* NT4 */,
1435 "WSAPROTOCOL_INFOW was not filled\n");
1437 WideCharToMultiByte(CP_ACP
, 0, infoW
.szProtocol
, -1,
1438 providername
, sizeof(providername
), NULL
, NULL
);
1439 ok(!strcmp(infoA
.szProtocol
,providername
),
1440 "different provider names '%s' != '%s'\n", infoA
.szProtocol
, providername
);
1442 ok(!memcmp(&infoA
, &infoW
, FIELD_OFFSET(WSAPROTOCOL_INFOA
, szProtocol
)),
1443 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1445 /* Remove IF when WSAEnumProtocols support IPV6 data */
1446 if (prottest
[i
].family
== AF_INET6
)
1449 ok(infoA
.iAddressFamily
== prottest
[i
].family
, "socket family invalid, expected %d received %d\n",
1450 prottest
[i
].family
, infoA
.iAddressFamily
);
1454 ok(infoA
.iAddressFamily
== prottest
[i
].family
, "socket family invalid, expected %d received %d\n",
1455 prottest
[i
].family
, infoA
.iAddressFamily
);
1456 } ok(infoA
.iSocketType
== prottest
[i
].type
, "socket type invalid, expected %d received %d\n",
1457 prottest
[i
].type
, infoA
.iSocketType
);
1458 ok(infoA
.iProtocol
== prottest
[i
].proto
, "socket protocol invalid, expected %d received %d\n",
1459 prottest
[i
].proto
, infoA
.iProtocol
);
1465 static void test_so_reuseaddr(void)
1467 struct sockaddr_in saddr
;
1469 unsigned int rc
,reuse
;
1472 saddr
.sin_family
= AF_INET
;
1473 saddr
.sin_port
= htons(9375);
1474 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1476 s1
=socket(AF_INET
, SOCK_STREAM
, 0);
1477 ok(s1
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1478 rc
= bind(s1
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1479 ok(rc
!=SOCKET_ERROR
, "bind(s1) failed error: %d\n", WSAGetLastError());
1481 s2
=socket(AF_INET
, SOCK_STREAM
, 0);
1482 ok(s2
!=INVALID_SOCKET
, "socket() failed error: %d\n", WSAGetLastError());
1486 rc
=getsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, &size
);
1487 ok(rc
==0 && reuse
==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc
,reuse
);
1489 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1490 ok(rc
==SOCKET_ERROR
, "bind() succeeded\n");
1493 rc
= setsockopt(s2
, SOL_SOCKET
, SO_REUSEADDR
, (char*)&reuse
, sizeof(reuse
));
1494 ok(rc
==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1496 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1497 * a port immediately after closing another socket on that port, so
1498 * basically following the BSD socket semantics here. */
1500 rc
= bind(s2
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1501 ok(rc
==0, "bind() failed error: %d\n", WSAGetLastError());
1506 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1508 static void test_ip_pktinfo(void)
1510 ULONG addresses
[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY
)};
1511 char recvbuf
[10], pktbuf
[512], msg
[] = "HELLO";
1512 struct sockaddr_in s1addr
, s2addr
, s3addr
;
1513 GUID WSARecvMsg_GUID
= WSAID_WSARECVMSG
;
1514 LPFN_WSARECVMSG pWSARecvMsg
= NULL
;
1515 unsigned int rc
, yes
= 1;
1517 DWORD dwBytes
, dwSize
, dwFlags
;
1526 memset(&ov
, 0, sizeof(ov
));
1527 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
1528 if (ov
.hEvent
== INVALID_HANDLE_VALUE
)
1530 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
1534 memset(&hdr
, 0x00, sizeof(hdr
));
1535 s1addr
.sin_family
= AF_INET
;
1536 s1addr
.sin_port
= htons(0);
1537 /* Note: s1addr.sin_addr is set below */
1538 iovec
[0].buf
= recvbuf
;
1539 iovec
[0].len
= sizeof(recvbuf
);
1540 hdr
.name
= (struct sockaddr
*)&s3addr
;
1541 hdr
.namelen
= sizeof(s3addr
);
1542 hdr
.lpBuffers
= &iovec
[0];
1543 hdr
.dwBufferCount
= 1;
1544 hdr
.Control
.buf
= pktbuf
;
1545 /* Note: hdr.Control.len is set below */
1548 for (i
=0;i
<sizeof(addresses
)/sizeof(UINT32
);i
++)
1550 s1addr
.sin_addr
.s_addr
= addresses
[i
];
1552 /* Build "server" side socket */
1553 s1
=socket(AF_INET
, SOCK_DGRAM
, 0);
1554 if (s1
== INVALID_SOCKET
)
1556 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1560 /* Obtain the WSARecvMsg function */
1561 WSAIoctl(s1
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSARecvMsg_GUID
, sizeof(WSARecvMsg_GUID
),
1562 &pWSARecvMsg
, sizeof(pWSARecvMsg
), &dwBytes
, NULL
, NULL
);
1565 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
1570 /* Setup the server side socket */
1571 rc
=bind(s1
, (struct sockaddr
*)&s1addr
, sizeof(s1addr
));
1572 ok(rc
!= SOCKET_ERROR
, "bind() failed error: %d\n", WSAGetLastError());
1573 rc
=setsockopt(s1
, IPPROTO_IP
, IP_PKTINFO
, (const char*)&yes
, sizeof(yes
));
1574 ok(rc
== 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1576 /* Build "client" side socket */
1577 addrlen
= sizeof(s2addr
);
1578 if (getsockname(s1
, (struct sockaddr
*) &s2addr
, &addrlen
) != 0)
1580 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
1584 s2addr
.sin_addr
.s_addr
= addresses
[0]; /* Always target the local adapter address */
1585 s2
=socket(AF_INET
, SOCK_DGRAM
, 0);
1586 if (s2
== INVALID_SOCKET
)
1588 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1593 /* Test an empty message header */
1594 rc
=pWSARecvMsg(s1
, NULL
, NULL
, NULL
, NULL
);
1595 err
=WSAGetLastError();
1596 ok(rc
== SOCKET_ERROR
&& err
== WSAEFAULT
, "WSARecvMsg() failed error: %d (ret = %d)\n", err
, rc
);
1599 * Send a packet from the client to the server and test for specifying
1600 * a short control header.
1602 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1603 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1604 hdr
.Control
.len
= 1;
1605 rc
=pWSARecvMsg(s1
, &hdr
, &dwSize
, NULL
, NULL
);
1606 err
=WSAGetLastError();
1607 ok(rc
== SOCKET_ERROR
&& err
== WSAEMSGSIZE
&& (hdr
.dwFlags
& MSG_CTRUNC
),
1608 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err
, rc
, hdr
.dwFlags
);
1609 hdr
.dwFlags
= 0; /* Reset flags */
1611 /* Perform another short control header test, this time with an overlapped receive */
1612 hdr
.Control
.len
= 1;
1613 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1614 err
=WSAGetLastError();
1615 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1616 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1617 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1618 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
1620 skip("Server side did not receive packet, some tests skipped.\n");
1626 WSAGetOverlappedResult(s1
, &ov
, NULL
, FALSE
, &dwFlags
);
1628 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags
);
1629 ok(hdr
.dwFlags
== MSG_CTRUNC
,
1630 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr
.dwFlags
);
1631 hdr
.dwFlags
= 0; /* Reset flags */
1634 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1635 * on the server end and check that the returned packet matches what was sent.
1637 hdr
.Control
.len
= sizeof(pktbuf
);
1638 rc
=pWSARecvMsg(s1
, &hdr
, NULL
, &ov
, NULL
);
1639 err
=WSAGetLastError();
1640 ok(rc
!= 0 && err
== WSA_IO_PENDING
, "WSARecvMsg() failed error: %d\n", err
);
1641 ok(hdr
.Control
.len
== sizeof(pktbuf
),
1642 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr
.Control
.len
);
1643 rc
=sendto(s2
, msg
, sizeof(msg
), 0, (struct sockaddr
*)&s2addr
, sizeof(s2addr
));
1644 ok(rc
== sizeof(msg
), "sendto() failed error: %d\n", WSAGetLastError());
1645 if (WaitForSingleObject(ov
.hEvent
, 100) != WAIT_OBJECT_0
)
1647 skip("Server side did not receive packet, some tests skipped.\n");
1653 WSAGetOverlappedResult(s1
, &ov
, &dwSize
, FALSE
, NULL
);
1654 ok(dwSize
== sizeof(msg
),
1655 "WSARecvMsg() buffer length does not match transmitted data!\n");
1656 ok(strncmp(iovec
[0].buf
, msg
, sizeof(msg
)) == 0,
1657 "WSARecvMsg() buffer does not match transmitted data!\n");
1658 ok(hdr
.Control
.len
== IP_PKTINFO_LEN
,
1659 "WSARecvMsg() control length mismatch (%d).\n", hdr
.Control
.len
);
1661 /* Test for the expected IP_PKTINFO return information. */
1663 for (cmsg
= WSA_CMSG_FIRSTHDR(&hdr
); cmsg
!= NULL
; cmsg
= WSA_CMSG_NXTHDR(&hdr
, cmsg
))
1665 if (cmsg
->cmsg_level
== IPPROTO_IP
&& cmsg
->cmsg_type
== IP_PKTINFO
)
1667 struct in_pktinfo
*pi
= (struct in_pktinfo
*)WSA_CMSG_DATA(cmsg
);
1669 ok(pi
->ipi_addr
.s_addr
== s2addr
.sin_addr
.s_addr
, "destination ip mismatch!\n");
1673 ok(foundhdr
, "IP_PKTINFO header information was not returned!\n");
1680 CloseHandle(ov
.hEvent
);
1683 /************* Array containing the tests to run **********/
1685 #define STD_STREAM_SOCKET \
1691 static test_setup tests
[] =
1693 /* Test 0: synchronous client and server */
1714 /* Test 1: event-driven client, synchronous server */
1731 WSA_FLAG_OVERLAPPED
,
1735 /* Test 2: synchronous client, non-blocking server via select() */
1756 /* Test 3: OOB client, OOB server */
1777 /* Test 4: synchronous mixed client and server */
1791 simple_mixed_client
,
1800 static void test_UDP(void)
1802 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
1803 possible that this test fails due to dropped packets. */
1805 /* peer 0 receives data from all other peers */
1806 struct sock_info peer
[NUM_UDP_PEERS
];
1808 int ss
, i
, n_recv
, n_sent
;
1810 memset (buf
,0,sizeof(buf
));
1811 for ( i
= NUM_UDP_PEERS
- 1; i
>= 0; i
-- ) {
1812 ok ( ( peer
[i
].s
= socket ( AF_INET
, SOCK_DGRAM
, 0 ) ) != INVALID_SOCKET
, "UDP: socket failed\n" );
1814 peer
[i
].addr
.sin_family
= AF_INET
;
1815 peer
[i
].addr
.sin_addr
.s_addr
= inet_addr ( SERVERIP
);
1818 peer
[i
].addr
.sin_port
= htons ( SERVERPORT
);
1820 peer
[i
].addr
.sin_port
= htons ( 0 );
1823 do_bind ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, sizeof( peer
[i
].addr
) );
1825 /* test getsockname() to get peer's port */
1826 ss
= sizeof ( peer
[i
].addr
);
1827 ok ( getsockname ( peer
[i
].s
, (struct sockaddr
*) &peer
[i
].addr
, &ss
) != SOCKET_ERROR
, "UDP: could not getsockname()\n" );
1828 ok ( peer
[i
].addr
.sin_port
!= htons ( 0 ), "UDP: bind() did not associate port\n" );
1831 /* test getsockname() */
1832 ok ( peer
[0].addr
.sin_port
== htons ( SERVERPORT
), "UDP: getsockname returned incorrect peer port\n" );
1834 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
1835 /* send client's ip */
1836 memcpy( buf
, &peer
[i
].addr
.sin_port
, sizeof(peer
[i
].addr
.sin_port
) );
1837 n_sent
= sendto ( peer
[i
].s
, buf
, sizeof(buf
), 0, (struct sockaddr
*) &peer
[0].addr
, sizeof(peer
[0].addr
) );
1838 ok ( n_sent
== sizeof(buf
), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent
);
1841 for ( i
= 1; i
< NUM_UDP_PEERS
; i
++ ) {
1842 n_recv
= recvfrom ( peer
[0].s
, buf
, sizeof(buf
), 0,(struct sockaddr
*) &peer
[0].peer
, &ss
);
1843 ok ( n_recv
== sizeof(buf
), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv
);
1844 ok ( memcmp ( &peer
[0].peer
.sin_port
, buf
, sizeof(peer
[0].addr
.sin_port
) ) == 0, "UDP: port numbers do not match\n" );
1848 static DWORD WINAPI
do_getservbyname( void *param
)
1854 } serv
[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
1856 HANDLE
*starttest
= param
;
1858 struct servent
*pserv
[2];
1860 ok ( WaitForSingleObject ( *starttest
, TEST_TIMEOUT
* 1000 ) != WAIT_TIMEOUT
,
1861 "test_getservbyname: timeout waiting for start signal\n" );
1863 /* ensure that necessary buffer resizes are completed */
1864 for ( j
= 0; j
< 2; j
++) {
1865 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
1868 for ( i
= 0; i
< NUM_QUERIES
/ 2; i
++ ) {
1869 for ( j
= 0; j
< 2; j
++ ) {
1870 pserv
[j
] = getservbyname ( serv
[j
].name
, serv
[j
].proto
);
1871 ok ( pserv
[j
] != NULL
|| broken(pserv
[j
] == NULL
) /* win8, fixed in win81 */,
1872 "getservbyname could not retrieve information for %s: %d\n", serv
[j
].name
, WSAGetLastError() );
1873 if ( !pserv
[j
] ) continue;
1874 ok ( pserv
[j
]->s_port
== htons(serv
[j
].port
),
1875 "getservbyname returned the wrong port for %s: %d\n", serv
[j
].name
, ntohs(pserv
[j
]->s_port
) );
1876 ok ( !strcmp ( pserv
[j
]->s_proto
, serv
[j
].proto
),
1877 "getservbyname returned the wrong protocol for %s: %s\n", serv
[j
].name
, pserv
[j
]->s_proto
);
1878 ok ( !strcmp ( pserv
[j
]->s_name
, serv
[j
].name
),
1879 "getservbyname returned the wrong name for %s: %s\n", serv
[j
].name
, pserv
[j
]->s_name
);
1882 ok ( pserv
[0] == pserv
[1] || broken(pserv
[0] != pserv
[1]) /* win8, fixed in win81 */,
1883 "getservbyname: winsock resized servent buffer when not necessary\n" );
1889 static void test_getservbyname(void)
1892 HANDLE starttest
, thread
[NUM_THREADS
];
1893 DWORD thread_id
[NUM_THREADS
];
1895 starttest
= CreateEventA ( NULL
, 1, 0, "test_getservbyname_starttest" );
1897 /* create threads */
1898 for ( i
= 0; i
< NUM_THREADS
; i
++ ) {
1899 thread
[i
] = CreateThread ( NULL
, 0, do_getservbyname
, &starttest
, 0, &thread_id
[i
] );
1902 /* signal threads to start */
1903 SetEvent ( starttest
);
1905 for ( i
= 0; i
< NUM_THREADS
; i
++) {
1906 WaitForSingleObject ( thread
[i
], TEST_TIMEOUT
* 1000 );
1910 static void test_WSASocket(void)
1912 SOCKET sock
= INVALID_SOCKET
;
1913 WSAPROTOCOL_INFOA
*pi
;
1914 int wsaproviders
[] = {IPPROTO_TCP
, IPPROTO_IP
};
1915 int autoprotocols
[] = {IPPROTO_TCP
, IPPROTO_UDP
};
1916 int items
, err
, size
, socktype
, i
, j
;
1919 SetLastError(0xdeadbeef);
1920 ok(WSASocketA(0, 0, 0, NULL
, 0, 0) == INVALID_SOCKET
,
1921 "WSASocketA should have failed\n");
1922 err
= WSAGetLastError();
1923 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
1925 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
1926 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
1929 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, NULL
, 0, 0);
1930 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
1933 SetLastError(0xdeadbeef);
1934 ok(WSASocketA(0, SOCK_STREAM
, -1, NULL
, 0, 0) == INVALID_SOCKET
,
1935 "WSASocketA should have failed\n");
1936 err
= WSAGetLastError();
1937 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
1939 SetLastError(0xdeadbeef);
1940 ok(WSASocketA(0, -1, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
1941 "WSASocketA should have failed\n");
1942 err
= WSAGetLastError();
1943 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
1945 SetLastError(0xdeadbeef);
1946 ok(WSASocketA(0, -1, 0, NULL
, 0, 0) == INVALID_SOCKET
,
1947 "WSASocketA should have failed\n");
1948 err
= WSAGetLastError();
1949 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
1951 SetLastError(0xdeadbeef);
1952 ok(WSASocketA(AF_INET
, -1, 0, NULL
, 0, 0) == INVALID_SOCKET
,
1953 "WSASocketA should have failed\n");
1954 err
= WSAGetLastError();
1955 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
1957 SetLastError(0xdeadbeef);
1958 ok(WSASocketA(AF_INET
, 0, -1, NULL
, 0, 0) == INVALID_SOCKET
,
1959 "WSASocketA should have failed\n");
1960 err
= WSAGetLastError();
1961 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
1963 SetLastError(0xdeadbeef);
1964 ok(WSASocketA(0, -1, -1, NULL
, 0, 0) == INVALID_SOCKET
,
1965 "WSASocketA should have failed\n");
1966 err
= WSAGetLastError();
1967 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
1969 SetLastError(0xdeadbeef);
1970 ok(WSASocketA(-1, SOCK_STREAM
, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
1971 "WSASocketA should have failed\n");
1972 err
= WSAGetLastError();
1973 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
1975 sock
= WSASocketA(AF_INET
, 0, IPPROTO_TCP
, NULL
, 0, 0);
1976 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
1979 SetLastError(0xdeadbeef);
1980 ok(WSASocketA(0, SOCK_STREAM
, 0, NULL
, 0, 0) == INVALID_SOCKET
,
1981 "WSASocketA should have failed\n");
1982 err
= WSAGetLastError();
1983 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
1985 SetLastError(0xdeadbeef);
1986 ok(WSASocketA(0, 0, 0xdead, NULL
, 0, 0) == INVALID_SOCKET
,
1987 "WSASocketA should have failed\n");
1988 err
= WSAGetLastError();
1989 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
1991 SetLastError(0xdeadbeef);
1992 ok(WSASocketA(AF_INET
, 0xdead, 0, NULL
, 0, 0) == INVALID_SOCKET
,
1993 "WSASocketA should have failed\n");
1994 err
= WSAGetLastError();
1995 ok(err
== WSAESOCKTNOSUPPORT
, "Expected 10044, received %d\n", err
);
1997 SetLastError(0xdeadbeef);
1998 ok(WSASocketA(0, 0xdead, 0, NULL
, 0, 0) == INVALID_SOCKET
,
1999 "WSASocketA should have failed\n");
2000 err
= WSAGetLastError();
2001 ok(err
== WSAEINVAL
, "Expected 10022, received %d\n", err
);
2003 sock
= WSASocketA(0, 0, IPPROTO_TCP
, NULL
, 0, 0);
2004 ok(sock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2007 /* SOCK_STREAM does not support IPPROTO_UDP */
2008 SetLastError(0xdeadbeef);
2009 ok(WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_UDP
, NULL
, 0, 0) == INVALID_SOCKET
,
2010 "WSASocketA should have failed\n");
2011 err
= WSAGetLastError();
2012 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2014 /* SOCK_DGRAM does not support IPPROTO_TCP */
2015 SetLastError(0xdeadbeef);
2016 ok(WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_TCP
, NULL
, 0, 0) == INVALID_SOCKET
,
2017 "WSASocketA should have failed\n");
2018 err
= WSAGetLastError();
2019 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2021 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
2022 * to avoid a crash on win98.
2025 items
= WSAEnumProtocolsA(wsaproviders
, NULL
, &pi_size
);
2026 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
2028 err
= WSAGetLastError();
2029 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2032 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2033 ok(pi
!= NULL
, "Failed to allocate memory\n");
2035 skip("Can't continue without memory.\n");
2039 items
= WSAEnumProtocolsA(wsaproviders
, pi
, &pi_size
);
2040 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2044 skip("No protocols enumerated.\n");
2045 HeapFree(GetProcessHeap(), 0, pi
);
2049 sock
= WSASocketA(FROM_PROTOCOL_INFO
, FROM_PROTOCOL_INFO
,
2050 FROM_PROTOCOL_INFO
, &pi
[0], 0, 0);
2051 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2055 /* find what parameters are used first: plain parameters or protocol info struct */
2056 pi
[0].iProtocol
= -1;
2057 pi
[0].iSocketType
= -1;
2058 pi
[0].iAddressFamily
= -1;
2059 ok(WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0) == INVALID_SOCKET
,
2060 "WSASocketA should have failed\n");
2061 err
= WSAGetLastError();
2062 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2064 pi
[0].iProtocol
= 0;
2065 pi
[0].iSocketType
= 0;
2066 pi
[0].iAddressFamily
= 0;
2067 sock
= WSASocketA(0, 0, IPPROTO_UDP
, &pi
[0], 0, 0);
2068 if(sock
!= INVALID_SOCKET
)
2070 win_skip("must work only in OS <= 2003\n");
2075 err
= WSAGetLastError();
2076 ok(err
== WSAEAFNOSUPPORT
, "Expected 10047, received %d\n", err
);
2079 pi
[0].iProtocol
= IPPROTO_UDP
;
2080 pi
[0].iSocketType
= SOCK_DGRAM
;
2081 pi
[0].iAddressFamily
= AF_INET
;
2082 sock
= WSASocketA(0, 0, 0, &pi
[0], 0, 0);
2083 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2085 size
= sizeof(socktype
);
2087 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2088 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2089 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2090 SOCK_DGRAM
, socktype
);
2093 sock
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, &pi
[0], 0, 0);
2094 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2096 size
= sizeof(socktype
);
2098 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2099 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2100 ok(socktype
== SOCK_STREAM
, "Wrong socket type, expected %d received %d\n",
2101 SOCK_STREAM
, socktype
);
2104 HeapFree(GetProcessHeap(), 0, pi
);
2107 items
= WSAEnumProtocolsA(NULL
, NULL
, &pi_size
);
2108 ok(items
== SOCKET_ERROR
, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
2110 err
= WSAGetLastError();
2111 ok(err
== WSAENOBUFS
, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
2114 pi
= HeapAlloc(GetProcessHeap(), 0, pi_size
);
2115 ok(pi
!= NULL
, "Failed to allocate memory\n");
2117 skip("Can't continue without memory.\n");
2121 items
= WSAEnumProtocolsA(NULL
, pi
, &pi_size
);
2122 ok(items
!= SOCKET_ERROR
, "WSAEnumProtocolsA failed, last error is %d\n",
2125 /* when no protocol and socket type are specified the first entry
2126 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
2128 sock
= WSASocketA(AF_INET
, 0, 0, NULL
, 0, 0);
2129 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2132 size
= sizeof(socktype
);
2134 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2135 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2136 for(i
= 0; i
< items
; i
++)
2138 if(pi
[i
].dwProviderFlags
& PFL_MATCHES_PROTOCOL_ZERO
)
2140 ok(socktype
== pi
[i
].iSocketType
, "Wrong socket type, expected %d received %d\n",
2141 pi
[i
].iSocketType
, socktype
);
2145 ok(i
!= items
, "Creating a socket without protocol and socket type didn't work\n");
2148 /* when no socket type is specified the first entry from WSAEnumProtocols
2149 * that matches the protocol is returned */
2150 for (i
= 0; i
< sizeof(autoprotocols
) / sizeof(autoprotocols
[0]); i
++)
2152 sock
= WSASocketA(0, 0, autoprotocols
[i
], NULL
, 0, 0);
2153 ok(sock
!= INVALID_SOCKET
, "Failed to create socket for protocol %d, received %d\n",
2154 autoprotocols
[i
], WSAGetLastError());
2156 size
= sizeof(socktype
);
2158 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2159 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2161 for (err
= 1, j
= 0; j
< items
; j
++)
2163 if (pi
[j
].iProtocol
== autoprotocols
[i
])
2165 if (socktype
== pi
[j
].iSocketType
)
2168 ok(0, "Wrong socket type, expected %d received %d\n",
2169 pi
[j
].iSocketType
, socktype
);
2173 ok(!err
, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols
[i
]);
2178 HeapFree(GetProcessHeap(), 0, pi
);
2180 SetLastError(0xdeadbeef);
2181 /* starting on vista the socket function returns error during the socket
2182 creation and no longer in the socket operations (sendto, readfrom) */
2183 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_ICMP
, NULL
, 0, 0);
2184 if (sock
== INVALID_SOCKET
)
2186 err
= WSAGetLastError();
2187 ok(err
== WSAEACCES
, "Expected 10013, received %d\n", err
);
2188 skip("SOCK_RAW is not supported\n");
2192 trace("SOCK_RAW is supported\n");
2194 size
= sizeof(socktype
);
2196 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2197 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2198 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2199 SOCK_RAW
, socktype
);
2203 sock
= WSASocketA(0, 0, IPPROTO_RAW
, NULL
, 0, 0);
2204 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2206 size
= sizeof(socktype
);
2208 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2209 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2210 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2211 SOCK_RAW
, socktype
);
2215 sock
= WSASocketA(AF_INET
, SOCK_RAW
, IPPROTO_TCP
, NULL
, 0, 0);
2216 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2218 size
= sizeof(socktype
);
2220 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2221 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2222 ok(socktype
== SOCK_RAW
, "Wrong socket type, expected %d received %d\n",
2223 SOCK_RAW
, socktype
);
2227 /* IPX socket tests */
2229 SetLastError(0xdeadbeef);
2230 sock
= WSASocketA(AF_IPX
, SOCK_DGRAM
, NSPROTO_IPX
, NULL
, 0, 0);
2231 if (sock
== INVALID_SOCKET
)
2233 err
= WSAGetLastError();
2234 ok(err
== WSAEAFNOSUPPORT
|| broken(err
== WSAEPROTONOSUPPORT
), "Expected 10047, received %d\n", err
);
2235 skip("IPX is not supported\n");
2239 WSAPROTOCOL_INFOA info
;
2242 trace("IPX is supported\n");
2244 sock
= WSASocketA(0, 0, NSPROTO_IPX
, NULL
, 0, 0);
2245 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2248 size
= sizeof(socktype
);
2250 err
= getsockopt(sock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2251 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2252 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2253 SOCK_DGRAM
, socktype
);
2255 /* check socket family, type and protocol */
2256 size
= sizeof(WSAPROTOCOL_INFOA
);
2257 err
= getsockopt(sock
, SOL_SOCKET
, SO_PROTOCOL_INFOA
, (char *) &info
, &size
);
2258 ok(!err
,"getsockopt failed with %d\n", WSAGetLastError());
2259 ok(info
.iProtocol
== NSPROTO_IPX
, "expected protocol %d, received %d\n",
2260 NSPROTO_IPX
, info
.iProtocol
);
2261 ok(info
.iAddressFamily
== AF_IPX
, "expected family %d, received %d\n",
2262 AF_IPX
, info
.iProtocol
);
2263 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2264 SOCK_DGRAM
, info
.iSocketType
);
2267 /* SOCK_STREAM does not support NSPROTO_IPX */
2268 SetLastError(0xdeadbeef);
2269 ok(WSASocketA(AF_IPX
, SOCK_STREAM
, NSPROTO_IPX
, NULL
, 0, 0) == INVALID_SOCKET
,
2270 "WSASocketA should have failed\n");
2271 err
= WSAGetLastError();
2272 ok(err
== WSAEPROTONOSUPPORT
, "Expected 10043, received %d\n", err
);
2274 /* test extended IPX support - that is adding any number between 0 and 255
2275 * to the IPX protocol value will make it be used as IPX packet type */
2276 for(i
= 0;i
<= 255;i
+= 17)
2278 SetLastError(0xdeadbeef);
2279 sock
= WSASocketA(0, 0, NSPROTO_IPX
+ i
, NULL
, 0, 0);
2280 ok(sock
!= INVALID_SOCKET
, "Failed to create socket: %d\n",
2285 err
= getsockopt(sock
, NSPROTO_IPX
, IPX_PTYPE
, (char *) &socktype
, &size
);
2286 ok(!err
, "getsockopt failed with %d\n", WSAGetLastError());
2287 ok(socktype
== i
, "Wrong IPX packet type, expected %d received %d\n",
2295 static void test_WSADuplicateSocket(void)
2297 SOCKET source
, dupsock
;
2298 WSAPROTOCOL_INFOA info
;
2300 struct sockaddr_in addr
;
2301 int socktype
, size
, addrsize
, ret
;
2302 char teststr
[] = "TEST", buffer
[16];
2304 source
= WSASocketA(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
2305 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2307 /* test invalid parameters */
2308 SetLastError(0xdeadbeef);
2309 ok(WSADuplicateSocketA(0, 0, NULL
), "WSADuplicateSocketA should have failed\n");
2310 err
= WSAGetLastError();
2311 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2313 SetLastError(0xdeadbeef);
2314 ok(WSADuplicateSocketA(source
, 0, NULL
),
2315 "WSADuplicateSocketA should have failed\n");
2316 err
= WSAGetLastError();
2317 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2319 SetLastError(0xdeadbeef);
2320 ok(WSADuplicateSocketA(source
, ~0, &info
),
2321 "WSADuplicateSocketA should have failed\n");
2322 err
= WSAGetLastError();
2323 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2325 SetLastError(0xdeadbeef);
2326 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info
),
2327 "WSADuplicateSocketA should have failed\n");
2328 err
= WSAGetLastError();
2329 ok(err
== WSAENOTSOCK
, "expected 10038, received %d\n", err
);
2331 SetLastError(0xdeadbeef);
2332 ok(WSADuplicateSocketA(source
, GetCurrentProcessId(), NULL
),
2333 "WSADuplicateSocketA should have failed\n");
2334 err
= WSAGetLastError();
2335 ok(err
== WSAEFAULT
, "expected 10014, received %d\n", err
);
2337 /* test returned structure */
2338 memset(&info
, 0, sizeof(info
));
2339 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2340 "WSADuplicateSocketA should have worked\n");
2342 ok(info
.iProtocol
== IPPROTO_TCP
, "expected protocol %d, received %d\n",
2343 IPPROTO_TCP
, info
.iProtocol
);
2344 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2345 AF_INET
, info
.iProtocol
);
2346 ok(info
.iSocketType
== SOCK_STREAM
, "expected type %d, received %d\n",
2347 SOCK_STREAM
, info
.iSocketType
);
2349 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2350 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2352 closesocket(dupsock
);
2353 closesocket(source
);
2355 /* create a socket, bind it, duplicate it then send data on source and
2356 * receve in the duplicated socket */
2357 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2358 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2360 memset(&info
, 0, sizeof(info
));
2361 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2362 "WSADuplicateSocketA should have worked\n");
2364 ok(info
.iProtocol
== IPPROTO_UDP
, "expected protocol %d, received %d\n",
2365 IPPROTO_UDP
, info
.iProtocol
);
2366 ok(info
.iAddressFamily
== AF_INET
, "expected family %d, received %d\n",
2367 AF_INET
, info
.iProtocol
);
2368 ok(info
.iSocketType
== SOCK_DGRAM
, "expected type %d, received %d\n",
2369 SOCK_DGRAM
, info
.iSocketType
);
2371 memset(&addr
, 0, sizeof(addr
));
2372 addr
.sin_family
= AF_INET
;
2373 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2374 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2375 "bind should have worked\n");
2377 /* read address to find out the port number to be used in sendto */
2378 memset(&addr
, 0, sizeof(addr
));
2379 addrsize
= sizeof(addr
);
2380 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2381 "getsockname should have worked\n");
2382 ok(addr
.sin_port
, "socket port should be != 0\n");
2384 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2385 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2388 ret
= getsockopt(dupsock
, SOL_SOCKET
, SO_TYPE
, (char *) &socktype
, &size
);
2389 ok(!ret
, "getsockopt failed with %d\n", WSAGetLastError());
2390 ok(socktype
== SOCK_DGRAM
, "Wrong socket type, expected %d received %d\n",
2391 SOCK_DGRAM
, socktype
);
2393 set_blocking(source
, TRUE
);
2395 /* send data on source socket */
2396 addrsize
= sizeof(addr
);
2397 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2398 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2400 /* receive on duplicated socket */
2401 addrsize
= sizeof(addr
);
2402 memset(buffer
, 0, sizeof(buffer
));
2403 size
= recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
);
2404 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2405 buffer
[sizeof(teststr
) - 1] = 0;
2406 ok(!strcmp(buffer
, teststr
), "expected '%s', received '%s'\n", teststr
, buffer
);
2408 closesocket(dupsock
);
2409 closesocket(source
);
2411 /* show that the source socket need to be bound before the duplicated
2412 * socket is created */
2413 source
= WSASocketA(AF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0, 0);
2414 ok(source
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2416 memset(&info
, 0, sizeof(info
));
2417 ok(!WSADuplicateSocketA(source
, GetCurrentProcessId(), &info
),
2418 "WSADuplicateSocketA should have worked\n");
2420 dupsock
= WSASocketA(0, 0, 0, &info
, 0, 0);
2421 ok(dupsock
!= INVALID_SOCKET
, "WSASocketA should have succeeded\n");
2423 memset(&addr
, 0, sizeof(addr
));
2424 addr
.sin_family
= AF_INET
;
2425 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
2426 ok(!bind(source
, (struct sockaddr
*)&addr
, sizeof(addr
)),
2427 "bind should have worked\n");
2429 /* read address to find out the port number to be used in sendto */
2430 memset(&addr
, 0, sizeof(addr
));
2431 addrsize
= sizeof(addr
);
2432 ok(!getsockname(source
, (struct sockaddr
*) &addr
, &addrsize
),
2433 "getsockname should have worked\n");
2434 ok(addr
.sin_port
, "socket port should be != 0\n");
2436 set_blocking(source
, TRUE
);
2438 addrsize
= sizeof(addr
);
2439 size
= sendto(source
, teststr
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, addrsize
);
2440 ok(size
== sizeof(teststr
), "got %d (err %d)\n", size
, WSAGetLastError());
2442 SetLastError(0xdeadbeef);
2443 addrsize
= sizeof(addr
);
2444 memset(buffer
, 0, sizeof(buffer
));
2446 ok(recvfrom(dupsock
, buffer
, sizeof(teststr
), 0, (struct sockaddr
*) &addr
, &addrsize
) == -1,
2447 "recvfrom should have failed\n");
2448 err
= WSAGetLastError();
2449 ok(err
== WSAEINVAL
, "expected 10022, received %d\n", err
);
2452 closesocket(dupsock
);
2453 closesocket(source
);
2456 static void test_WSAAddressToStringA(void)
2458 SOCKET v6
= INVALID_SOCKET
;
2462 SOCKADDR_IN sockaddr
;
2463 CHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2465 CHAR expect1
[] = "0.0.0.0";
2466 CHAR expect2
[] = "255.255.255.255";
2467 CHAR expect3
[] = "0.0.0.0:65535";
2468 CHAR expect4
[] = "255.255.255.255:65535";
2470 SOCKADDR_IN6 sockaddr6
;
2471 CHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2473 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2474 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2475 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2477 CHAR expect6_1
[] = "::1";
2478 CHAR expect6_2
[] = "20ab::1";
2479 CHAR expect6_3
[] = "[20ab::2001]:33274";
2480 CHAR expect6_3_nt
[] = "20ab::2001@33274";
2481 CHAR expect6_3_w2k
[] = "20ab::2001";
2482 CHAR expect6_3_2
[] = "[20ab::2001%4660]:33274";
2483 CHAR expect6_3_2_nt
[] = "4660/20ab::2001@33274";
2484 CHAR expect6_3_2_w2k
[] = "20ab::2001%4660";
2485 CHAR expect6_3_3
[] = "20ab::2001%4660";
2486 CHAR expect6_3_3_nt
[] = "4660/20ab::2001";
2490 sockaddr
.sin_family
= AF_INET
;
2491 sockaddr
.sin_port
= 0;
2492 sockaddr
.sin_addr
.s_addr
= 0;
2494 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2495 GLE
= WSAGetLastError();
2496 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
2497 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2500 len
= sizeof(address
);
2502 sockaddr
.sin_family
= AF_INET
;
2503 sockaddr
.sin_port
= 0;
2504 sockaddr
.sin_addr
.s_addr
= 0;
2506 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2507 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2509 ok( !strcmp( address
, expect1
), "Expected: %s, got: %s\n", expect1
, address
);
2510 ok( len
== sizeof( expect1
), "Got size %d\n", len
);
2512 len
= sizeof(address
);
2514 sockaddr
.sin_family
= AF_INET
;
2515 sockaddr
.sin_port
= 0;
2516 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
2518 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2519 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2521 ok( !strcmp( address
, expect2
), "Expected: %s, got: %s\n", expect2
, address
);
2523 len
= sizeof(address
);
2525 sockaddr
.sin_family
= AF_INET
;
2526 sockaddr
.sin_port
= 0xffff;
2527 sockaddr
.sin_addr
.s_addr
= 0;
2529 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2530 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2532 ok( !strcmp( address
, expect3
), "Expected: %s, got: %s\n", expect3
, address
);
2534 len
= sizeof(address
);
2536 sockaddr
.sin_family
= AF_INET
;
2537 sockaddr
.sin_port
= 0xffff;
2538 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
2540 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2541 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2543 ok( !strcmp( address
, expect4
), "Expected: %s, got: %s\n", expect4
, address
);
2544 ok( len
== sizeof( expect4
), "Got size %d\n", len
);
2546 /*check to see it IPv6 is available */
2547 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
2548 if (v6
== INVALID_SOCKET
) {
2549 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2550 WSAGetLastError(), WSAEAFNOSUPPORT
);
2553 /* Test a short IPv6 address */
2554 len
= sizeof(address6
);
2556 sockaddr6
.sin6_family
= AF_INET6
;
2557 sockaddr6
.sin6_port
= 0x0000;
2558 sockaddr6
.sin6_scope_id
= 0;
2559 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
2561 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2562 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2563 ok( !strcmp( address6
, expect6_1
), "Expected: %s, got: %s\n", expect6_1
, address6
);
2564 ok( len
== sizeof(expect6_1
), "Got size %d\n", len
);
2566 /* Test a longer IPv6 address */
2567 len
= sizeof(address6
);
2569 sockaddr6
.sin6_family
= AF_INET6
;
2570 sockaddr6
.sin6_port
= 0x0000;
2571 sockaddr6
.sin6_scope_id
= 0;
2572 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
2574 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2575 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2576 ok( !strcmp( address6
, expect6_2
), "Expected: %s, got: %s\n", expect6_2
, address6
);
2577 ok( len
== sizeof(expect6_2
), "Got size %d\n", len
);
2579 /* Test IPv6 address and port number */
2580 len
= sizeof(address6
);
2582 sockaddr6
.sin6_family
= AF_INET6
;
2583 sockaddr6
.sin6_port
= 0xfa81;
2584 sockaddr6
.sin6_scope_id
= 0;
2585 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2587 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2588 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2589 ok( !strcmp( address6
, expect6_3
) ||
2590 broken( !strcmp( address6
, expect6_3_nt
) ) || /* NT4 */
2591 broken( !strcmp( address6
, expect6_3_w2k
) ), /* Win2000 */
2592 "Expected: %s, got: %s\n", expect6_3
, address6
);
2593 ok( len
== sizeof(expect6_3
) ||
2594 broken( len
== sizeof(expect6_3_nt
) ) || /* NT4 */
2595 broken( len
== sizeof(expect6_3_w2k
) ), /* Win2000 */
2596 "Got size %d\n", len
);
2598 /* Test IPv6 address, port number and scope_id */
2599 len
= sizeof(address6
);
2601 sockaddr6
.sin6_family
= AF_INET6
;
2602 sockaddr6
.sin6_port
= 0xfa81;
2603 sockaddr6
.sin6_scope_id
= 0x1234;
2604 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2606 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2607 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2608 ok( !strcmp( address6
, expect6_3_2
) ||
2609 broken( !strcmp( address6
, expect6_3_2_nt
) ) || /* NT4 */
2610 broken( !strcmp( address6
, expect6_3_2_w2k
) ), /* Win2000 */
2611 "Expected: %s, got: %s\n", expect6_3_2
, address6
);
2612 ok( len
== sizeof(expect6_3_2
) ||
2613 broken( len
== sizeof(expect6_3_2_nt
) ) || /* NT4 */
2614 broken( len
== sizeof(expect6_3_2_w2k
) ), /* Win2000 */
2615 "Got size %d\n", len
);
2617 /* Test IPv6 address and scope_id */
2618 len
= sizeof(address6
);
2620 sockaddr6
.sin6_family
= AF_INET6
;
2621 sockaddr6
.sin6_port
= 0x0000;
2622 sockaddr6
.sin6_scope_id
= 0x1234;
2623 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2625 ret
= WSAAddressToStringA( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2626 ok( !ret
, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2627 ok( !strcmp( address6
, expect6_3_3
) ||
2628 broken( !strcmp( address6
, expect6_3_3_nt
) ), /* NT4 */
2629 "Expected: %s, got: %s\n", expect6_3_3
, address6
);
2630 ok( len
== sizeof(expect6_3_3
) ||
2631 broken( len
== sizeof(expect6_3_3_nt
) ), /* NT4 */
2632 "Got size %d\n", len
);
2635 if (v6
!= INVALID_SOCKET
)
2639 static void test_WSAAddressToStringW(void)
2641 SOCKET v6
= INVALID_SOCKET
;
2645 SOCKADDR_IN sockaddr
;
2646 WCHAR address
[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2648 WCHAR expect1
[] = { '0','.','0','.','0','.','0', 0 };
2649 WCHAR expect2
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
2650 WCHAR expect3
[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
2651 WCHAR expect4
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
2652 '6', '5', '5', '3', '5', 0 };
2654 SOCKADDR_IN6 sockaddr6
;
2655 WCHAR address6
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2657 CHAR addr6_1
[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2658 CHAR addr6_2
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2659 CHAR addr6_3
[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2661 WCHAR expect6_1
[] = {':',':','1',0};
2662 WCHAR expect6_2
[] = {'2','0','a','b',':',':','1',0};
2663 WCHAR expect6_3
[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
2664 WCHAR expect6_3_nt
[] = {'2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
2665 WCHAR expect6_3_w2k
[] = {'2','0','a','b',':',':','2','0','0','1',0};
2666 WCHAR expect6_3_2
[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
2667 WCHAR expect6_3_2_nt
[] = {'4','6','6','0','/','2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
2668 WCHAR expect6_3_2_w2k
[] = {'2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',0};
2669 WCHAR expect6_3_3
[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
2670 WCHAR expect6_3_3_nt
[] = {'6','5','5','3','4','/','2','0','a','b',':',':','2','0','0','1',0};
2674 sockaddr
.sin_family
= AF_INET
;
2675 sockaddr
.sin_port
= 0;
2676 sockaddr
.sin_addr
.s_addr
= 0;
2678 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2679 GLE
= WSAGetLastError();
2680 ok( (ret
== SOCKET_ERROR
&& GLE
== WSAEFAULT
) || (ret
== 0),
2681 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2684 len
= sizeof(address
);
2686 sockaddr
.sin_family
= AF_INET
;
2687 sockaddr
.sin_port
= 0;
2688 sockaddr
.sin_addr
.s_addr
= 0;
2690 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2691 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2693 ok( !lstrcmpW( address
, expect1
), "Expected different address string\n" );
2694 ok( len
== sizeof( expect1
)/sizeof( WCHAR
), "Got size %d\n", len
);
2696 len
= sizeof(address
);
2698 sockaddr
.sin_family
= AF_INET
;
2699 sockaddr
.sin_port
= 0;
2700 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
2702 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2703 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2705 ok( !lstrcmpW( address
, expect2
), "Expected different address string\n" );
2707 len
= sizeof(address
);
2709 sockaddr
.sin_family
= AF_INET
;
2710 sockaddr
.sin_port
= 0xffff;
2711 sockaddr
.sin_addr
.s_addr
= 0;
2713 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2714 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2716 ok( !lstrcmpW( address
, expect3
), "Expected different address string\n" );
2718 len
= sizeof(address
);
2720 sockaddr
.sin_family
= AF_INET
;
2721 sockaddr
.sin_port
= 0xffff;
2722 sockaddr
.sin_addr
.s_addr
= 0xffffffff;
2724 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr
, sizeof(sockaddr
), NULL
, address
, &len
);
2725 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2727 ok( !lstrcmpW( address
, expect4
), "Expected different address string\n" );
2728 ok( len
== sizeof( expect4
)/sizeof( WCHAR
), "Got %d\n", len
);
2730 /*check to see it IPv6 is available */
2731 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
2732 if (v6
== INVALID_SOCKET
) {
2733 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2734 WSAGetLastError(), WSAEAFNOSUPPORT
);
2738 /* Test a short IPv6 address */
2739 len
= sizeof(address6
)/sizeof(WCHAR
);
2741 sockaddr6
.sin6_family
= AF_INET6
;
2742 sockaddr6
.sin6_port
= 0x0000;
2743 sockaddr6
.sin6_scope_id
= 0;
2744 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_1
, sizeof(addr6_1
));
2746 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2747 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2748 ok( !lstrcmpW( address6
, expect6_1
), "Wrong string returned\n" );
2749 ok( len
== sizeof(expect6_1
)/sizeof(WCHAR
), "Got %d\n", len
);
2751 /* Test a longer IPv6 address */
2752 len
= sizeof(address6
)/sizeof(WCHAR
);
2754 sockaddr6
.sin6_family
= AF_INET6
;
2755 sockaddr6
.sin6_port
= 0x0000;
2756 sockaddr6
.sin6_scope_id
= 0;
2757 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_2
, sizeof(addr6_2
));
2759 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2760 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2762 ok( !lstrcmpW( address6
, expect6_2
), "Wrong string returned\n" );
2763 ok( len
== sizeof(expect6_2
)/sizeof(WCHAR
), "Got %d\n", len
);
2765 /* Test IPv6 address and port number */
2766 len
= sizeof(address6
)/sizeof(WCHAR
);
2768 sockaddr6
.sin6_family
= AF_INET6
;
2769 sockaddr6
.sin6_port
= 0xfa81;
2770 sockaddr6
.sin6_scope_id
= 0;
2771 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2773 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2774 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2775 ok( !lstrcmpW( address6
, expect6_3
) ||
2776 broken( !lstrcmpW( address6
, expect6_3_nt
) ) || /* NT4 */
2777 broken( !lstrcmpW( address6
, expect6_3_w2k
) ), /* Win2000 */
2778 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3
),
2779 wine_dbgstr_w(address6
) );
2780 ok( len
== sizeof(expect6_3
)/sizeof(WCHAR
) ||
2781 broken(len
== sizeof(expect6_3_nt
)/sizeof(WCHAR
) ) || /* NT4 */
2782 broken(len
== sizeof(expect6_3_w2k
)/sizeof(WCHAR
) ), /* Win2000 */
2785 /* Test IPv6 address, port number and scope_id */
2786 len
= sizeof(address6
)/sizeof(WCHAR
);
2788 sockaddr6
.sin6_family
= AF_INET6
;
2789 sockaddr6
.sin6_port
= 0xfa81;
2790 sockaddr6
.sin6_scope_id
= 0x1234;
2791 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2793 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2794 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2795 ok( !lstrcmpW( address6
, expect6_3_2
) ||
2796 broken( !lstrcmpW( address6
, expect6_3_2_nt
) ) || /* NT4 */
2797 broken( !lstrcmpW( address6
, expect6_3_2_w2k
) ), /* Win2000 */
2798 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2
),
2799 wine_dbgstr_w(address6
) );
2800 ok( len
== sizeof(expect6_3_2
)/sizeof(WCHAR
) ||
2801 broken( len
== sizeof(expect6_3_2_nt
)/sizeof(WCHAR
) ) || /* NT4 */
2802 broken( len
== sizeof(expect6_3_2_w2k
)/sizeof(WCHAR
) ), /* Win2000 */
2805 /* Test IPv6 address and scope_id */
2806 len
= sizeof(address6
)/sizeof(WCHAR
);
2808 sockaddr6
.sin6_family
= AF_INET6
;
2809 sockaddr6
.sin6_port
= 0x0000;
2810 sockaddr6
.sin6_scope_id
= 0xfffe;
2811 memcpy (sockaddr6
.sin6_addr
.s6_addr
, addr6_3
, sizeof(addr6_3
));
2813 ret
= WSAAddressToStringW( (SOCKADDR
*)&sockaddr6
, sizeof(sockaddr6
), NULL
, address6
, &len
);
2814 ok( !ret
, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2815 ok( !lstrcmpW( address6
, expect6_3_3
) ||
2816 broken( !lstrcmpW( address6
, expect6_3_3_nt
) ), /* NT4 */
2817 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3
),
2818 wine_dbgstr_w(address6
) );
2819 ok( len
== sizeof(expect6_3_3
)/sizeof(WCHAR
) ||
2820 broken( len
== sizeof(expect6_3_3_nt
)/sizeof(WCHAR
) ), /* NT4 */
2824 if (v6
!= INVALID_SOCKET
)
2828 static void test_WSAStringToAddressA(void)
2831 SOCKADDR_IN sockaddr
;
2832 SOCKADDR_IN6 sockaddr6
;
2835 CHAR address1
[] = "0.0.0.0";
2836 CHAR address2
[] = "127.127.127.127";
2837 CHAR address3
[] = "255.255.255.255";
2838 CHAR address4
[] = "127.127.127.127:65535";
2839 CHAR address5
[] = "255.255.255.255:65535";
2840 CHAR address6
[] = "::1";
2841 CHAR address7
[] = "[::1]";
2842 CHAR address8
[] = "[::1]:65535";
2845 sockaddr
.sin_family
= AF_INET
;
2847 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2848 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
2849 WSAGetLastError() );
2851 len
= sizeof(sockaddr
);
2852 sockaddr
.sin_port
= 0;
2853 sockaddr
.sin_addr
.s_addr
= 0;
2855 ret
= WSAStringToAddressA( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2856 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
2857 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
2859 len
= sizeof(sockaddr
);
2860 sockaddr
.sin_port
= 0;
2861 sockaddr
.sin_addr
.s_addr
= 0;
2863 ret
= WSAStringToAddressA( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2864 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
2865 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
2867 len
= sizeof(sockaddr
);
2868 sockaddr
.sin_port
= 0;
2869 sockaddr
.sin_addr
.s_addr
= 0;
2871 ret
= WSAStringToAddressA( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2872 GLE
= WSAGetLastError();
2873 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
2874 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2875 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
2877 len
= sizeof(sockaddr
);
2878 sockaddr
.sin_port
= 0;
2879 sockaddr
.sin_addr
.s_addr
= 0;
2881 ret
= WSAStringToAddressA( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2882 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
2883 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
2885 len
= sizeof(sockaddr
);
2886 sockaddr
.sin_port
= 0;
2887 sockaddr
.sin_addr
.s_addr
= 0;
2889 ret
= WSAStringToAddressA( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2890 GLE
= WSAGetLastError();
2891 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
2892 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2893 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE
);
2895 len
= sizeof(sockaddr6
);
2896 memset(&sockaddr6
, 0, len
);
2897 sockaddr6
.sin6_family
= AF_INET6
;
2899 ret
= WSAStringToAddressA( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2901 GLE
= WSAGetLastError();
2902 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2903 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
2905 len
= sizeof(sockaddr6
);
2906 memset(&sockaddr6
, 0, len
);
2907 sockaddr6
.sin6_family
= AF_INET6
;
2909 ret
= WSAStringToAddressA( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2911 GLE
= WSAGetLastError();
2912 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2913 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
2915 len
= sizeof(sockaddr6
);
2916 memset(&sockaddr6
, 0, len
);
2917 sockaddr6
.sin6_family
= AF_INET6
;
2919 ret
= WSAStringToAddressA( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
2921 GLE
= WSAGetLastError();
2922 ok( (ret
== 0 && sockaddr6
.sin6_port
== 0xffff) ||
2923 (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
2924 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE
);
2928 static void test_WSAStringToAddressW(void)
2931 SOCKADDR_IN sockaddr
, *sin
;
2932 SOCKADDR_IN6 sockaddr6
;
2933 SOCKADDR_STORAGE sockaddr_storage
;
2936 WCHAR address1
[] = { '0','.','0','.','0','.','0', 0 };
2937 WCHAR address2
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
2938 WCHAR address3
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
2939 WCHAR address4
[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
2940 ':', '6', '5', '5', '3', '5', 0 };
2941 WCHAR address5
[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
2942 '6', '5', '5', '3', '5', 0 };
2943 WCHAR address6
[] = {':',':','1','\0'};
2944 WCHAR address7
[] = {'[',':',':','1',']','\0'};
2945 WCHAR address8
[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
2948 sockaddr
.sin_family
= AF_INET
;
2950 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2951 ok( ret
== SOCKET_ERROR
, "WSAStringToAddressW() failed unexpectedly: %d\n",
2952 WSAGetLastError() );
2954 len
= sizeof(sockaddr
);
2955 sockaddr
.sin_port
= 0;
2956 sockaddr
.sin_addr
.s_addr
= 0;
2958 ret
= WSAStringToAddressW( address1
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2959 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0,
2960 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2962 len
= sizeof(sockaddr
);
2963 sockaddr
.sin_port
= 0;
2964 sockaddr
.sin_addr
.s_addr
= 0;
2966 ret
= WSAStringToAddressW( address2
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2967 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f,
2968 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2970 len
= sizeof(sockaddr
);
2971 sockaddr
.sin_port
= 0;
2972 sockaddr
.sin_addr
.s_addr
= 0;
2974 ret
= WSAStringToAddressW( address3
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2975 GLE
= WSAGetLastError();
2976 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff) ||
2977 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2978 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
2980 len
= sizeof(sockaddr
);
2981 sockaddr
.sin_port
= 0;
2982 sockaddr
.sin_addr
.s_addr
= 0;
2984 ret
= WSAStringToAddressW( address4
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2985 ok( !ret
&& sockaddr
.sin_addr
.s_addr
== 0x7f7f7f7f && sockaddr
.sin_port
== 0xffff,
2986 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2988 len
= sizeof(sockaddr
);
2989 sockaddr
.sin_port
= 0;
2990 sockaddr
.sin_addr
.s_addr
= 0;
2992 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)&sockaddr
, &len
);
2993 ok( (ret
== 0 && sockaddr
.sin_addr
.s_addr
== 0xffffffff && sockaddr
.sin_port
== 0xffff) ||
2994 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
2995 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
2997 /* Test with a larger buffer than necessary */
2998 len
= sizeof(sockaddr_storage
);
2999 sin
= (SOCKADDR_IN
*)&sockaddr_storage
;
3001 sin
->sin_addr
.s_addr
= 0;
3003 ret
= WSAStringToAddressW( address5
, AF_INET
, NULL
, (SOCKADDR
*)sin
, &len
);
3004 ok( (ret
== 0 && sin
->sin_addr
.s_addr
== 0xffffffff && sin
->sin_port
== 0xffff) ||
3005 (ret
== SOCKET_ERROR
&& (GLE
== ERROR_INVALID_PARAMETER
|| GLE
== WSAEINVAL
)),
3006 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE
);
3007 ok( len
== sizeof(SOCKADDR_IN
) ||
3008 broken(len
== sizeof(SOCKADDR_STORAGE
)) /* NT4/2k */,
3009 "unexpected length %d\n", len
);
3011 len
= sizeof(sockaddr6
);
3012 memset(&sockaddr6
, 0, len
);
3013 sockaddr6
.sin6_family
= AF_INET6
;
3015 ret
= WSAStringToAddressW( address6
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3017 GLE
= WSAGetLastError();
3018 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3019 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
3021 len
= sizeof(sockaddr6
);
3022 memset(&sockaddr6
, 0, len
);
3023 sockaddr6
.sin6_family
= AF_INET6
;
3025 ret
= WSAStringToAddressW( address7
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3027 GLE
= WSAGetLastError();
3028 ok( ret
== 0 || (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3029 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
3031 len
= sizeof(sockaddr6
);
3032 memset(&sockaddr6
, 0, len
);
3033 sockaddr6
.sin6_family
= AF_INET6
;
3035 ret
= WSAStringToAddressW( address8
, AF_INET6
, NULL
, (SOCKADDR
*)&sockaddr6
,
3037 GLE
= WSAGetLastError();
3038 ok( (ret
== 0 && sockaddr6
.sin6_port
== 0xffff) ||
3039 (ret
== SOCKET_ERROR
&& GLE
== WSAEINVAL
),
3040 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE
);
3044 static DWORD WINAPI
SelectReadThread(void *param
)
3046 select_thread_params
*par
= param
;
3049 struct sockaddr_in addr
;
3050 struct timeval select_timeout
;
3053 FD_SET(par
->s
, &readfds
);
3054 select_timeout
.tv_sec
=5;
3055 select_timeout
.tv_usec
=0;
3056 addr
.sin_family
= AF_INET
;
3057 addr
.sin_addr
.s_addr
= inet_addr(SERVERIP
);
3058 addr
.sin_port
= htons(SERVERPORT
);
3060 do_bind(par
->s
, (struct sockaddr
*)&addr
, sizeof(addr
));
3061 wsa_ok(listen(par
->s
, SOMAXCONN
), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
3063 SetEvent(server_ready
);
3064 ret
= select(par
->s
+1, &readfds
, NULL
, NULL
, &select_timeout
);
3065 par
->ReadKilled
= (ret
== 1);
3070 static void test_errors(void)
3073 SOCKADDR_IN SockAddr
;
3076 WSASetLastError(NO_ERROR
);
3077 sock
= socket(PF_INET
, SOCK_STREAM
, 0);
3078 ok( (sock
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3079 memset(&SockAddr
, 0, sizeof(SockAddr
));
3080 SockAddr
.sin_family
= AF_INET
;
3081 SockAddr
.sin_port
= htons(6924);
3082 SockAddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3084 ret
= connect(sock
, (PSOCKADDR
)&SockAddr
, sizeof(SockAddr
));
3085 ok( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got: %d\n", ret
);
3086 if (ret
== SOCKET_ERROR
)
3088 err
= WSAGetLastError();
3089 ok( (err
== WSAECONNREFUSED
), "expected WSAECONNREFUSED, got: %d\n", err
);
3094 fd_set set
= {1, {sock
}};
3097 timeval
.tv_usec
= 50000;
3099 ret
= select(1, NULL
, &set
, NULL
, &timeval
);
3100 ok( (ret
== 0), "expected 0 (timeout), got: %d\n", ret
);
3103 ret
= closesocket(sock
);
3104 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
3107 static void test_listen(void)
3110 int ret
, acceptc
, olen
= sizeof(acceptc
);
3111 struct sockaddr_in address
;
3113 memset(&address
, 0, sizeof(address
));
3114 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3115 address
.sin_family
= AF_INET
;
3116 address
.sin_port
= htons(SERVERPORT
);
3118 /* invalid socket tests */
3119 SetLastError(0xdeadbeef);
3120 ok ((listen(0, 0) == SOCKET_ERROR
), "listen did not fail\n");
3121 ret
= WSAGetLastError();
3122 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
3124 SetLastError(0xdeadbeef);
3125 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR
), "listen did not fail\n");
3126 ret
= WSAGetLastError();
3127 ok (ret
== WSAENOTSOCK
, "expected 10038, received %d\n", ret
);
3130 fdA
= socket(AF_INET
, SOCK_STREAM
, 0);
3131 ok ((fdA
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3133 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
3134 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3136 SetLastError(0xdeadbeef);
3137 ok ((listen(fdA
, -2) == SOCKET_ERROR
), "listen did not fail\n");
3138 ret
= WSAGetLastError();
3139 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3141 SetLastError(0xdeadbeef);
3142 ok ((listen(fdA
, 1) == SOCKET_ERROR
), "listen did not fail\n");
3143 ret
= WSAGetLastError();
3144 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3146 SetLastError(0xdeadbeef);
3147 ok ((listen(fdA
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3148 ret
= WSAGetLastError();
3149 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3151 ok (!bind(fdA
, (struct sockaddr
*) &address
, sizeof(address
)), "bind failed\n");
3153 SetLastError(0xdeadbeef);
3154 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
3155 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3158 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
3159 ok (!ret
, "getsockopt failed\n");
3160 ok (acceptc
== 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc
);
3162 ok (!listen(fdA
, 0), "listen failed\n");
3163 ok (!listen(fdA
, SOMAXCONN
), "double listen failed\n");
3166 ret
= getsockopt(fdA
, SOL_SOCKET
, SO_ACCEPTCONN
, (char*)&acceptc
, &olen
);
3167 ok (!ret
, "getsockopt failed\n");
3168 ok (acceptc
== 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc
);
3170 SetLastError(0xdeadbeef);
3171 ok ((listen(fdB
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3172 ret
= WSAGetLastError();
3173 ok (ret
== WSAEINVAL
, "expected 10022, received %d\n", ret
);
3175 ret
= closesocket(fdB
);
3176 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3178 fdB
= socket(AF_INET
, SOCK_STREAM
, 0);
3179 ok ((fdB
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3181 SetLastError(0xdeadbeef);
3182 ok (bind(fdB
, (struct sockaddr
*) &address
, sizeof(address
)), "bind should have failed\n");
3183 ret
= WSAGetLastError();
3184 ok (ret
== WSAEADDRINUSE
, "expected 10048, received %d\n", ret
);
3186 ret
= closesocket(fdA
);
3187 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3188 ret
= closesocket(fdB
);
3189 ok (ret
== 0, "closesocket failed unexpectedly: %d\n", ret
);
3192 static void test_select(void)
3194 SOCKET fdRead
, fdWrite
;
3195 fd_set readfds
, writefds
, exceptfds
;
3199 struct timeval select_timeout
;
3200 select_thread_params thread_params
;
3201 HANDLE thread_handle
;
3204 fdRead
= socket(AF_INET
, SOCK_STREAM
, 0);
3205 ok( (fdRead
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3206 fdWrite
= socket(AF_INET
, SOCK_STREAM
, 0);
3207 ok( (fdWrite
!= INVALID_SOCKET
), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3211 FD_ZERO(&exceptfds
);
3212 FD_SET(fdRead
, &readfds
);
3213 FD_SET(fdWrite
, &writefds
);
3214 FD_SET(fdRead
, &exceptfds
);
3215 FD_SET(fdWrite
, &exceptfds
);
3216 select_timeout
.tv_sec
=0;
3217 select_timeout
.tv_usec
=500;
3220 if (fdWrite
> maxfd
)
3224 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3225 ok ( (ret
== 0), "select should not return any socket handles\n");
3226 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3228 ok ( !FD_ISSET(fdWrite
, &writefds
), "FD should not be set\n");
3230 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3231 ok ( !FD_ISSET(fdWrite
, &exceptfds
), "FD should not be set\n");
3233 ok ((listen(fdWrite
, SOMAXCONN
) == SOCKET_ERROR
), "listen did not fail\n");
3234 ret
= closesocket(fdWrite
);
3235 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3237 thread_params
.s
= fdRead
;
3238 thread_params
.ReadKilled
= FALSE
;
3239 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
3240 thread_handle
= CreateThread (NULL
, 0, SelectReadThread
, &thread_params
, 0, &id
);
3241 ok ( (thread_handle
!= NULL
), "CreateThread failed unexpectedly: %d\n", GetLastError());
3243 WaitForSingleObject (server_ready
, INFINITE
);
3245 ret
= closesocket(fdRead
);
3246 ok ( (ret
== 0), "closesocket failed unexpectedly: %d\n", ret
);
3248 WaitForSingleObject (thread_handle
, 1000);
3249 ok ( (thread_params
.ReadKilled
) ||
3250 broken(thread_params
.ReadKilled
== 0), /*Win98*/
3251 "closesocket did not wakeup select\n");
3252 ret
= recv(fdRead
, &buffer
, 1, MSG_PEEK
);
3253 ok( (ret
== -1), "peek at closed socket expected -1 got %d\n", ret
);
3255 /* Test selecting invalid handles */
3258 FD_ZERO(&exceptfds
);
3261 ret
= select(maxfd
+1, 0, 0, 0, &select_timeout
);
3262 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3263 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3266 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3267 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3268 ok ( WSAGetLastError() == WSAEINVAL
, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3270 FD_SET(INVALID_SOCKET
, &readfds
);
3272 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3273 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3274 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3275 ok ( !FD_ISSET(fdRead
, &readfds
), "FD should not be set\n");
3278 FD_SET(INVALID_SOCKET
, &writefds
);
3280 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3281 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3282 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3283 ok ( !FD_ISSET(fdRead
, &writefds
), "FD should not be set\n");
3286 FD_SET(INVALID_SOCKET
, &exceptfds
);
3288 ret
= select(maxfd
+1, &readfds
, &writefds
, &exceptfds
, &select_timeout
);
3289 ok ( (ret
== SOCKET_ERROR
), "expected SOCKET_ERROR, got %i\n", ret
);
3290 ok ( WSAGetLastError() == WSAENOTSOCK
, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3291 ok ( !FD_ISSET(fdRead
, &exceptfds
), "FD should not be set\n");
3294 static DWORD WINAPI
AcceptKillThread(void *param
)
3296 select_thread_params
*par
= param
;
3297 struct sockaddr_in address
;
3298 int len
= sizeof(address
);
3299 SOCKET client_socket
;
3301 SetEvent(server_ready
);
3302 client_socket
= accept(par
->s
, (struct sockaddr
*) &address
, &len
);
3303 if (client_socket
!= INVALID_SOCKET
)
3304 closesocket(client_socket
);
3305 par
->ReadKilled
= (client_socket
== INVALID_SOCKET
);
3310 static int CALLBACK
AlwaysDeferConditionFunc(LPWSABUF lpCallerId
, LPWSABUF lpCallerData
, LPQOS pQos
,
3311 LPQOS lpGQOS
, LPWSABUF lpCalleeId
, LPWSABUF lpCalleeData
,
3312 GROUP
*g
, DWORD_PTR dwCallbackData
)
3317 static SOCKET
setup_server_socket(struct sockaddr_in
*addr
, int *len
)
3320 SOCKET server_socket
;
3322 server_socket
= socket(AF_INET
, SOCK_STREAM
, 0);
3323 if (server_socket
== INVALID_SOCKET
)
3325 trace("error creating server socket: %d\n", WSAGetLastError());
3326 return INVALID_SOCKET
;
3330 ret
= setsockopt(server_socket
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
3333 trace("error setting SO_REUSEADDR: %d\n", WSAGetLastError());
3334 closesocket(server_socket
);
3335 return INVALID_SOCKET
;
3338 ret
= bind(server_socket
, (struct sockaddr
*)addr
, *len
);
3341 trace("error binding server socket: %d\n", WSAGetLastError());
3344 ret
= getsockname(server_socket
, (struct sockaddr
*)addr
, len
);
3347 skip("failed to lookup bind address: %d\n", WSAGetLastError());
3348 closesocket(server_socket
);
3349 return INVALID_SOCKET
;
3352 ret
= listen(server_socket
, 5);
3355 trace("error making server socket listen: %d\n", WSAGetLastError());
3356 closesocket(server_socket
);
3357 return INVALID_SOCKET
;
3360 return server_socket
;
3363 static SOCKET
setup_connector_socket(struct sockaddr_in
*addr
, int len
)
3368 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
3369 ok(connector
!= INVALID_SOCKET
, "failed to create connector socket %d\n", WSAGetLastError());
3371 ret
= connect(connector
, (struct sockaddr
*)addr
, len
);
3372 ok(!ret
, "connecting to accepting socket failed %d\n", WSAGetLastError());
3377 static void test_accept(void)
3380 SOCKET server_socket
, accepted
= INVALID_SOCKET
, connector
;
3381 struct sockaddr_in address
;
3382 SOCKADDR_STORAGE ss
;
3384 select_thread_params thread_params
;
3385 HANDLE thread_handle
= NULL
;
3388 memset(&address
, 0, sizeof(address
));
3389 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
3390 address
.sin_family
= AF_INET
;
3392 socklen
= sizeof(address
);
3393 server_socket
= setup_server_socket(&address
, &socklen
);
3394 if (server_socket
== INVALID_SOCKET
)
3396 trace("error creating server socket: %d\n", WSAGetLastError());
3400 connector
= setup_connector_socket(&address
, socklen
);
3401 if (connector
== INVALID_SOCKET
) goto done
;
3403 trace("Blocking accept next\n");
3405 accepted
= WSAAccept(server_socket
, NULL
, NULL
, AlwaysDeferConditionFunc
, 0);
3406 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
3408 accepted
= accept(server_socket
, NULL
, 0);
3409 ok(accepted
!= INVALID_SOCKET
, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
3411 server_ready
= CreateEventA(NULL
, TRUE
, FALSE
, NULL
);
3412 if (server_ready
== INVALID_HANDLE_VALUE
)
3414 trace("error creating event: %d\n", GetLastError());
3418 thread_params
.s
= server_socket
;
3419 thread_params
.ReadKilled
= FALSE
;
3420 thread_handle
= CreateThread(NULL
, 0, AcceptKillThread
, &thread_params
, 0, &id
);
3421 if (thread_handle
== NULL
)
3423 trace("error creating thread: %d\n", GetLastError());
3427 WaitForSingleObject(server_ready
, INFINITE
);
3429 ret
= closesocket(server_socket
);
3432 trace("closesocket failed: %d\n", WSAGetLastError());
3436 WaitForSingleObject(thread_handle
, 1000);
3437 ok(thread_params
.ReadKilled
|| broken(!thread_params
.ReadKilled
) /* Win98/ME, after accept */,
3438 "closesocket did not wakeup accept\n");
3440 closesocket(accepted
);
3441 closesocket(connector
);
3442 accepted
= connector
= server_socket
= INVALID_SOCKET
;
3444 socklen
= sizeof(address
);
3445 server_socket
= setup_server_socket(&address
, &socklen
);
3446 if (server_socket
== INVALID_SOCKET
) goto done
;
3448 connector
= setup_connector_socket(&address
, socklen
);
3449 if (connector
== INVALID_SOCKET
) goto done
;
3452 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
3453 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
3454 ok(!socklen
, "got %d\n", socklen
);
3455 closesocket(connector
);
3456 connector
= INVALID_SOCKET
;
3458 socklen
= sizeof(address
);
3459 connector
= setup_connector_socket(&address
, socklen
);
3460 if (connector
== INVALID_SOCKET
) goto done
;
3462 accepted
= WSAAccept(server_socket
, NULL
, NULL
, NULL
, 0);
3463 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3464 closesocket(accepted
);
3465 closesocket(connector
);
3466 accepted
= connector
= INVALID_SOCKET
;
3468 socklen
= sizeof(address
);
3469 connector
= setup_connector_socket(&address
, socklen
);
3470 if (connector
== INVALID_SOCKET
) goto done
;
3472 socklen
= sizeof(ss
);
3473 memset(&ss
, 0, sizeof(ss
));
3474 accepted
= WSAAccept(server_socket
, (struct sockaddr
*)&ss
, &socklen
, NULL
, 0);
3475 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3476 ok(socklen
!= sizeof(ss
), "unexpected length\n");
3477 ok(ss
.ss_family
, "family not set\n");
3478 closesocket(accepted
);
3479 closesocket(connector
);
3480 accepted
= connector
= INVALID_SOCKET
;
3482 socklen
= sizeof(address
);
3483 connector
= setup_connector_socket(&address
, socklen
);
3484 if (connector
== INVALID_SOCKET
) goto done
;
3487 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
3488 ok(accepted
== INVALID_SOCKET
&& WSAGetLastError() == WSAEFAULT
, "got %d\n", WSAGetLastError());
3489 ok(!socklen
, "got %d\n", socklen
);
3490 closesocket(connector
);
3491 accepted
= connector
= INVALID_SOCKET
;
3493 socklen
= sizeof(address
);
3494 connector
= setup_connector_socket(&address
, socklen
);
3495 if (connector
== INVALID_SOCKET
) goto done
;
3497 accepted
= accept(server_socket
, NULL
, NULL
);
3498 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3499 closesocket(accepted
);
3500 closesocket(connector
);
3501 accepted
= connector
= INVALID_SOCKET
;
3503 socklen
= sizeof(address
);
3504 connector
= setup_connector_socket(&address
, socklen
);
3505 if (connector
== INVALID_SOCKET
) goto done
;
3507 socklen
= sizeof(ss
);
3508 memset(&ss
, 0, sizeof(ss
));
3509 accepted
= accept(server_socket
, (struct sockaddr
*)&ss
, &socklen
);
3510 ok(accepted
!= INVALID_SOCKET
, "Failed to accept connection, %d\n", WSAGetLastError());
3511 ok(socklen
!= sizeof(ss
), "unexpected length\n");
3512 ok(ss
.ss_family
, "family not set\n");
3515 if (accepted
!= INVALID_SOCKET
)
3516 closesocket(accepted
);
3517 if (connector
!= INVALID_SOCKET
)
3518 closesocket(connector
);
3519 if (thread_handle
!= NULL
)
3520 CloseHandle(thread_handle
);
3521 if (server_ready
!= INVALID_HANDLE_VALUE
)
3522 CloseHandle(server_ready
);
3523 if (server_socket
!= INVALID_SOCKET
)
3524 closesocket(server_socket
);
3527 static void test_extendedSocketOptions(void)
3531 struct sockaddr_in sa
;
3532 int sa_len
= sizeof(struct sockaddr_in
);
3533 int optval
, optlen
= sizeof(int), ret
;
3537 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
3538 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
3542 memset(&sa
, 0, sa_len
);
3544 sa
.sin_family
= AF_INET
;
3545 sa
.sin_port
= htons(0);
3546 sa
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
3548 if((sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
3549 trace("Creating the socket failed: %d\n", WSAGetLastError());
3554 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
3555 trace("Failed to bind socket: %d\n", WSAGetLastError());
3561 ret
= getsockopt(sock
, SOL_SOCKET
, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3563 ok(ret
== 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret
);
3564 ok((optval
== 65507) || (optval
== 65527),
3565 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval
);
3567 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
3568 SetLastError(0xdeadbeef);
3569 optval
= 0xdeadbeef;
3570 optlen
= sizeof(int);
3571 ret
= getsockopt(sock
, 0xffffffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3572 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3573 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3574 ret
, WSAGetLastError(), optval
, optval
);
3576 /* more invalid values for level */
3577 SetLastError(0xdeadbeef);
3578 optval
= 0xdeadbeef;
3579 optlen
= sizeof(int);
3580 ret
= getsockopt(sock
, 0x1234ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3581 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3582 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3583 ret
, WSAGetLastError(), optval
, optval
);
3585 SetLastError(0xdeadbeef);
3586 optval
= 0xdeadbeef;
3587 optlen
= sizeof(int);
3588 ret
= getsockopt(sock
, 0x8000ffff, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3589 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3590 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3591 ret
, WSAGetLastError(), optval
, optval
);
3593 SetLastError(0xdeadbeef);
3594 optval
= 0xdeadbeef;
3595 optlen
= sizeof(int);
3596 ret
= getsockopt(sock
, 0x00008000, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3597 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3598 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3599 ret
, WSAGetLastError(), optval
, optval
);
3601 SetLastError(0xdeadbeef);
3602 optval
= 0xdeadbeef;
3603 optlen
= sizeof(int);
3604 ret
= getsockopt(sock
, 0x00000800, SO_MAX_MSG_SIZE
, (char *)&optval
, &optlen
);
3605 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAEINVAL
),
3606 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3607 ret
, WSAGetLastError(), optval
, optval
);
3609 SetLastError(0xdeadbeef);
3610 optlen
= sizeof(LINGER
);
3611 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
3612 ok( (ret
== SOCKET_ERROR
) && (WSAGetLastError() == WSAENOPROTOOPT
),
3613 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
3614 ret
, WSAGetLastError());
3617 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
3618 trace("Creating the socket failed: %d\n", WSAGetLastError());
3623 if(bind(sock
, (struct sockaddr
*) &sa
, sa_len
) < 0){
3624 trace("Failed to bind socket: %d\n", WSAGetLastError());
3630 ret
= getsockopt(sock
, SOL_SOCKET
, SO_LINGER
, (char *)&linger_val
, &optlen
);
3631 ok(ret
== 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret
);
3633 optlen
= sizeof(BOOL
);
3634 ret
= getsockopt(sock
, SOL_SOCKET
, SO_DONTLINGER
, (char *)&bool_opt_val
, &optlen
);
3635 ok(ret
== 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret
);
3636 ok((linger_val
.l_onoff
&& !bool_opt_val
) || (!linger_val
.l_onoff
&& bool_opt_val
),
3637 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
3638 bool_opt_val
, linger_val
.l_onoff
);
3644 static void test_getsockname(void)
3648 struct sockaddr_in sa_set
, sa_get
;
3649 int sa_set_len
= sizeof(struct sockaddr_in
);
3650 int sa_get_len
= sa_set_len
;
3651 static const unsigned char null_padding
[] = {0,0,0,0,0,0,0,0};
3654 if(WSAStartup(MAKEWORD(2,0), &wsa
)){
3655 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
3659 memset(&sa_set
, 0, sa_set_len
);
3661 sa_set
.sin_family
= AF_INET
;
3662 sa_set
.sin_port
= htons(0);
3663 sa_set
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
3665 if((sock
= socket(PF_INET
, SOCK_STREAM
, IPPROTO_IP
)) == INVALID_SOCKET
) {
3666 trace("Creating the socket failed: %d\n", WSAGetLastError());
3672 if (getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) == 0)
3673 ok(0, "getsockname on unbound socket should fail\n");
3675 ok(WSAGetLastError() == WSAEINVAL
, "getsockname on unbound socket "
3676 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL
);
3677 ok(memcmp(&sa_get
, &sa_set
, sizeof(sa_get
)) == 0,
3678 "failed getsockname modified sockaddr when it shouldn't\n");
3681 if(bind(sock
, (struct sockaddr
*) &sa_set
, sa_set_len
) < 0){
3682 trace("Failed to bind socket: %d\n", WSAGetLastError());
3688 if(getsockname(sock
, (struct sockaddr
*) &sa_get
, &sa_get_len
) != 0){
3689 trace("Failed to call getsockname: %d\n", WSAGetLastError());
3695 ret
= memcmp(sa_get
.sin_zero
, null_padding
, 8);
3696 ok(ret
== 0 || broken(ret
!= 0), /* NT4 */
3697 "getsockname did not zero the sockaddr_in structure\n");
3703 static void test_dns(void)
3714 h
= gethostbyname("");
3715 ok(h
!= NULL
, "gethostbyname(\"\") failed with %d\n", h_errno
);
3717 /* Use an address with valid alias names if possible */
3718 h
= gethostbyname("source.winehq.org");
3721 skip("Can't test the hostent structure because gethostbyname failed\n");
3725 /* The returned struct must be allocated in a very strict way. First we need to
3726 * count how many aliases there are because they must be located right after
3727 * the struct hostent size. Knowing the amount of aliases we know the exact
3728 * location of the first IP returned. Rule valid for >= XP, for older OS's
3729 * it's somewhat the opposite. */
3731 if(h
->h_addr_list
== addr
.mem
) /* <= W2K */
3733 win_skip("Skipping hostent tests since this OS is unsupported\n");
3737 ok(h
->h_aliases
== addr
.mem
,
3738 "hostent->h_aliases should be in %p, it is in %p\n", addr
.mem
, h
->h_aliases
);
3740 for(ptr
= h
->h_aliases
, acount
= 1; *ptr
; ptr
++) acount
++;
3741 addr
.chr
+= sizeof(*ptr
) * acount
;
3742 ok(h
->h_addr_list
== addr
.mem
,
3743 "hostent->h_addr_list should be in %p, it is in %p\n", addr
.mem
, h
->h_addr_list
);
3745 for(ptr
= h
->h_addr_list
, acount
= 1; *ptr
; ptr
++) acount
++;
3747 addr
.chr
+= sizeof(*ptr
) * acount
;
3748 ok(h
->h_addr_list
[0] == addr
.mem
,
3749 "hostent->h_addr_list[0] should be in %p, it is in %p\n", addr
.mem
, h
->h_addr_list
[0]);
3752 /* Our winsock headers don't define gethostname because it conflicts with the
3753 * definition in unistd.h. Define it here to get rid of the warning. */
3755 int WINAPI
gethostname(char *name
, int namelen
);
3757 static void test_gethostbyname_hack(void)
3761 static BYTE loopback
[] = {127, 0, 0, 1};
3762 static BYTE magic_loopback
[] = {127, 12, 34, 56};
3765 ret
= gethostname(name
, 256);
3766 ok(ret
== 0, "gethostname() call failed: %d\n", WSAGetLastError());
3768 he
= gethostbyname("localhost");
3769 ok(he
!= NULL
, "gethostbyname(\"localhost\") failed: %d\n", h_errno
);
3772 if(he
->h_length
!= 4)
3774 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
3778 ok(memcmp(he
->h_addr_list
[0], loopback
, he
->h_length
) == 0,
3779 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
3780 he
->h_addr_list
[0][0], he
->h_addr_list
[0][1], he
->h_addr_list
[0][2],
3781 he
->h_addr_list
[0][3]);
3784 if(strcmp(name
, "localhost") == 0)
3786 skip("hostname seems to be \"localhost\", skipping test.\n");
3791 he
= gethostbyname(name
);
3792 ok(he
!= NULL
, "gethostbyname(\"%s\") failed: %d\n", name
, h_errno
);
3795 if(he
->h_length
!= 4)
3797 skip("h_length is %d, not IPv4, skipping test.\n", he
->h_length
);
3801 if (he
->h_addr_list
[0][0] == 127)
3803 ok(memcmp(he
->h_addr_list
[0], magic_loopback
, he
->h_length
) == 0,
3804 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
3805 name
, he
->h_addr_list
[0][0], he
->h_addr_list
[0][1],
3806 he
->h_addr_list
[0][2], he
->h_addr_list
[0][3]);
3810 gethostbyname("nonexistent.winehq.org");
3811 /* Don't check for the return value, as some braindead ISPs will kindly
3812 * resolve nonexistent host names to addresses of the ISP's spam pages. */
3815 static void test_inet_addr(void)
3819 addr
= inet_addr(NULL
);
3820 ok(addr
== INADDR_NONE
, "inet_addr succeeded unexpectedly\n");
3823 static void test_addr_to_print(void)
3829 struct in6_addr in6
;
3831 u_long addr0_Num
= 0x00000000;
3832 PCSTR addr0_Str
= "0.0.0.0";
3833 u_long addr1_Num
= 0x20201015;
3834 PCSTR addr1_Str
= "21.16.32.32";
3835 u_char addr2_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
3836 PCSTR addr2_Str
= "::fffe:cc98:bd74";
3837 u_char addr3_Num
[16] = {0x20,0x30,0xa4,0xb1};
3838 PCSTR addr3_Str
= "2030:a4b1::";
3839 u_char addr4_Num
[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
3840 PCSTR addr4_Str
= "::204.152.189.116";
3842 /* Test IPv4 addresses */
3843 in
.s_addr
= addr0_Num
;
3845 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
3846 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
3847 ok(!strcmp(pdst
, addr0_Str
),"Address %s != %s\n", pdst
, addr0_Str
);
3849 /* Test that inet_ntoa and inet_ntop return the same value */
3850 in
.S_un
.S_addr
= addr1_Num
;
3851 pdst
= inet_ntoa(*((struct in_addr
*)&in
.s_addr
));
3852 ok(pdst
!= NULL
, "inet_ntoa failed %s\n", dst
);
3853 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
3855 /* InetNtop became available in Vista and Win2008 */
3858 win_skip("InetNtop not present, not executing tests\n");
3862 /* Second part of test */
3863 pdst
= pInetNtop(AF_INET
,(void*)&in
.s_addr
, dst
, sizeof(dst
));
3864 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst
);
3865 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
3867 /* Test invalid parm conditions */
3868 pdst
= pInetNtop(1, (void*)&in
.s_addr
, dst
, sizeof(dst
));
3869 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3870 ok(WSAGetLastError() == WSAEAFNOSUPPORT
, "Should be WSAEAFNOSUPPORT\n");
3872 /* Test Null destination */
3874 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, NULL
, sizeof(dst
));
3875 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3876 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
3877 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3879 /* Test zero length passed */
3882 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 0);
3883 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3884 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
3885 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3887 /* Test length one shorter than the address length */
3890 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, 6);
3891 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3892 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
3893 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3895 /* Test longer length is ok */
3898 pdst
= pInetNtop(AF_INET
, (void*)&in
.s_addr
, dst
, sizeof(dst
)+1);
3899 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
3900 ok(!strcmp(pdst
, addr1_Str
),"Address %s != %s\n", pdst
, addr1_Str
);
3902 /* Test the IPv6 addresses */
3904 /* Test an zero prefixed IPV6 address */
3905 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
3906 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
3907 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
3908 ok(!strcmp(pdst
, addr2_Str
),"Address %s != %s\n", pdst
, addr2_Str
);
3910 /* Test an zero suffixed IPV6 address */
3911 memcpy(in6
.s6_addr
, addr3_Num
, sizeof(addr3_Num
));
3912 pdst
= pInetNtop(AF_INET6
,(void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
3913 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
3914 ok(!strcmp(pdst
, addr3_Str
),"Address %s != %s\n", pdst
, addr3_Str
);
3916 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
3917 memcpy(in6
.s6_addr
, addr4_Num
, sizeof(addr4_Num
));
3918 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, sizeof(dst6
));
3919 ok(pdst
!= NULL
, "InetNtop failed %s\n", dst6
);
3920 ok(!strcmp(pdst
, addr4_Str
),"Address %s != %s\n", pdst
, addr4_Str
);
3922 /* Test invalid parm conditions */
3923 memcpy(in6
.u
.Byte
, addr2_Num
, sizeof(addr2_Num
));
3925 /* Test Null destination */
3927 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, NULL
, sizeof(dst6
));
3928 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3929 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
3930 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3932 /* Test zero length passed */
3935 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 0);
3936 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3937 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
3938 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3940 /* Test length one shorter than the address length */
3943 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 16);
3944 ok(pdst
== NULL
, "The pointer should not be returned (%p)\n", pdst
);
3945 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER
|| WSAGetLastError() == WSAEINVAL
/* Win7 */,
3946 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3948 /* Test longer length is ok */
3951 pdst
= pInetNtop(AF_INET6
, (void*)&in6
.s6_addr
, dst6
, 18);
3952 ok(pdst
!= NULL
, "The pointer should be returned (%p)\n", pdst
);
3955 static void test_ioctlsocket(void)
3957 SOCKET sock
, src
, dst
;
3958 struct tcp_keepalive kalive
;
3960 static const LONG cmds
[] = {FIONBIO
, FIONREAD
, SIOCATMARK
};
3964 sock
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
3965 ok(sock
!= INVALID_SOCKET
, "Creating the socket failed: %d\n", WSAGetLastError());
3966 if(sock
== INVALID_SOCKET
)
3968 skip("Can't continue without a socket.\n");
3972 for(i
= 0; i
< sizeof(cmds
)/sizeof(cmds
[0]); i
++)
3974 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
3975 ret
= ioctlsocket(sock
, cmds
[i
], (u_long
*)1);
3976 ok(ret
== SOCKET_ERROR
, "ioctlsocket succeeded unexpectedly\n");
3977 ret
= WSAGetLastError();
3978 ok(ret
== WSAEFAULT
, "expected WSAEFAULT, got %d instead\n", ret
);
3981 /* A fresh and not connected socket has no urgent data, this test shows
3982 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
3984 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
3985 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
3986 ok(arg
, "SIOCATMARK expected a non-zero value\n");
3988 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
3990 ret
= setsockopt(sock
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
3991 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
3993 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
3994 ok(ret
!= SOCKET_ERROR
, "ioctlsocket failed unexpectedly\n");
3995 ok(arg
, "SIOCATMARK expected a non-zero value\n");
3997 /* disable SO_OOBINLINE and get the same old behavior */
3999 ret
= setsockopt(sock
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&optval
, sizeof(optval
));
4000 ok(ret
!= SOCKET_ERROR
, "setsockopt failed unexpectedly\n");
4002 ret
= ioctlsocket(sock
, SIOCATMARK
, &arg
);
4003 ok(arg
, "SIOCATMARK expected a non-zero value\n");
4005 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &arg
, 0, NULL
, 0, &arg
, NULL
, NULL
);
4006 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4007 ret
= WSAGetLastError();
4008 ok(ret
== WSAEFAULT
|| broken(ret
== WSAEINVAL
), "expected WSAEFAULT, got %d instead\n", ret
);
4010 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, NULL
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
4011 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4012 ret
= WSAGetLastError();
4013 ok(ret
== WSAEFAULT
|| broken(ret
== WSAEINVAL
), "expected WSAEFAULT, got %d instead\n", ret
);
4015 /* broken used to catch W95, W98, NT4 */
4016 make_keepalive(kalive
, 0, 0, 0);
4017 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
4018 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
4020 make_keepalive(kalive
, 1, 0, 0);
4021 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
4022 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
4024 make_keepalive(kalive
, 1, 1000, 1000);
4025 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
4026 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
4028 make_keepalive(kalive
, 1, 10000, 10000);
4029 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
4030 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
4032 make_keepalive(kalive
, 1, 100, 100);
4033 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
4034 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
4036 make_keepalive(kalive
, 0, 100, 100);
4037 ret
= WSAIoctl(sock
, SIO_KEEPALIVE_VALS
, &kalive
, sizeof(struct tcp_keepalive
), NULL
, 0, &arg
, NULL
, NULL
);
4038 ok(ret
== 0 || broken(ret
== SOCKET_ERROR
), "WSAIoctl failed unexpectedly\n");
4042 if (tcp_socketpair(&src
, &dst
) != 0)
4044 ok(0, "creating socket pair failed, skipping test\n");
4048 /* test FIONREAD on TCP sockets */
4049 optval
= 0xdeadbeef;
4050 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
4051 ok(ret
== 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
4052 ok(optval
== 0, "FIONREAD should have returned 0 bytes, got %d instead\n", optval
);
4054 optval
= 0xdeadbeef;
4055 ok(send(src
, "TEST", 4, 0) == 4, "failed to send test data\n");
4057 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
4058 ok(ret
== 0, "WSAIoctl failed unexpectedly with error %d\n", WSAGetLastError());
4059 ok(optval
== 4, "FIONREAD should have returned 4 bytes, got %d instead\n", optval
);
4062 optval
= 0xdeadbeef;
4063 ret
= WSAIoctl(dst
, FIONREAD
, NULL
, 0, &optval
, sizeof(optval
), &arg
, NULL
, NULL
);
4064 ok(ret
== SOCKET_ERROR
, "WSAIoctl succeeded unexpectedly\n");
4065 ok(optval
== 0xdeadbeef, "FIONREAD should not have changed last error, got %d instead\n", optval
);
4069 static BOOL drain_pause
= FALSE
;
4070 static DWORD WINAPI
drain_socket_thread(LPVOID arg
)
4073 SOCKET sock
= *(SOCKET
*)arg
;
4076 while ((ret
= recv(sock
, buffer
, sizeof(buffer
), 0)) != 0)
4080 if (WSAGetLastError() == WSAEWOULDBLOCK
)
4084 FD_SET(sock
, &readset
);
4085 select(sock
+1, &readset
, NULL
, NULL
, NULL
);
4096 static void test_send(void)
4098 SOCKET src
= INVALID_SOCKET
;
4099 SOCKET dst
= INVALID_SOCKET
;
4100 HANDLE hThread
= NULL
;
4101 const int buflen
= 1024*1024;
4102 char *buffer
= NULL
;
4103 int ret
, i
, zero
= 0;
4107 DWORD id
, bytes_sent
, dwRet
;
4109 memset(&ov
, 0, sizeof(ov
));
4111 if (tcp_socketpair(&src
, &dst
) != 0)
4113 ok(0, "creating socket pair failed, skipping test\n");
4117 set_blocking(dst
, FALSE
);
4118 /* force disable buffering so we can get a pending overlapped request */
4119 ret
= setsockopt(dst
, SOL_SOCKET
, SO_SNDBUF
, (char *) &zero
, sizeof(zero
));
4120 ok(!ret
, "setsockopt SO_SNDBUF failed: %d - %d\n", ret
, GetLastError());
4122 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
4123 if (hThread
== NULL
)
4125 ok(0, "CreateThread failed, error %d\n", GetLastError());
4129 buffer
= HeapAlloc(GetProcessHeap(), 0, buflen
);
4132 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
4136 /* fill the buffer with some nonsense */
4137 for (i
= 0; i
< buflen
; ++i
)
4139 buffer
[i
] = (char) i
;
4142 ret
= send(src
, buffer
, buflen
, 0);
4144 ok(ret
== buflen
, "send should have sent %d bytes, but it only sent %d\n", buflen
, ret
);
4146 ok(0, "send failed, error %d\n", WSAGetLastError());
4151 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
4152 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
4157 WSASetLastError(12345);
4158 ret
= WSASend(dst
, &buf
, 1, &bytes_sent
, 0, &ov
, NULL
);
4159 ok((ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
) || broken(bytes_sent
== buflen
),
4160 "Failed to start overlapped send %d - %d - %d/%d\n", ret
, WSAGetLastError(), bytes_sent
, buflen
);
4162 /* don't check for completion yet, we may need to drain the buffer while still sending */
4163 set_blocking(src
, FALSE
);
4164 for (i
= 0; i
< buflen
; ++i
)
4168 ret
= recv(src
, buffer
, 1, 0);
4169 while (ret
== SOCKET_ERROR
&& GetLastError() == WSAEWOULDBLOCK
&& j
< 100)
4173 ret
= recv(src
, buffer
, 1, 0);
4176 ok(ret
== 1, "Failed to receive data %d - %d (got %d/%d)\n", ret
, GetLastError(), i
, buflen
);
4180 ok(buffer
[0] == (char) i
, "Received bad data at position %d\n", i
);
4183 dwRet
= WaitForSingleObject(ov
.hEvent
, 1000);
4184 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
4185 if (dwRet
== WAIT_OBJECT_0
)
4187 bret
= GetOverlappedResult((HANDLE
)dst
, &ov
, &bytes_sent
, FALSE
);
4188 ok((bret
&& bytes_sent
== buflen
) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
4189 "Got %d instead of %d (%d - %d)\n", bytes_sent
, buflen
, bret
, GetLastError());
4192 WSASetLastError(12345);
4193 ret
= WSASend(INVALID_SOCKET
, &buf
, 1, NULL
, 0, &ov
, NULL
);
4194 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
4195 "WSASend failed %d - %d\n", ret
, WSAGetLastError());
4197 WSASetLastError(12345);
4198 ret
= WSASend(dst
, &buf
, 1, NULL
, 0, &ov
, NULL
);
4199 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == ERROR_IO_PENDING
,
4200 "Failed to start overlapped send %d - %d\n", ret
, WSAGetLastError());
4203 if (src
!= INVALID_SOCKET
)
4205 if (dst
!= INVALID_SOCKET
)
4207 if (hThread
!= NULL
)
4208 CloseHandle(hThread
);
4210 CloseHandle(ov
.hEvent
);
4211 HeapFree(GetProcessHeap(), 0, buffer
);
4214 typedef struct async_message
4218 struct async_message
*next
;
4221 static struct async_message
*messages_received
;
4223 #define WM_SOCKET (WM_USER+100)
4224 static LRESULT CALLBACK
ws2_test_WndProc(HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
4226 struct async_message
*message
;
4231 message
= HeapAlloc(GetProcessHeap(), 0, sizeof(*message
));
4232 message
->socket
= (SOCKET
) wparam
;
4233 message
->lparam
= lparam
;
4234 message
->next
= NULL
;
4236 if (messages_received
)
4238 struct async_message
*last
= messages_received
;
4239 while (last
->next
) last
= last
->next
;
4240 last
->next
= message
;
4243 messages_received
= message
;
4247 return DefWindowProcA(hwnd
, msg
, wparam
, lparam
);
4250 static void get_event_details(int event
, int *bit
, char *name
)
4255 if (bit
) *bit
= FD_ACCEPT_BIT
;
4256 if (name
) strcpy(name
, "FD_ACCEPT");
4259 if (bit
) *bit
= FD_CONNECT_BIT
;
4260 if (name
) strcpy(name
, "FD_CONNECT");
4263 if (bit
) *bit
= FD_READ_BIT
;
4264 if (name
) strcpy(name
, "FD_READ");
4267 if (bit
) *bit
= FD_OOB_BIT
;
4268 if (name
) strcpy(name
, "FD_OOB");
4271 if (bit
) *bit
= FD_WRITE_BIT
;
4272 if (name
) strcpy(name
, "FD_WRITE");
4275 if (bit
) *bit
= FD_CLOSE_BIT
;
4276 if (name
) strcpy(name
, "FD_CLOSE");
4280 if (name
) sprintf(name
, "bad%x", event
);
4284 static const char *dbgstr_event_seq(const LPARAM
*seq
)
4286 static char message
[1024];
4294 get_event_details(WSAGETSELECTEVENT(*seq
), NULL
, name
);
4295 len
+= sprintf(message
+ len
, "%s(%d) ", name
, WSAGETSELECTERROR(*seq
));
4299 strcpy( message
+ len
, "]" );
4303 static char *dbgstr_event_seq_result(SOCKET s
, WSANETWORKEVENTS
*netEvents
)
4305 static char message
[1024];
4306 struct async_message
*curr
= messages_received
;
4307 int index
, error
, bit
= 0;
4317 if (bit
>= FD_MAX_EVENTS
) break;
4318 if ( !(netEvents
->lNetworkEvents
& (1 << bit
)) )
4323 get_event_details(1 << bit
, &index
, name
);
4324 error
= netEvents
->iErrorCode
[index
];
4330 if (curr
->socket
!= s
)
4335 get_event_details(WSAGETSELECTEVENT(curr
->lparam
), NULL
, name
);
4336 error
= WSAGETSELECTERROR(curr
->lparam
);
4340 len
+= sprintf(message
+ len
, "%s(%d) ", name
, error
);
4343 strcpy( message
+ len
, "]" );
4347 static void flush_events(SOCKET s
, HANDLE hEvent
)
4349 WSANETWORKEVENTS netEvents
;
4350 struct async_message
*prev
= NULL
, *curr
= messages_received
;
4354 if (hEvent
!= INVALID_HANDLE_VALUE
)
4356 dwRet
= WaitForSingleObject(hEvent
, 100);
4357 if (dwRet
== WAIT_OBJECT_0
)
4359 ret
= WSAEnumNetworkEvents(s
, hEvent
, &netEvents
);
4361 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
4368 if (curr
->socket
== s
)
4370 if (prev
) prev
->next
= curr
->next
;
4371 else messages_received
= curr
->next
;
4373 HeapFree(GetProcessHeap(), 0, curr
);
4375 if (prev
) curr
= prev
->next
;
4376 else curr
= messages_received
;
4387 static int match_event_sequence(SOCKET s
, WSANETWORKEVENTS
*netEvents
, const LPARAM
*seq
)
4389 int event
, index
, error
, events
;
4390 struct async_message
*curr
;
4394 events
= netEvents
->lNetworkEvents
;
4397 event
= WSAGETSELECTEVENT(*seq
);
4398 error
= WSAGETSELECTERROR(*seq
);
4399 get_event_details(event
, &index
, NULL
);
4401 if (!(events
& event
) && index
!= -1)
4403 if (events
& event
&& index
!= -1)
4405 if (netEvents
->iErrorCode
[index
] != error
)
4416 curr
= messages_received
;
4419 if (curr
->socket
== s
)
4421 if (!*seq
) return 0;
4422 if (*seq
!= curr
->lparam
) return 0;
4433 /* checks for a sequence of events, (order only checked if window is used) */
4434 static void ok_event_sequence(SOCKET s
, HANDLE hEvent
, const LPARAM
*seq
, const LPARAM
**broken_seqs
, int completelyBroken
)
4437 WSANETWORKEVENTS events
, *netEvents
= NULL
;
4441 if (hEvent
!= INVALID_HANDLE_VALUE
)
4443 netEvents
= &events
;
4445 dwRet
= WaitForSingleObject(hEvent
, 200);
4446 if (dwRet
== WAIT_OBJECT_0
)
4448 ret
= WSAEnumNetworkEvents(s
, hEvent
, netEvents
);
4451 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret
);
4456 memset(netEvents
, 0, sizeof(*netEvents
));
4461 /* Run the message loop a little */
4462 while (PeekMessageA( &msg
, 0, 0, 0, PM_REMOVE
))
4464 DispatchMessageA(&msg
);
4468 if (match_event_sequence(s
, netEvents
, seq
))
4470 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq
));
4471 flush_events(s
, hEvent
);
4477 for (; *broken_seqs
; broken_seqs
++)
4479 if (match_event_sequence(s
, netEvents
, *broken_seqs
))
4481 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s
, netEvents
), dbgstr_event_seq(seq
));
4482 flush_events(s
, hEvent
);
4488 winetest_ok(broken(completelyBroken
), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq
),
4489 dbgstr_event_seq_result(s
, netEvents
));
4490 flush_events(s
, hEvent
);
4493 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
4495 static void test_events(int useMessages
)
4497 SOCKET server
= INVALID_SOCKET
;
4498 SOCKET src
= INVALID_SOCKET
, src2
= INVALID_SOCKET
;
4499 SOCKET dst
= INVALID_SOCKET
, dst2
= INVALID_SOCKET
;
4500 struct sockaddr_in addr
;
4501 HANDLE hThread
= NULL
;
4502 HANDLE hEvent
= INVALID_HANDLE_VALUE
, hEvent2
= INVALID_HANDLE_VALUE
;
4503 WNDCLASSEXA wndclass
;
4505 char *buffer
= NULL
;
4506 int bufferSize
= 1024*1024;
4510 DWORD bytesReturned
;
4516 static char szClassName
[] = "wstestclass";
4517 const LPARAM
*broken_seq
[3];
4518 static const LPARAM empty_seq
[] = { 0 };
4519 static const LPARAM close_seq
[] = { WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
4520 static const LPARAM write_seq
[] = { WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
4521 static const LPARAM read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
4522 static const LPARAM oob_seq
[] = { WSAMAKESELECTREPLY(FD_OOB
, 0), 0 };
4523 static const LPARAM connect_seq
[] = { WSAMAKESELECTREPLY(FD_CONNECT
, 0),
4524 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
4525 static const LPARAM read_read_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
4526 WSAMAKESELECTREPLY(FD_READ
, 0), 0 };
4527 static const LPARAM read_write_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
4528 WSAMAKESELECTREPLY(FD_WRITE
, 0), 0 };
4529 static const LPARAM read_close_seq
[] = { WSAMAKESELECTREPLY(FD_READ
, 0),
4530 WSAMAKESELECTREPLY(FD_CLOSE
, 0), 0 };
4532 memset(&ov
, 0, sizeof(ov
));
4533 memset(&ov2
, 0, sizeof(ov2
));
4535 /* don't use socketpair, we want connection event */
4536 src
= socket(AF_INET
, SOCK_STREAM
, 0);
4537 if (src
== INVALID_SOCKET
)
4539 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4543 ret
= set_blocking(src
, TRUE
);
4544 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
4546 src2
= socket(AF_INET
, SOCK_STREAM
, 0);
4547 if (src2
== INVALID_SOCKET
)
4549 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4553 ret
= set_blocking(src2
, TRUE
);
4554 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
4557 if (getsockopt(src
, SOL_SOCKET
, SO_OOBINLINE
, (void *)&bret
, &len
) == SOCKET_ERROR
)
4559 ok(0, "failed to get oobinline status, %d\n", GetLastError());
4562 ok(bret
== FALSE
, "OOB not inline\n");
4566 trace("Event test using messages\n");
4568 wndclass
.cbSize
= sizeof(wndclass
);
4569 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
4570 wndclass
.lpfnWndProc
= ws2_test_WndProc
;
4571 wndclass
.cbClsExtra
= 0;
4572 wndclass
.cbWndExtra
= 0;
4573 wndclass
.hInstance
= GetModuleHandleA(NULL
);
4574 wndclass
.hIcon
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
4575 wndclass
.hIconSm
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
4576 wndclass
.hCursor
= LoadCursorA(NULL
, (LPCSTR
)IDC_ARROW
);
4577 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
4578 wndclass
.lpszClassName
= szClassName
;
4579 wndclass
.lpszMenuName
= NULL
;
4580 RegisterClassExA(&wndclass
);
4582 hWnd
= CreateWindowA(szClassName
, "WS2Test", WS_OVERLAPPEDWINDOW
,
4583 0, 0, 500, 500, NULL
, NULL
, GetModuleHandleA(NULL
), NULL
);
4586 ok(0, "failed to create window: %d\n", GetLastError());
4590 ret
= WSAAsyncSelect(src
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
4593 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
4597 ok(set_blocking(src
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
4598 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
4600 ret
= WSAAsyncSelect(src2
, hWnd
, WM_SOCKET
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
4603 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
4607 ok(set_blocking(src2
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
4608 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
4612 trace("Event test using events\n");
4614 hEvent
= WSACreateEvent();
4615 if (hEvent
== INVALID_HANDLE_VALUE
)
4617 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
4621 hEvent2
= WSACreateEvent();
4622 if (hEvent2
== INVALID_HANDLE_VALUE
)
4624 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
4628 ret
= WSAEventSelect(src
, hEvent
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
4631 ok(0, "WSAEventSelect failed, error %d\n", ret
);
4635 ok(set_blocking(src
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
4636 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
4638 ret
= WSAEventSelect(src2
, hEvent2
, FD_CONNECT
| FD_READ
| FD_OOB
| FD_WRITE
| FD_CLOSE
);
4641 ok(0, "WSAEventSelect failed, error %d\n", ret
);
4645 ok(set_blocking(src2
, TRUE
) == SOCKET_ERROR
, "set_blocking should failed!\n");
4646 ok(WSAGetLastError() == WSAEINVAL
, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
4649 server
= socket(AF_INET
, SOCK_STREAM
, 0);
4650 if (server
== INVALID_SOCKET
)
4652 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4656 memset(&addr
, 0, sizeof(addr
));
4657 addr
.sin_family
= AF_INET
;
4658 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
4659 ret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
4662 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4667 ret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
4670 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4674 ret
= listen(server
, 2);
4677 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4681 ret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
4682 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
4684 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4688 ret
= connect(src2
, (struct sockaddr
*)&addr
, sizeof(addr
));
4689 if (ret
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
4691 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4696 dst
= accept(server
, (struct sockaddr
*)&addr
, &len
);
4697 if (dst
== INVALID_SOCKET
)
4699 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4704 dst2
= accept(server
, (struct sockaddr
*)&addr
, &len
);
4705 if (dst2
== INVALID_SOCKET
)
4707 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4711 closesocket(server
);
4712 server
= INVALID_SOCKET
;
4714 /* On Windows it seems when a non-blocking socket sends to a
4715 blocking socket on the same host, the send() is BLOCKING,
4716 so make both sockets non-blocking. src is already non-blocking
4717 from the async select */
4719 if (set_blocking(dst
, FALSE
))
4721 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
4725 buffer
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, bufferSize
);
4728 ok(0, "could not allocate memory for test\n");
4732 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
4733 if (ov
.hEvent
== NULL
)
4735 ok(0, "could not create event object, errno = %d\n", GetLastError());
4739 ov2
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
4740 if (ov2
.hEvent
== NULL
)
4742 ok(0, "could not create event object, errno = %d\n", GetLastError());
4746 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
4747 ok_event_seq(src
, hEvent
, connect_seq
, NULL
, 1);
4748 ok_event_seq(src2
, hEvent2
, connect_seq
, NULL
, 1);
4749 /* broken on all windows - FD_CONNECT error is garbage */
4751 /* Test simple send/recv */
4752 ret
= send(dst
, buffer
, 100, 0);
4753 ok(ret
== 100, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4754 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
4756 ret
= recv(src
, buffer
, 1, MSG_PEEK
);
4757 ok(ret
== 1, "Failed to peek at recv buffer %d err %d\n", ret
, GetLastError());
4758 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
4760 ret
= recv(src
, buffer
, 50, 0);
4761 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
4762 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
4764 ret
= recv(src
, buffer
, 50, 0);
4765 ok(ret
== 50, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
4766 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
4768 /* fun fact - events are re-enabled even on failure, but only for messages */
4769 ret
= send(dst
, "1", 1, 0);
4770 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4771 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
4773 ret
= recv(src
, buffer
, -1, 0);
4774 ok(ret
== SOCKET_ERROR
&& (GetLastError() == WSAEFAULT
|| GetLastError() == WSAENOBUFS
),
4775 "Failed to recv buffer %d err %d\n", ret
, GetLastError());
4778 broken_seq
[0] = empty_seq
; /* win9x */
4779 broken_seq
[1] = NULL
;
4780 todo_wine
ok_event_seq(src
, hEvent
, read_seq
, broken_seq
, 0);
4783 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
4785 ret
= recv(src
, buffer
, 1, 0);
4786 ok(ret
== 1, "Failed to recv buffer %d err %d\n", ret
, GetLastError());
4787 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
4789 /* Interaction with overlapped */
4790 bufs
.len
= sizeof(char);
4792 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
4793 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
4794 "WSARecv failed - %d error %d\n", ret
, GetLastError());
4796 bufs
.len
= sizeof(char);
4797 bufs
.buf
= buffer
+1;
4798 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov2
, NULL
);
4799 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
4800 "WSARecv failed - %d error %d\n", ret
, GetLastError());
4802 ret
= send(dst
, "12", 2, 0);
4803 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4804 broken_seq
[0] = read_read_seq
; /* win9x */
4805 broken_seq
[1] = NULL
;
4806 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
4808 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
4809 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
4810 if (dwRet
== WAIT_OBJECT_0
)
4812 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
4813 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
4814 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
4815 ok(buffer
[0] == '1', "Got %c instead of 1\n", buffer
[0]);
4818 dwRet
= WaitForSingleObject(ov2
.hEvent
, 100);
4819 ok(dwRet
== WAIT_OBJECT_0
, "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
4820 if (dwRet
== WAIT_OBJECT_0
)
4822 bret
= GetOverlappedResult((HANDLE
)src
, &ov2
, &bytesReturned
, FALSE
);
4823 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
4824 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
4825 ok(buffer
[1] == '2', "Got %c instead of 2\n", buffer
[1]);
4828 ret
= send(dst
, "1", 1, 0);
4829 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4830 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
4832 ret
= recv(src
, buffer
, 1, 0);
4833 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
4834 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
4836 /* Notifications are delivered as soon as possible, blocked only on
4837 * async requests on the same type */
4838 bufs
.len
= sizeof(char);
4840 ret
= WSARecv(src
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
4841 ok(ret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
,
4842 "WSARecv failed - %d error %d\n", ret
, GetLastError());
4845 ret
= send(dst
, "1", 1, MSG_OOB
);
4846 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4847 ok_event_seq(src
, hEvent
, oob_seq
, NULL
, 0);
4850 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
4851 ok(dwRet
== WAIT_TIMEOUT
, "OOB message activated read?: %d - %d\n", dwRet
, GetLastError());
4853 ret
= send(dst
, "2", 1, 0);
4854 ok(ret
== 1, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4855 broken_seq
[0] = read_seq
; /* win98 */
4856 broken_seq
[1] = NULL
;
4857 ok_event_seq(src
, hEvent
, empty_seq
, broken_seq
, 0);
4859 dwRet
= WaitForSingleObject(ov
.hEvent
, 100);
4860 ok(dwRet
== WAIT_OBJECT_0
|| broken(dwRet
== WAIT_TIMEOUT
),
4861 "Failed to wait for recv message: %d - %d\n", dwRet
, GetLastError());
4862 if (dwRet
== WAIT_OBJECT_0
)
4864 bret
= GetOverlappedResult((HANDLE
)src
, &ov
, &bytesReturned
, FALSE
);
4865 ok((bret
&& bytesReturned
== 1) || broken(!bret
&& GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */,
4866 "Got %d instead of 1 (%d - %d)\n", bytesReturned
, bret
, GetLastError());
4867 ok(buffer
[0] == '2', "Got %c instead of 2\n", buffer
[0]);
4869 else if (dwRet
== WAIT_TIMEOUT
)
4871 /* this happens on win98. We get an FD_READ later on the next test */
4872 CancelIo((HANDLE
) src
);
4876 ret
= recv(src
, buffer
, 1, MSG_OOB
);
4877 todo_wine
ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
4878 /* We get OOB notification, but no data on wine */
4879 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
4882 /* Flood the send queue */
4883 hThread
= CreateThread(NULL
, 0, drain_socket_thread
, &dst
, 0, &id
);
4884 if (hThread
== NULL
)
4886 ok(0, "CreateThread failed, error %d\n", GetLastError());
4890 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
4891 ok_event_seq(src
, hEvent
, empty_seq
, NULL
, 0);
4893 /* Now if we send a ton of data and the 'server' does not drain it fast
4894 * enough (set drain_pause to be sure), the socket send buffer will only
4895 * take some of it, and we will get a short write. This will trigger
4896 * another FD_WRITE event as soon as data is sent and more space becomes
4897 * available, but not any earlier. */
4901 ret
= send(src
, buffer
, bufferSize
, 0);
4902 } while (ret
== bufferSize
);
4903 drain_pause
= FALSE
;
4904 if (ret
>= 0 || WSAGetLastError() == WSAEWOULDBLOCK
)
4906 Sleep(400); /* win9x */
4907 broken_seq
[0] = read_write_seq
;
4908 broken_seq
[1] = NULL
;
4909 ok_event_seq(src
, hEvent
, write_seq
, broken_seq
, 0);
4913 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
4916 /* Test how FD_CLOSE is handled */
4917 ret
= send(dst
, "12", 2, 0);
4918 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4920 /* Wait a little and let the send complete */
4923 dst
= INVALID_SOCKET
;
4926 /* We can never implement this in wine, best we can hope for is
4927 sending FD_CLOSE after the reads complete */
4928 broken_seq
[0] = read_seq
; /* win9x */
4929 broken_seq
[1] = NULL
;
4930 todo_wine
ok_event_seq(src
, hEvent
, read_close_seq
, broken_seq
, 0);
4932 ret
= recv(src
, buffer
, 1, 0);
4933 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
4934 ok_event_seq(src
, hEvent
, read_seq
, NULL
, 0);
4936 ret
= recv(src
, buffer
, 1, 0);
4937 ok(ret
== 1, "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
4938 /* want it? it's here, but you can't have it */
4939 broken_seq
[0] = close_seq
; /* win9x */
4940 broken_seq
[1] = NULL
;
4941 todo_wine
ok_event_seq(src
, hEvent
, empty_seq
, /* wine sends FD_CLOSE here */
4944 /* Test how FD_CLOSE is handled */
4945 ret
= send(dst2
, "12", 2, 0);
4946 ok(ret
== 2, "Failed to send buffer %d err %d\n", ret
, GetLastError());
4949 shutdown(dst2
, SD_SEND
);
4952 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
4953 regressions, don't mark them as todo_wine, and mark windows as broken */
4954 broken_seq
[0] = read_close_seq
;
4955 broken_seq
[1] = close_seq
;
4956 broken_seq
[2] = NULL
;
4957 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
4959 ret
= recv(src2
, buffer
, 1, 0);
4960 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
4961 broken_seq
[0] = close_seq
; /* win98 */
4962 broken_seq
[1] = NULL
;
4963 ok_event_seq(src2
, hEvent2
, read_seq
, broken_seq
, 0);
4965 ret
= recv(src2
, buffer
, 1, 0);
4966 ok(ret
== 1 || broken(!ret
), "Failed to empty buffer: %d - %d\n", ret
, GetLastError());
4967 broken_seq
[0] = empty_seq
;
4968 broken_seq
[1] = NULL
;
4969 ok_event_seq(src2
, hEvent2
, close_seq
, broken_seq
, 0);
4971 ret
= send(src2
, "1", 1, 0);
4972 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
4973 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
4975 ret
= send(src2
, "1", 1, 0);
4976 ok(ret
== 1, "Sending to half-closed socket failed %d err %d\n", ret
, GetLastError());
4977 ok_event_seq(src2
, hEvent2
, empty_seq
, NULL
, 0);
4981 ret
= WSAAsyncSelect(src
, hWnd
, WM_SOCKET
, 0);
4984 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
4988 ret
= set_blocking(src
, TRUE
);
4989 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
4991 ret
= WSAAsyncSelect(src2
, hWnd
, WM_SOCKET
, 0);
4994 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
4998 ret
= set_blocking(src2
, TRUE
);
4999 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
5003 ret
= WSAEventSelect(src
, hEvent2
, 0);
5006 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
5010 ret
= set_blocking(src
, TRUE
);
5011 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
5013 ret
= WSAEventSelect(src2
, hEvent2
, 0);
5016 ok(0, "WSAAsyncSelect failed, error %d\n", ret
);
5020 ret
= set_blocking(src2
, TRUE
);
5021 ok(!ret
, "set_blocking failed, error %d\n", WSAGetLastError());
5025 if (src
!= INVALID_SOCKET
)
5027 flush_events(src
, hEvent
);
5030 if (src2
!= INVALID_SOCKET
)
5032 flush_events(src2
, hEvent2
);
5035 HeapFree(GetProcessHeap(), 0, buffer
);
5036 if (server
!= INVALID_SOCKET
)
5037 closesocket(server
);
5038 if (dst
!= INVALID_SOCKET
)
5040 if (dst2
!= INVALID_SOCKET
)
5042 if (hThread
!= NULL
)
5043 CloseHandle(hThread
);
5045 DestroyWindow(hWnd
);
5047 CloseHandle(hEvent
);
5048 if (hEvent2
!= NULL
)
5049 CloseHandle(hEvent2
);
5050 if (ov
.hEvent
!= NULL
)
5051 CloseHandle(ov
.hEvent
);
5052 if (ov2
.hEvent
!= NULL
)
5053 CloseHandle(ov2
.hEvent
);
5056 static void test_ipv6only(void)
5058 SOCKET v4
= INVALID_SOCKET
,
5059 v6
= INVALID_SOCKET
;
5060 struct sockaddr_in sin4
;
5061 struct sockaddr_in6 sin6
;
5064 memset(&sin4
, 0, sizeof(sin4
));
5065 sin4
.sin_family
= AF_INET
;
5066 sin4
.sin_port
= htons(SERVERPORT
);
5068 memset(&sin6
, 0, sizeof(sin6
));
5069 sin6
.sin6_family
= AF_INET6
;
5070 sin6
.sin6_port
= htons(SERVERPORT
);
5072 v6
= socket(AF_INET6
, SOCK_STREAM
, IPPROTO_TCP
);
5073 if (v6
== INVALID_SOCKET
) {
5074 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
5075 WSAGetLastError(), WSAEAFNOSUPPORT
);
5078 ret
= bind(v6
, (struct sockaddr
*)&sin6
, sizeof(sin6
));
5080 skip("Could not bind IPv6 address (LastError: %d).\n",
5085 v4
= socket(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
);
5086 if (v4
== INVALID_SOCKET
) {
5087 skip("Could not create IPv4 socket (LastError: %d).\n",
5091 ret
= bind(v4
, (struct sockaddr
*)&sin4
, sizeof(sin4
));
5092 ok(!ret
, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
5093 WSAGetLastError(), WSAEADDRINUSE
);
5096 if (v4
!= INVALID_SOCKET
)
5098 if (v6
!= INVALID_SOCKET
)
5102 static void test_WSASendMsg(void)
5105 struct sockaddr_in sendaddr
, sockaddr
;
5106 GUID WSASendMsg_GUID
= WSAID_WSASENDMSG
;
5107 LPFN_WSASENDMSG pWSASendMsg
= NULL
;
5108 char teststr
[12] = "hello world", buffer
[32];
5111 DWORD bytesSent
, err
;
5114 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
5116 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5117 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5119 /* Obtain the WSASendMsg function */
5120 WSAIoctl(sock
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &WSASendMsg_GUID
, sizeof(WSASendMsg_GUID
),
5121 &pWSASendMsg
, sizeof(pWSASendMsg
), &err
, NULL
, NULL
);
5125 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
5129 /* fake address for now */
5130 sendaddr
.sin_family
= AF_INET
;
5131 sendaddr
.sin_port
= htons(139);
5132 sendaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5134 memset(&msg
, 0, sizeof(msg
));
5135 iovec
[0].buf
= teststr
;
5136 iovec
[0].len
= sizeof(teststr
);
5137 iovec
[1].buf
= teststr
;
5138 iovec
[1].len
= sizeof(teststr
) / 2;
5139 msg
.name
= (struct sockaddr
*) &sendaddr
;
5140 msg
.namelen
= sizeof(sendaddr
);
5141 msg
.lpBuffers
= iovec
;
5142 msg
.dwBufferCount
= 1; /* send only one buffer for now */
5144 WSASetLastError(0xdeadbeef);
5145 ret
= pWSASendMsg(INVALID_SOCKET
, &msg
, 0, NULL
, NULL
, NULL
);
5146 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5147 err
= WSAGetLastError();
5148 ok(err
== WSAENOTSOCK
, "expected 10038, got %d instead\n", err
);
5150 WSASetLastError(0xdeadbeef);
5151 ret
= pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
);
5152 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5153 err
= WSAGetLastError();
5154 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
5156 WSASetLastError(0xdeadbeef);
5157 ret
= pWSASendMsg(sock
, NULL
, 0, &bytesSent
, NULL
, NULL
);
5158 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5159 err
= WSAGetLastError();
5160 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
5162 WSASetLastError(0xdeadbeef);
5163 ret
= pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
);
5164 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5165 err
= WSAGetLastError();
5166 ok(err
== WSAEFAULT
, "expected 10014, got %d instead\n", err
);
5170 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5171 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5173 dst
= socket(AF_INET
, SOCK_DGRAM
, 0);
5174 ok(dst
!= INVALID_SOCKET
, "socket() failed\n");
5176 memset(&sockaddr
, 0, sizeof(sockaddr
));
5177 sockaddr
.sin_family
= AF_INET
;
5178 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5179 ok(!bind(dst
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
)),
5180 "bind should have worked\n");
5182 /* read address to find out the port number to be used in send */
5183 memset(&sendaddr
, 0, sizeof(sendaddr
));
5184 addrlen
= sizeof(sendaddr
);
5185 ok(!getsockname(dst
, (struct sockaddr
*) &sendaddr
, &addrlen
),
5186 "getsockname should have worked\n");
5187 ok(sendaddr
.sin_port
, "socket port should be != 0\n");
5189 /* ensure the sending socket is not bound */
5190 WSASetLastError(0xdeadbeef);
5191 addrlen
= sizeof(sockaddr
);
5192 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
5193 ok(ret
== SOCKET_ERROR
, "getsockname should have failed\n");
5194 err
= WSAGetLastError();
5195 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
5197 set_blocking(sock
, TRUE
);
5200 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
5201 ok(!ret
, "WSASendMsg should have worked\n");
5202 ok(bytesSent
== iovec
[0].len
, "incorret bytes sent, expected %d, sent %d\n",
5203 iovec
[0].len
, bytesSent
);
5206 addrlen
= sizeof(sockaddr
);
5207 memset(buffer
, 0, sizeof(buffer
));
5208 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
5209 ok(ret
== bytesSent
, "got %d, expected %d\n",
5212 /* A successful call to WSASendMsg must have bound the socket */
5213 addrlen
= sizeof(sockaddr
);
5214 sockaddr
.sin_port
= 0;
5215 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5216 ret
= getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
);
5217 ok(!ret
, "getsockname should have worked\n");
5218 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
5219 inet_ntoa(sockaddr
.sin_addr
));
5220 ok(sockaddr
.sin_port
, "sin_port should be != 0\n");
5222 msg
.dwBufferCount
= 2; /* send both buffers */
5225 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
5226 ok(!ret
, "WSASendMsg should have worked\n");
5227 ok(bytesSent
== iovec
[0].len
+ iovec
[1].len
, "incorret bytes sent, expected %d, sent %d\n",
5228 iovec
[0].len
+ iovec
[1].len
, bytesSent
);
5231 addrlen
= sizeof(sockaddr
);
5232 memset(buffer
, 0, sizeof(buffer
));
5233 ret
= recvfrom(dst
, buffer
, sizeof(buffer
), 0, (struct sockaddr
*) &sockaddr
, &addrlen
);
5234 ok(ret
== bytesSent
, "got %d, expected %d\n",
5240 /* a bad call to WSASendMsg will also bind the socket */
5241 addrlen
= sizeof(sockaddr
);
5242 sockaddr
.sin_port
= 0;
5243 sockaddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5244 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5245 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5246 ok(pWSASendMsg(sock
, &msg
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
5248 ok(!getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have worked\n");
5249 ok(sockaddr
.sin_addr
.s_addr
== htonl(INADDR_ANY
), "expected 0.0.0.0, got %s\n",
5250 inet_ntoa(sockaddr
.sin_addr
));
5251 ok(sockaddr
.sin_port
, "sin_port should be > 0\n");
5255 /* a bad call without msg parameter will not trigger the auto-bind */
5256 sock
= socket(AF_INET
, SOCK_DGRAM
, 0);
5257 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5258 ok(pWSASendMsg(sock
, NULL
, 0, NULL
, NULL
, NULL
) == SOCKET_ERROR
, "WSASendMsg should have failed\n");
5259 ok(getsockname(sock
, (struct sockaddr
*)&sockaddr
, &addrlen
), "getsockname should have failed\n");
5260 err
= WSAGetLastError();
5261 ok(err
== WSAEINVAL
, "expected 10022, got %d instead\n", err
);
5264 /* SOCK_STREAM sockets are not supported */
5266 sock
= socket(AF_INET
, SOCK_STREAM
, 0);
5267 ok(sock
!= INVALID_SOCKET
, "socket() failed\n");
5268 SetLastError(0xdeadbeef);
5269 ret
= pWSASendMsg(sock
, &msg
, 0, &bytesSent
, NULL
, NULL
);
5270 ok(ret
== SOCKET_ERROR
, "WSASendMsg should have failed\n");
5271 err
= WSAGetLastError();
5273 ok(err
== WSAEINVAL
, "expected 10014, got %d instead\n", err
);
5277 static void test_WSASendTo(void)
5280 struct sockaddr_in addr
;
5281 char buf
[12] = "hello world";
5286 addr
.sin_family
= AF_INET
;
5287 addr
.sin_port
= htons(139);
5288 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5289 data_buf
.len
= sizeof(buf
);
5292 if( (s
= socket(AF_INET
, SOCK_DGRAM
, 0)) == INVALID_SOCKET
) {
5293 ok(0, "socket() failed error: %d\n", WSAGetLastError());
5297 WSASetLastError(12345);
5298 ret
= WSASendTo(INVALID_SOCKET
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
5299 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAENOTSOCK
,
5300 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
5302 WSASetLastError(12345);
5303 ret
= WSASendTo(s
, &data_buf
, 1, NULL
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
);
5304 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
5305 "WSASendTo() failed: %d/%d\n", ret
, WSAGetLastError());
5307 WSASetLastError(12345);
5308 if(WSASendTo(s
, &data_buf
, 1, &bytesSent
, 0, (struct sockaddr
*)&addr
, sizeof(addr
), NULL
, NULL
)) {
5309 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
5312 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
5313 "a successful call to WSASendTo()\n");
5316 static DWORD WINAPI
recv_thread(LPVOID arg
)
5318 SOCKET sock
= *(SOCKET
*)arg
;
5325 wsa
.len
= sizeof(buffer
);
5326 ov
.hEvent
= WSACreateEvent();
5327 WSARecv(sock
, &wsa
, 1, NULL
, &flags
, &ov
, NULL
);
5329 WaitForSingleObject(ov
.hEvent
, 1000);
5330 WSACloseEvent(ov
.hEvent
);
5334 static void test_WSARecv(void)
5336 SOCKET src
, dest
, server
= INVALID_SOCKET
;
5340 DWORD bytesReturned
, flags
, id
;
5342 struct sockaddr_in addr
;
5348 memset(&ov
, 0, sizeof(ov
));
5350 tcp_socketpair(&src
, &dest
);
5351 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
5353 skip("failed to create sockets\n");
5357 bufs
.len
= sizeof(buf
);
5361 ov
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5362 ok(ov
.hEvent
!= NULL
, "could not create event object, errno = %d\n", GetLastError());
5368 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
5369 ok(!iret
, "Failed to set linger %d\n", GetLastError());
5371 iret
= WSARecv(dest
, &bufs
, 1, NULL
, &flags
, &ov
, NULL
);
5372 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5374 iret
= WSARecv(dest
, &bufs
, 1, &bytesReturned
, &flags
, &ov
, NULL
);
5375 ok(iret
== SOCKET_ERROR
&& GetLastError() == ERROR_IO_PENDING
, "WSARecv failed - %d error %d\n", iret
, GetLastError());
5378 src
= INVALID_SOCKET
;
5380 dwret
= WaitForSingleObject(ov
.hEvent
, 1000);
5381 ok(dwret
== WAIT_OBJECT_0
, "Waiting for disconnect event failed with %d + errno %d\n", dwret
, GetLastError());
5383 bret
= GetOverlappedResult((HANDLE
)dest
, &ov
, &bytesReturned
, FALSE
);
5384 todo_wine
ok(!bret
&& (GetLastError() == ERROR_NETNAME_DELETED
|| broken(GetLastError() == ERROR_IO_INCOMPLETE
) /* win9x */),
5385 "Did not get disconnect event: %d, error %d\n", bret
, GetLastError());
5386 ok(bytesReturned
== 0, "Bytes received is %d\n", bytesReturned
);
5388 dest
= INVALID_SOCKET
;
5390 src
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, 0);
5391 ok(src
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5392 if (src
== INVALID_SOCKET
) goto end
;
5394 server
= WSASocketW(AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
5395 ok(server
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5396 if (server
== INVALID_SOCKET
) goto end
;
5398 memset(&addr
, 0, sizeof(addr
));
5399 addr
.sin_family
= AF_INET
;
5400 addr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5401 iret
= bind(server
, (struct sockaddr
*)&addr
, sizeof(addr
));
5405 iret
= getsockname(server
, (struct sockaddr
*)&addr
, &len
);
5408 iret
= listen(server
, 1);
5411 iret
= connect(src
, (struct sockaddr
*)&addr
, sizeof(addr
));
5415 dest
= accept(server
, (struct sockaddr
*)&addr
, &len
);
5416 ok(dest
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError());
5417 if (dest
== INVALID_SOCKET
) goto end
;
5419 send(src
, "test message", sizeof("test message"), 0);
5420 thread
= CreateThread(NULL
, 0, recv_thread
, &dest
, 0, &id
);
5421 CloseHandle(thread
);
5424 if (server
!= INVALID_SOCKET
)
5425 closesocket(server
);
5426 if (dest
!= INVALID_SOCKET
)
5428 if (src
!= INVALID_SOCKET
)
5431 WSACloseEvent(ov
.hEvent
);
5434 static void test_GetAddrInfoW(void)
5436 static const WCHAR port
[] = {'8','0',0};
5437 static const WCHAR empty
[] = {0};
5438 static const WCHAR localhost
[] = {'l','o','c','a','l','h','o','s','t',0};
5439 static const WCHAR nxdomain
[] =
5440 {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
5441 static const WCHAR zero
[] = {'0',0};
5443 ADDRINFOW
*result
, *result2
, *p
, hint
;
5445 if (!pGetAddrInfoW
|| !pFreeAddrInfoW
)
5447 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
5450 memset(&hint
, 0, sizeof(ADDRINFOW
));
5452 result
= (ADDRINFOW
*)0xdeadbeef;
5453 ret
= pGetAddrInfoW(NULL
, NULL
, NULL
, &result
);
5454 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
5455 ok(result
== NULL
, "got %p\n", result
);
5458 ret
= pGetAddrInfoW(empty
, NULL
, NULL
, &result
);
5459 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5460 ok(result
!= NULL
, "GetAddrInfoW failed\n");
5461 pFreeAddrInfoW(result
);
5464 ret
= pGetAddrInfoW(NULL
, zero
, NULL
, &result
);
5465 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5466 ok(result
!= NULL
, "GetAddrInfoW failed\n");
5469 ret
= pGetAddrInfoW(NULL
, empty
, NULL
, &result2
);
5470 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5471 ok(result2
!= NULL
, "GetAddrInfoW failed\n");
5472 compare_addrinfow(result
, result2
);
5473 pFreeAddrInfoW(result
);
5474 pFreeAddrInfoW(result2
);
5477 ret
= pGetAddrInfoW(empty
, zero
, NULL
, &result
);
5478 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5479 ok(result
!= NULL
, "GetAddrInfoW failed\n");
5482 ret
= pGetAddrInfoW(empty
, empty
, NULL
, &result2
);
5483 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5484 ok(result2
!= NULL
, "GetAddrInfoW failed\n");
5485 compare_addrinfow(result
, result2
);
5486 pFreeAddrInfoW(result
);
5487 pFreeAddrInfoW(result2
);
5490 ret
= pGetAddrInfoW(localhost
, NULL
, NULL
, &result
);
5491 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5492 pFreeAddrInfoW(result
);
5495 ret
= pGetAddrInfoW(localhost
, empty
, NULL
, &result
);
5496 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5497 pFreeAddrInfoW(result
);
5500 ret
= pGetAddrInfoW(localhost
, zero
, NULL
, &result
);
5501 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5502 pFreeAddrInfoW(result
);
5505 ret
= pGetAddrInfoW(localhost
, port
, NULL
, &result
);
5506 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5507 pFreeAddrInfoW(result
);
5510 ret
= pGetAddrInfoW(localhost
, NULL
, &hint
, &result
);
5511 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5512 pFreeAddrInfoW(result
);
5515 ret
= pGetAddrInfoW(localhost
, port
, &hint
, &result
);
5516 ok(!ret
, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5517 pFreeAddrInfoW(result
);
5519 result
= (ADDRINFOW
*)0xdeadbeef;
5520 ret
= pGetAddrInfoW(NULL
, NULL
, NULL
, &result
);
5523 skip("nxdomain returned success. Broken ISP redirects?\n");
5526 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
5527 ok(result
== NULL
, "got %p\n", result
);
5529 result
= (ADDRINFOW
*)0xdeadbeef;
5530 ret
= pGetAddrInfoW(nxdomain
, NULL
, NULL
, &result
);
5533 skip("nxdomain returned success. Broken ISP redirects?\n");
5536 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
5537 ok(result
== NULL
, "got %p\n", result
);
5539 for (i
= 0;i
< (sizeof(hinttests
) / sizeof(hinttests
[0]));i
++)
5541 hint
.ai_family
= hinttests
[i
].family
;
5542 hint
.ai_socktype
= hinttests
[i
].socktype
;
5543 hint
.ai_protocol
= hinttests
[i
].protocol
;
5546 SetLastError(0xdeadbeef);
5547 ret
= pGetAddrInfoW(localhost
, NULL
, &hint
, &result
);
5550 if (hinttests
[i
].error
)
5551 ok(0, "test %d: GetAddrInfoW succeeded unexpectedly\n", i
);
5557 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
5558 if (hinttests
[i
].family
== AF_UNSPEC
)
5559 ok(p
->ai_family
== AF_INET
|| p
->ai_family
== AF_INET6
,
5560 "test %d: expected AF_INET or AF_INET6, got %d\n",
5563 ok(p
->ai_family
== hinttests
[i
].family
,
5564 "test %d: expected family %d, got %d\n",
5565 i
, hinttests
[i
].family
, p
->ai_family
);
5567 ok(p
->ai_socktype
== hinttests
[i
].socktype
,
5568 "test %d: expected type %d, got %d\n",
5569 i
, hinttests
[i
].socktype
, p
->ai_socktype
);
5570 ok(p
->ai_protocol
== hinttests
[i
].protocol
,
5571 "test %d: expected protocol %d, got %d\n",
5572 i
, hinttests
[i
].protocol
, p
->ai_protocol
);
5577 pFreeAddrInfoW(result
);
5581 DWORD err
= WSAGetLastError();
5582 if (hinttests
[i
].error
)
5583 ok(hinttests
[i
].error
== err
, "test %d: GetAddrInfoW failed with error %d, expected %d\n",
5584 i
, err
, hinttests
[i
].error
);
5586 ok(0, "test %d: GetAddrInfoW failed with %d (err %d)\n", i
, ret
, err
);
5591 static void test_getaddrinfo(void)
5594 ADDRINFOA
*result
, *result2
, *p
, hint
;
5596 if (!pgetaddrinfo
|| !pfreeaddrinfo
)
5598 win_skip("getaddrinfo and/or freeaddrinfo not present\n");
5601 memset(&hint
, 0, sizeof(ADDRINFOA
));
5603 result
= (ADDRINFOA
*)0xdeadbeef;
5604 ret
= pgetaddrinfo(NULL
, NULL
, NULL
, &result
);
5605 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
5606 ok(result
== NULL
, "got %p\n", result
);
5609 ret
= pgetaddrinfo("", NULL
, NULL
, &result
);
5610 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5611 ok(result
!= NULL
, "getaddrinfo failed\n");
5612 pfreeaddrinfo(result
);
5615 ret
= pgetaddrinfo(NULL
, "0", NULL
, &result
);
5616 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5617 ok(result
!= NULL
, "getaddrinfo failed\n");
5620 ret
= pgetaddrinfo(NULL
, "", NULL
, &result2
);
5621 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5622 ok(result2
!= NULL
, "getaddrinfo failed\n");
5623 compare_addrinfo(result
, result2
);
5624 pfreeaddrinfo(result
);
5625 pfreeaddrinfo(result2
);
5628 ret
= pgetaddrinfo("", "0", NULL
, &result
);
5629 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5630 ok(result
!= NULL
, "getaddrinfo failed\n");
5633 ret
= pgetaddrinfo("", "", NULL
, &result2
);
5634 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5635 ok(result2
!= NULL
, "getaddrinfo failed\n");
5636 compare_addrinfo(result
, result2
);
5637 pfreeaddrinfo(result
);
5638 pfreeaddrinfo(result2
);
5641 ret
= pgetaddrinfo("localhost", NULL
, NULL
, &result
);
5642 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5643 pfreeaddrinfo(result
);
5646 ret
= pgetaddrinfo("localhost", "", NULL
, &result
);
5647 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5648 pfreeaddrinfo(result
);
5651 ret
= pgetaddrinfo("localhost", "0", NULL
, &result
);
5652 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5653 pfreeaddrinfo(result
);
5656 ret
= pgetaddrinfo("localhost", "80", NULL
, &result
);
5657 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5658 pfreeaddrinfo(result
);
5661 ret
= pgetaddrinfo("localhost", NULL
, &hint
, &result
);
5662 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5663 pfreeaddrinfo(result
);
5666 ret
= pgetaddrinfo("localhost", "80", &hint
, &result
);
5667 ok(!ret
, "getaddrinfo failed with %d\n", WSAGetLastError());
5668 pfreeaddrinfo(result
);
5670 result
= (ADDRINFOA
*)0xdeadbeef;
5671 ret
= pgetaddrinfo("nxdomain.codeweavers.com", NULL
, NULL
, &result
);
5674 skip("nxdomain returned success. Broken ISP redirects?\n");
5677 ok(ret
== WSAHOST_NOT_FOUND
, "got %d expected WSAHOST_NOT_FOUND\n", ret
);
5678 ok(result
== NULL
, "got %p\n", result
);
5680 for (i
= 0;i
< (sizeof(hinttests
) / sizeof(hinttests
[0]));i
++)
5682 hint
.ai_family
= hinttests
[i
].family
;
5683 hint
.ai_socktype
= hinttests
[i
].socktype
;
5684 hint
.ai_protocol
= hinttests
[i
].protocol
;
5687 SetLastError(0xdeadbeef);
5688 ret
= pgetaddrinfo("localhost", NULL
, &hint
, &result
);
5691 if (hinttests
[i
].error
)
5692 ok(0, "test %d: getaddrinfo succeeded unexpectedly\n", i
);
5698 /* when AF_UNSPEC is used the return will be either AF_INET or AF_INET6 */
5699 if (hinttests
[i
].family
== AF_UNSPEC
)
5700 ok(p
->ai_family
== AF_INET
|| p
->ai_family
== AF_INET6
,
5701 "test %d: expected AF_INET or AF_INET6, got %d\n",
5704 ok(p
->ai_family
== hinttests
[i
].family
,
5705 "test %d: expected family %d, got %d\n",
5706 i
, hinttests
[i
].family
, p
->ai_family
);
5708 ok(p
->ai_socktype
== hinttests
[i
].socktype
,
5709 "test %d: expected type %d, got %d\n",
5710 i
, hinttests
[i
].socktype
, p
->ai_socktype
);
5711 ok(p
->ai_protocol
== hinttests
[i
].protocol
,
5712 "test %d: expected protocol %d, got %d\n",
5713 i
, hinttests
[i
].protocol
, p
->ai_protocol
);
5718 pfreeaddrinfo(result
);
5722 DWORD err
= WSAGetLastError();
5723 if (hinttests
[i
].error
)
5724 ok(hinttests
[i
].error
== err
, "test %d: getaddrinfo failed with error %d, expected %d\n",
5725 i
, err
, hinttests
[i
].error
);
5727 ok(0, "test %d: getaddrinfo failed with %d (err %d)\n", i
, ret
, err
);
5732 static void test_ConnectEx(void)
5734 SOCKET listener
= INVALID_SOCKET
;
5735 SOCKET acceptor
= INVALID_SOCKET
;
5736 SOCKET connector
= INVALID_SOCKET
;
5737 struct sockaddr_in address
, conaddress
;
5739 OVERLAPPED overlapped
;
5740 LPFN_CONNECTEX pConnectEx
;
5741 GUID connectExGuid
= WSAID_CONNECTEX
;
5742 DWORD bytesReturned
;
5748 memset(&overlapped
, 0, sizeof(overlapped
));
5750 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
5751 if (listener
== INVALID_SOCKET
) {
5752 skip("could not create listener socket, error %d\n", WSAGetLastError());
5756 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5757 if (connector
== INVALID_SOCKET
) {
5758 skip("could not create connector socket, error %d\n", WSAGetLastError());
5762 memset(&address
, 0, sizeof(address
));
5763 address
.sin_family
= AF_INET
;
5764 address
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5765 iret
= bind(listener
, (struct sockaddr
*)&address
, sizeof(address
));
5767 skip("failed to bind, error %d\n", WSAGetLastError());
5771 addrlen
= sizeof(address
);
5772 iret
= getsockname(listener
, (struct sockaddr
*)&address
, &addrlen
);
5774 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
5778 if (set_blocking(listener
, TRUE
)) {
5779 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
5783 iret
= WSAIoctl(connector
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &connectExGuid
, sizeof(connectExGuid
),
5784 &pConnectEx
, sizeof(pConnectEx
), &bytesReturned
, NULL
, NULL
);
5786 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret
, WSAGetLastError());
5790 bret
= pConnectEx(INVALID_SOCKET
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
5791 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "ConnectEx on invalid socket "
5792 "returned %d + errno %d\n", bret
, WSAGetLastError());
5794 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
5795 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "ConnectEx on a unbound socket "
5796 "returned %d + errno %d\n", bret
, WSAGetLastError());
5797 if (bret
== TRUE
|| WSAGetLastError() != WSAEINVAL
)
5799 acceptor
= accept(listener
, NULL
, NULL
);
5800 if (acceptor
!= INVALID_SOCKET
) {
5801 closesocket(acceptor
);
5802 acceptor
= INVALID_SOCKET
;
5805 closesocket(connector
);
5806 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5807 if (connector
== INVALID_SOCKET
) {
5808 skip("could not create connector socket, error %d\n", WSAGetLastError());
5813 /* ConnectEx needs a bound socket */
5814 memset(&conaddress
, 0, sizeof(conaddress
));
5815 conaddress
.sin_family
= AF_INET
;
5816 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5817 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
5819 skip("failed to bind, error %d\n", WSAGetLastError());
5823 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, NULL
);
5824 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "ConnectEx on a NULL overlapped "
5825 "returned %d + errno %d\n", bret
, WSAGetLastError());
5827 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
5828 if (overlapped
.hEvent
== NULL
) {
5829 skip("could not create event object, errno = %d\n", GetLastError());
5833 iret
= listen(listener
, 1);
5835 skip("listening failed, errno = %d\n", WSAGetLastError());
5839 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
5840 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
5841 "returned %d + errno %d\n", bret
, WSAGetLastError());
5842 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
5843 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
5845 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
5846 ok(bret
, "Connecting failed, error %d\n", GetLastError());
5847 ok(bytesReturned
== 0, "Bytes sent is %d\n", bytesReturned
);
5849 closesocket(connector
);
5850 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5851 if (connector
== INVALID_SOCKET
) {
5852 skip("could not create connector socket, error %d\n", WSAGetLastError());
5855 /* ConnectEx needs a bound socket */
5856 memset(&conaddress
, 0, sizeof(conaddress
));
5857 conaddress
.sin_family
= AF_INET
;
5858 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5859 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
5861 skip("failed to bind, error %d\n", WSAGetLastError());
5865 acceptor
= accept(listener
, NULL
, NULL
);
5866 if (acceptor
!= INVALID_SOCKET
) {
5867 closesocket(acceptor
);
5873 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, buffer
, 3, &bytesReturned
, &overlapped
);
5874 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "ConnectEx failed: "
5875 "returned %d + errno %d\n", bret
, WSAGetLastError());
5876 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
5877 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
5879 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
5880 ok(bret
, "Connecting failed, error %d\n", GetLastError());
5881 ok(bytesReturned
== 3, "Bytes sent is %d\n", bytesReturned
);
5883 acceptor
= accept(listener
, NULL
, NULL
);
5884 ok(acceptor
!= INVALID_SOCKET
, "could not accept socket error %d\n", WSAGetLastError());
5886 bytesReturned
= recv(acceptor
, buffer
, 3, 0);
5888 ok(bytesReturned
== 3, "Didn't get all sent data, got only %d\n", bytesReturned
);
5889 ok(buffer
[0] == '1' && buffer
[1] == '2' && buffer
[2] == '3',
5890 "Failed to get the right data, expected '123', got '%s'\n", buffer
);
5892 closesocket(connector
);
5893 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5894 if (connector
== INVALID_SOCKET
) {
5895 skip("could not create connector socket, error %d\n", WSAGetLastError());
5898 /* ConnectEx needs a bound socket */
5899 memset(&conaddress
, 0, sizeof(conaddress
));
5900 conaddress
.sin_family
= AF_INET
;
5901 conaddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5902 iret
= bind(connector
, (struct sockaddr
*)&conaddress
, sizeof(conaddress
));
5904 skip("failed to bind, error %d\n", WSAGetLastError());
5908 if (acceptor
!= INVALID_SOCKET
) {
5909 closesocket(acceptor
);
5910 acceptor
= INVALID_SOCKET
;
5913 /* Connect with error */
5914 closesocket(listener
);
5915 listener
= INVALID_SOCKET
;
5917 address
.sin_port
= htons(1);
5919 bret
= pConnectEx(connector
, (struct sockaddr
*)&address
, addrlen
, NULL
, 0, &bytesReturned
, &overlapped
);
5920 ok(bret
== FALSE
&& GetLastError(), "ConnectEx to bad destination failed: "
5921 "returned %d + errno %d\n", bret
, GetLastError());
5923 if (GetLastError() == ERROR_IO_PENDING
)
5925 dwret
= WaitForSingleObject(overlapped
.hEvent
, 15000);
5926 ok(dwret
== WAIT_OBJECT_0
, "Waiting for connect event failed with %d + errno %d\n", dwret
, GetLastError());
5928 bret
= GetOverlappedResult((HANDLE
)connector
, &overlapped
, &bytesReturned
, FALSE
);
5929 ok(bret
== FALSE
&& GetLastError() == ERROR_CONNECTION_REFUSED
,
5930 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
5933 ok(GetLastError() == WSAECONNREFUSED
,
5934 "Connecting to a disconnected host returned error %d - %d\n", bret
, WSAGetLastError());
5938 if (overlapped
.hEvent
)
5939 WSACloseEvent(overlapped
.hEvent
);
5940 if (listener
!= INVALID_SOCKET
)
5941 closesocket(listener
);
5942 if (acceptor
!= INVALID_SOCKET
)
5943 closesocket(acceptor
);
5944 if (connector
!= INVALID_SOCKET
)
5945 closesocket(connector
);
5948 static void test_AcceptEx(void)
5950 SOCKET listener
= INVALID_SOCKET
;
5951 SOCKET acceptor
= INVALID_SOCKET
;
5952 SOCKET connector
= INVALID_SOCKET
;
5953 SOCKET connector2
= INVALID_SOCKET
;
5954 struct sockaddr_in bindAddress
, peerAddress
, *readBindAddress
, *readRemoteAddress
;
5955 int socklen
, optlen
;
5956 GUID acceptExGuid
= WSAID_ACCEPTEX
, getAcceptExGuid
= WSAID_GETACCEPTEXSOCKADDRS
;
5957 LPFN_ACCEPTEX pAcceptEx
= NULL
;
5958 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs
= NULL
;
5959 fd_set fds_accept
, fds_send
;
5960 struct timeval timeout
= {0,10}; /* wait for 10 milliseconds */
5962 DWORD bytesReturned
, connect_time
;
5963 char buffer
[1024], ipbuffer
[32];
5964 OVERLAPPED overlapped
;
5965 int iret
, localSize
= sizeof(struct sockaddr_in
), remoteSize
= localSize
;
5969 memset(&overlapped
, 0, sizeof(overlapped
));
5971 listener
= socket(AF_INET
, SOCK_STREAM
, 0);
5972 if (listener
== INVALID_SOCKET
) {
5973 skip("could not create listener socket, error %d\n", WSAGetLastError());
5977 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
5978 if (acceptor
== INVALID_SOCKET
) {
5979 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
5983 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
5984 if (connector
== INVALID_SOCKET
) {
5985 skip("could not create connector socket, error %d\n", WSAGetLastError());
5989 memset(&bindAddress
, 0, sizeof(bindAddress
));
5990 bindAddress
.sin_family
= AF_INET
;
5991 bindAddress
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
5992 iret
= bind(listener
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
5994 skip("failed to bind, error %d\n", WSAGetLastError());
5998 socklen
= sizeof(bindAddress
);
5999 iret
= getsockname(listener
, (struct sockaddr
*)&bindAddress
, &socklen
);
6001 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
6005 if (set_blocking(listener
, FALSE
)) {
6006 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
6010 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
6011 &pAcceptEx
, sizeof(pAcceptEx
), &bytesReturned
, NULL
, NULL
);
6013 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret
, WSAGetLastError());
6017 iret
= WSAIoctl(listener
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &getAcceptExGuid
, sizeof(getAcceptExGuid
),
6018 &pGetAcceptExSockaddrs
, sizeof(pGetAcceptExSockaddrs
), &bytesReturned
, NULL
, NULL
);
6020 skip("WSAIoctl failed to get GetAcceptExSockaddrs with ret %d + errno %d\n", iret
, WSAGetLastError());
6024 bret
= pAcceptEx(INVALID_SOCKET
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6025 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6026 &bytesReturned
, &overlapped
);
6027 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid listening socket "
6028 "returned %d + errno %d\n", bret
, WSAGetLastError());
6030 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6031 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6032 &bytesReturned
, &overlapped
);
6034 ok(bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
, "AcceptEx on a non-listening socket "
6035 "returned %d + errno %d\n", bret
, WSAGetLastError());
6037 iret
= listen(listener
, 5);
6039 skip("listening failed, errno = %d\n", WSAGetLastError());
6043 bret
= pAcceptEx(listener
, INVALID_SOCKET
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6044 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6045 &bytesReturned
, &overlapped
);
6046 ok(bret
== FALSE
&& WSAGetLastError() == WSAENOTSOCK
, "AcceptEx on invalid accepting socket "
6047 "returned %d + errno %d\n", bret
, WSAGetLastError());
6049 bret
= pAcceptEx(listener
, acceptor
, NULL
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6050 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6051 &bytesReturned
, &overlapped
);
6053 (WSAGetLastError() == WSAEINVAL
||
6054 broken(WSAGetLastError() == WSAEFAULT
)), /* NT4 */
6055 "AcceptEx on NULL buffer returned %d + errno %d\n", bret
, WSAGetLastError());
6057 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, sizeof(struct sockaddr_in
) + 16,
6058 &bytesReturned
, &overlapped
);
6059 ok(bret
== FALSE
&& (WSAGetLastError() == ERROR_IO_PENDING
|| broken(WSAGetLastError() == WSAEINVAL
)) /* NT4 */,
6060 "AcceptEx on too small local address size returned %d + errno %d\n",
6061 bret
, WSAGetLastError());
6062 bret
= CancelIo((HANDLE
) listener
);
6063 ok(bret
, "Failed to cancel pending accept socket\n");
6065 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 15,
6066 sizeof(struct sockaddr_in
) + 16, &bytesReturned
, &overlapped
);
6067 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx on too small local address "
6068 "size returned %d + errno %d\n",
6069 bret
, WSAGetLastError());
6070 bret
= CancelIo((HANDLE
) listener
);
6071 ok(bret
, "Failed to cancel pending accept socket\n");
6073 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16, 0,
6074 &bytesReturned
, &overlapped
);
6075 ok(bret
== FALSE
&& (WSAGetLastError() == WSAEFAULT
|| broken(WSAGetLastError() == WSAEINVAL
)) /* NT4 */,
6076 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
6078 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, sizeof(struct sockaddr_in
) + 16,
6079 sizeof(struct sockaddr_in
) + 15, &bytesReturned
, &overlapped
);
6080 ok(bret
== FALSE
&& (WSAGetLastError() == ERROR_IO_PENDING
|| broken(WSAGetLastError() == WSAEINVAL
)) /* NT4 */,
6081 "AcceptEx on too small remote address size returned %d + errno %d\n", bret
, WSAGetLastError());
6082 bret
= CancelIo((HANDLE
) listener
);
6083 ok(bret
, "Failed to cancel pending accept socket\n");
6085 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6086 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6087 &bytesReturned
, NULL
);
6088 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
6089 "returned %d + errno %d\n", bret
, WSAGetLastError());
6091 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0, 0, 0, &bytesReturned
, NULL
);
6092 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_INVALID_PARAMETER
, "AcceptEx on a NULL overlapped "
6093 "returned %d + errno %d\n", bret
, WSAGetLastError());
6095 overlapped
.hEvent
= CreateEventA(NULL
, FALSE
, FALSE
, NULL
);
6096 if (overlapped
.hEvent
== NULL
) {
6097 skip("could not create event object, errno = %d\n", GetLastError());
6101 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6102 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6103 &bytesReturned
, &overlapped
);
6104 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6106 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6107 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6108 &bytesReturned
, &overlapped
);
6109 todo_wine
ok((bret
== FALSE
&& WSAGetLastError() == WSAEINVAL
) || broken(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) /* NT4 */,
6110 "AcceptEx on already pending socket returned %d + errno %d\n", bret
, WSAGetLastError());
6111 if (bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
) {
6112 /* We need to cancel this call, otherwise things fail */
6113 bret
= CancelIo((HANDLE
) listener
);
6114 ok(bret
, "Failed to cancel failed test. Bailing...\n");
6116 WaitForSingleObject(overlapped
.hEvent
, 0);
6118 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6119 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6120 &bytesReturned
, &overlapped
);
6121 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6124 iret
= connect(acceptor
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6125 todo_wine
ok((iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEINVAL
) || broken(!iret
) /* NT4 */,
6126 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret
, WSAGetLastError());
6127 if (!iret
|| (iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
)) {
6128 /* We need to cancel this call, otherwise things fail */
6129 closesocket(acceptor
);
6130 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6131 if (acceptor
== INVALID_SOCKET
) {
6132 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6136 bret
= CancelIo((HANDLE
) listener
);
6137 ok(bret
, "Failed to cancel failed test. Bailing...\n");
6140 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6141 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6142 &bytesReturned
, &overlapped
);
6143 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6146 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6147 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6149 dwret
= WaitForSingleObject(overlapped
.hEvent
, INFINITE
);
6150 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6152 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6153 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6154 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6156 closesocket(connector
);
6157 connector
= INVALID_SOCKET
;
6158 closesocket(acceptor
);
6160 /* Test short reads */
6162 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6163 if (acceptor
== INVALID_SOCKET
) {
6164 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6167 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6168 if (connector
== INVALID_SOCKET
) {
6169 skip("could not create connector socket, error %d\n", WSAGetLastError());
6172 bret
= pAcceptEx(listener
, acceptor
, buffer
, 2,
6173 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6174 &bytesReturned
, &overlapped
);
6175 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6177 connect_time
= 0xdeadbeef;
6178 optlen
= sizeof(connect_time
);
6179 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
6180 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
6181 ok(connect_time
== ~0u, "unexpected connect time %u\n", connect_time
);
6183 /* AcceptEx() still won't complete until we send data */
6184 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6185 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6187 connect_time
= 0xdeadbeef;
6188 optlen
= sizeof(connect_time
);
6189 iret
= getsockopt(connector
, SOL_SOCKET
, SO_CONNECT_TIME
, (char *)&connect_time
, &optlen
);
6190 ok(!iret
, "getsockopt failed %d\n", WSAGetLastError());
6191 ok(connect_time
< 0xdeadbeef, "unexpected connect time %u\n", connect_time
);
6193 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
6194 ok(dwret
== WAIT_TIMEOUT
, "Waiting for accept event timeout failed with %d + errno %d\n", dwret
, GetLastError());
6196 iret
= getsockname( connector
, (struct sockaddr
*)&peerAddress
, &remoteSize
);
6197 ok( !iret
, "getsockname failed.\n");
6199 /* AcceptEx() could complete any time now */
6200 iret
= send(connector
, buffer
, 1, 0);
6201 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
6203 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6204 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6206 /* Check if the buffer from AcceptEx is decoded correctly */
6207 pGetAcceptExSockaddrs(buffer
, 2, sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6208 (struct sockaddr
**)&readBindAddress
, &localSize
,
6209 (struct sockaddr
**)&readRemoteAddress
, &remoteSize
);
6210 strcpy( ipbuffer
, inet_ntoa(readBindAddress
->sin_addr
));
6211 ok( readBindAddress
->sin_addr
.s_addr
== bindAddress
.sin_addr
.s_addr
,
6212 "Local socket address is different %s != %s\n",
6213 ipbuffer
, inet_ntoa(bindAddress
.sin_addr
));
6214 ok( readBindAddress
->sin_port
== bindAddress
.sin_port
,
6215 "Local socket port is different: %d != %d\n",
6216 readBindAddress
->sin_port
, bindAddress
.sin_port
);
6217 strcpy( ipbuffer
, inet_ntoa(readRemoteAddress
->sin_addr
));
6218 ok( readRemoteAddress
->sin_addr
.s_addr
== peerAddress
.sin_addr
.s_addr
,
6219 "Remote socket address is different %s != %s\n",
6220 ipbuffer
, inet_ntoa(peerAddress
.sin_addr
));
6221 ok( readRemoteAddress
->sin_port
== peerAddress
.sin_port
,
6222 "Remote socket port is different: %d != %d\n",
6223 readRemoteAddress
->sin_port
, peerAddress
.sin_port
);
6225 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6226 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6227 ok(bytesReturned
== 1, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6229 closesocket(connector
);
6230 connector
= INVALID_SOCKET
;
6231 closesocket(acceptor
);
6233 /* Test CF_DEFER & AcceptEx interaction */
6235 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6236 if (acceptor
== INVALID_SOCKET
) {
6237 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6240 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6241 if (connector
== INVALID_SOCKET
) {
6242 skip("could not create connector socket, error %d\n", WSAGetLastError());
6245 connector2
= socket(AF_INET
, SOCK_STREAM
, 0);
6246 if (connector
== INVALID_SOCKET
) {
6247 skip("could not create connector socket, error %d\n", WSAGetLastError());
6251 if (set_blocking(connector
, FALSE
)) {
6252 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
6256 if (set_blocking(connector2
, FALSE
)) {
6257 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
6261 /* Connect socket #1 */
6262 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6263 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6265 FD_ZERO ( &fds_accept
);
6266 FD_ZERO ( &fds_send
);
6268 FD_SET ( listener
, &fds_accept
);
6269 FD_SET ( connector
, &fds_send
);
6275 for (i
= 0; i
< 4000; ++i
)
6277 fd_set fds_openaccept
= fds_accept
, fds_opensend
= fds_send
;
6279 wsa_ok ( ( select ( 0, &fds_openaccept
, &fds_opensend
, NULL
, &timeout
) ), SOCKET_ERROR
!=,
6280 "acceptex test(%d): could not select on socket, errno %d\n" );
6282 /* check for incoming requests */
6283 if ( FD_ISSET ( listener
, &fds_openaccept
) ) {
6286 SOCKET tmp
= WSAAccept(listener
, NULL
, NULL
, (LPCONDITIONPROC
) AlwaysDeferConditionFunc
, 0);
6287 ok(tmp
== INVALID_SOCKET
&& WSAGetLastError() == WSATRY_AGAIN
, "Failed to defer connection, %d\n", WSAGetLastError());
6288 bret
= pAcceptEx(listener
, acceptor
, buffer
, 0,
6289 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6290 &bytesReturned
, &overlapped
);
6291 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6293 else if (got
== 2) {
6294 /* this should be socket #2 */
6295 SOCKET tmp
= accept(listener
, NULL
, NULL
);
6296 ok(tmp
!= INVALID_SOCKET
, "accept failed %d\n", WSAGetLastError());
6300 ok(FALSE
, "Got more than 2 connections?\n");
6303 if ( conn1
&& FD_ISSET ( connector2
, &fds_opensend
) ) {
6304 /* Send data on second socket, and stop */
6305 send(connector2
, "2", 1, 0);
6306 FD_CLR ( connector2
, &fds_send
);
6310 if ( FD_ISSET ( connector
, &fds_opensend
) ) {
6311 /* Once #1 is connected, allow #2 to connect */
6314 send(connector
, "1", 1, 0);
6315 FD_CLR ( connector
, &fds_send
);
6317 iret
= connect(connector2
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6318 ok(iret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEWOULDBLOCK
, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6319 FD_SET ( connector2
, &fds_send
);
6323 ok (got
== 2 || broken(got
== 1) /* NT4 */,
6324 "Did not get both connections, got %d\n", got
);
6326 dwret
= WaitForSingleObject(overlapped
.hEvent
, 0);
6327 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6329 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6330 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6331 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6333 set_blocking(acceptor
, TRUE
);
6334 iret
= recv( acceptor
, buffer
, 2, 0);
6335 ok(iret
== 1, "Failed to get data, %d, errno: %d\n", iret
, WSAGetLastError());
6337 ok(buffer
[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer
[0]);
6339 closesocket(connector
);
6340 connector
= INVALID_SOCKET
;
6341 closesocket(acceptor
);
6343 /* clean up in case of failures */
6344 while ((acceptor
= accept(listener
, NULL
, NULL
)) != INVALID_SOCKET
)
6345 closesocket(acceptor
);
6347 /* Disconnect during receive? */
6349 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6350 if (acceptor
== INVALID_SOCKET
) {
6351 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6354 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
6355 if (connector
== INVALID_SOCKET
) {
6356 skip("could not create connector socket, error %d\n", WSAGetLastError());
6359 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6360 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6361 &bytesReturned
, &overlapped
);
6362 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6364 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
6365 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6367 closesocket(connector
);
6368 connector
= INVALID_SOCKET
;
6370 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6371 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6373 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6374 ok(bret
, "GetOverlappedResult failed, error %d\n", GetLastError());
6375 ok(bytesReturned
== 0, "bytesReturned isn't supposed to be %d\n", bytesReturned
);
6377 closesocket(acceptor
);
6379 /* Test closing with pending requests */
6381 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6382 if (acceptor
== INVALID_SOCKET
) {
6383 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6386 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6387 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6388 &bytesReturned
, &overlapped
);
6389 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6391 closesocket(acceptor
);
6393 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6394 todo_wine
ok(dwret
== WAIT_OBJECT_0
|| broken(dwret
== WAIT_TIMEOUT
) /* NT4/2000 */,
6395 "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6397 if (dwret
!= WAIT_TIMEOUT
) {
6398 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6399 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
6402 bret
= CancelIo((HANDLE
) listener
);
6403 ok(bret
, "Failed to cancel failed test. Bailing...\n");
6405 WaitForSingleObject(overlapped
.hEvent
, 0);
6408 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6409 if (acceptor
== INVALID_SOCKET
) {
6410 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6413 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6414 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6415 &bytesReturned
, &overlapped
);
6416 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6418 CancelIo((HANDLE
) acceptor
);
6420 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6421 ok(dwret
== WAIT_TIMEOUT
, "Waiting for timeout failed with %d + errno %d\n", dwret
, GetLastError());
6423 closesocket(acceptor
);
6425 acceptor
= socket(AF_INET
, SOCK_STREAM
, 0);
6426 if (acceptor
== INVALID_SOCKET
) {
6427 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6430 bret
= pAcceptEx(listener
, acceptor
, buffer
, sizeof(buffer
) - 2*(sizeof(struct sockaddr_in
) + 16),
6431 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6432 &bytesReturned
, &overlapped
);
6433 ok(bret
== FALSE
&& WSAGetLastError() == ERROR_IO_PENDING
, "AcceptEx returned %d + errno %d\n", bret
, WSAGetLastError());
6435 closesocket(listener
);
6436 listener
= INVALID_SOCKET
;
6438 dwret
= WaitForSingleObject(overlapped
.hEvent
, 1000);
6439 ok(dwret
== WAIT_OBJECT_0
, "Waiting for accept event failed with %d + errno %d\n", dwret
, GetLastError());
6441 bret
= GetOverlappedResult((HANDLE
)listener
, &overlapped
, &bytesReturned
, FALSE
);
6442 ok(!bret
&& GetLastError() == ERROR_OPERATION_ABORTED
, "GetOverlappedResult failed, error %d\n", GetLastError());
6445 if (overlapped
.hEvent
)
6446 WSACloseEvent(overlapped
.hEvent
);
6447 if (listener
!= INVALID_SOCKET
)
6448 closesocket(listener
);
6449 if (acceptor
!= INVALID_SOCKET
)
6450 closesocket(acceptor
);
6451 if (connector
!= INVALID_SOCKET
)
6452 closesocket(connector
);
6453 if (connector2
!= INVALID_SOCKET
)
6454 closesocket(connector2
);
6457 static void test_getpeername(void)
6460 struct sockaddr_in sa
, sa_out
;
6461 SOCKADDR_STORAGE ss
;
6463 const char buf
[] = "hello world";
6466 /* Test the parameter validation order. */
6467 ret
= getpeername(INVALID_SOCKET
, NULL
, NULL
);
6468 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
6469 ok(WSAGetLastError() == WSAENOTSOCK
,
6470 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
6472 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
6473 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
6474 if (sock
== INVALID_SOCKET
)
6476 skip("Socket creation failed with %d\n", WSAGetLastError());
6480 ret
= getpeername(sock
, NULL
, NULL
);
6481 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
6482 ok(WSAGetLastError() == WSAENOTCONN
||
6483 broken(WSAGetLastError() == WSAEFAULT
), /* Win9x and WinMe */
6484 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
6486 memset(&sa
, 0, sizeof(sa
));
6487 sa
.sin_family
= AF_INET
;
6488 sa
.sin_port
= htons(139);
6489 sa
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
6491 /* sendto does not change a socket's connection state. */
6492 ret
= sendto(sock
, buf
, sizeof(buf
), 0, (struct sockaddr
*)&sa
, sizeof(sa
));
6493 ok(ret
!= SOCKET_ERROR
,
6494 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
6496 ret
= getpeername(sock
, NULL
, NULL
);
6497 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
6498 ok(WSAGetLastError() == WSAENOTCONN
||
6499 broken(WSAGetLastError() == WSAEFAULT
), /* Win9x and WinMe */
6500 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
6502 ret
= connect(sock
, (struct sockaddr
*)&sa
, sizeof(sa
));
6504 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
6506 ret
= getpeername(sock
, NULL
, NULL
);
6507 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
6508 ok(WSAGetLastError() == WSAEFAULT
,
6509 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6511 /* Test crashes on Wine. */
6514 ret
= getpeername(sock
, (void*)0xdeadbeef, (void*)0xcafebabe);
6515 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret
);
6516 ok(WSAGetLastError() == WSAEFAULT
,
6517 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6520 ret
= getpeername(sock
, (struct sockaddr
*)&sa_out
, NULL
);
6521 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
6522 ok(WSAGetLastError() == WSAEFAULT
,
6523 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6526 ret
= getpeername(sock
, NULL
, &sa_len
);
6527 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
6528 ok(WSAGetLastError() == WSAEFAULT
,
6529 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6530 ok(!sa_len
, "got %d\n", sa_len
);
6533 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
6534 ok(ret
== SOCKET_ERROR
, "Expected getpeername to return 0, got %d\n", ret
);
6535 ok(WSAGetLastError() == WSAEFAULT
,
6536 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6537 ok(!sa_len
, "got %d\n", sa_len
);
6539 sa_len
= sizeof(ss
);
6540 ret
= getpeername(sock
, (struct sockaddr
*)&ss
, &sa_len
);
6541 ok(ret
== 0, "Expected getpeername to return 0, got %d\n", ret
);
6542 ok(!memcmp(&sa
, &ss
, sizeof(sa
)),
6543 "Expected the returned structure to be identical to the connect structure\n");
6544 ok(sa_len
== sizeof(sa
), "got %d\n", sa_len
);
6549 static void test_sioRoutingInterfaceQuery(void)
6553 SOCKADDR_IN sin
= { 0 }, sout
= { 0 };
6554 DWORD bytesReturned
;
6556 sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
6557 ok(sock
!= INVALID_SOCKET
, "Expected socket to return a valid socket\n");
6558 if (sock
== INVALID_SOCKET
)
6560 skip("Socket creation failed with %d\n", WSAGetLastError());
6563 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, NULL
, 0, NULL
, 0, NULL
,
6565 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
6566 "expected WSAEFAULT, got %d\n", WSAGetLastError());
6567 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
6568 NULL
, 0, NULL
, NULL
, NULL
);
6569 ok(ret
== SOCKET_ERROR
&& WSAGetLastError() == WSAEFAULT
,
6570 "expected WSAEFAULT, got %d\n", WSAGetLastError());
6571 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
6572 NULL
, 0, &bytesReturned
, NULL
, NULL
);
6573 ok(ret
== SOCKET_ERROR
&&
6574 (WSAGetLastError() == WSAEFAULT
/* Win98 */ ||
6575 WSAGetLastError() == WSAEINVAL
/* NT4 */||
6576 WSAGetLastError() == WSAEAFNOSUPPORT
),
6577 "expected WSAEFAULT or WSAEINVAL or WSAEAFNOSUPPORT, got %d\n",
6579 sin
.sin_family
= AF_INET
;
6580 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
6581 NULL
, 0, &bytesReturned
, NULL
, NULL
);
6582 ok(ret
== SOCKET_ERROR
&&
6583 (WSAGetLastError() == WSAEFAULT
/* Win98 */ ||
6584 WSAGetLastError() == WSAEINVAL
),
6585 "expected WSAEFAULT or WSAEINVAL, got %d\n", WSAGetLastError());
6586 sin
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
6587 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
6588 NULL
, 0, &bytesReturned
, NULL
, NULL
);
6589 ok(ret
== SOCKET_ERROR
&&
6590 (WSAGetLastError() == WSAEINVAL
/* NT4 */ ||
6591 WSAGetLastError() == WSAEFAULT
),
6592 "expected WSAEINVAL or WSAEFAULT, got %d\n", WSAGetLastError());
6593 ret
= WSAIoctl(sock
, SIO_ROUTING_INTERFACE_QUERY
, &sin
, sizeof(sin
),
6594 &sout
, sizeof(sout
), &bytesReturned
, NULL
, NULL
);
6595 ok(!ret
|| broken(WSAGetLastError() == WSAEINVAL
/* NT4 */),
6596 "WSAIoctl failed: %d\n", WSAGetLastError());
6599 ok(sout
.sin_family
== AF_INET
, "expected AF_INET, got %d\n",
6601 /* We expect the source address to be INADDR_LOOPBACK as well, but
6602 * there's no guarantee that a route to the loopback address exists,
6603 * so rather than introduce spurious test failures we do not test the
6610 static void test_synchronous_WSAIoctl(void)
6612 HANDLE previous_port
, io_port
;
6613 WSAOVERLAPPED overlapped
, *olp
;
6621 previous_port
= CreateIoCompletionPort( INVALID_HANDLE_VALUE
, NULL
, 0, 0 );
6622 ok( previous_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
6624 socket
= WSASocketW( AF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0, WSA_FLAG_OVERLAPPED
);
6625 ok( socket
!= INVALID_SOCKET
, "failed to create socket %d\n", WSAGetLastError() );
6627 io_port
= CreateIoCompletionPort( (HANDLE
)socket
, previous_port
, 0, 0 );
6628 ok( io_port
!= NULL
, "failed to create completion port %u\n", GetLastError() );
6631 memset( &overlapped
, 0, sizeof(overlapped
) );
6632 res
= WSAIoctl( socket
, FIONBIO
, &on
, sizeof(on
), NULL
, 0, &num_bytes
, &overlapped
, NULL
);
6633 ok( !res
, "WSAIoctl failed %d\n", WSAGetLastError() );
6635 ret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 10000 );
6636 ok( ret
, "failed to get completion status %u\n", GetLastError() );
6638 CloseHandle( io_port
);
6639 closesocket( socket
);
6640 CloseHandle( previous_port
);
6643 #define WM_ASYNCCOMPLETE (WM_USER + 100)
6644 static HWND
create_async_message_window(void)
6646 static const char class_name
[] = "ws2_32 async message window class";
6648 WNDCLASSEXA wndclass
;
6651 wndclass
.cbSize
= sizeof(wndclass
);
6652 wndclass
.style
= CS_HREDRAW
| CS_VREDRAW
;
6653 wndclass
.lpfnWndProc
= DefWindowProcA
;
6654 wndclass
.cbClsExtra
= 0;
6655 wndclass
.cbWndExtra
= 0;
6656 wndclass
.hInstance
= GetModuleHandleA(NULL
);
6657 wndclass
.hIcon
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
6658 wndclass
.hIconSm
= LoadIconA(NULL
, (LPCSTR
)IDI_APPLICATION
);
6659 wndclass
.hCursor
= LoadCursorA(NULL
, (LPCSTR
)IDC_ARROW
);
6660 wndclass
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+ 1);
6661 wndclass
.lpszClassName
= class_name
;
6662 wndclass
.lpszMenuName
= NULL
;
6664 RegisterClassExA(&wndclass
);
6666 hWnd
= CreateWindowA(class_name
, "ws2_32 async message window", WS_OVERLAPPEDWINDOW
,
6667 0, 0, 500, 500, NULL
, NULL
, GetModuleHandleA(NULL
), NULL
);
6670 ok(0, "failed to create window: %u\n", GetLastError());
6677 static void test_WSAAsyncGetServByPort(void)
6679 HWND hwnd
= create_async_message_window();
6681 char buffer
[MAXGETHOSTSTRUCT
];
6686 /* FIXME: The asynchronous window messages should be tested. */
6688 /* Parameters are not checked when initiating the asynchronous operation. */
6689 ret
= WSAAsyncGetServByPort(NULL
, 0, 0, NULL
, NULL
, 0);
6690 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
6692 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, 0, NULL
, NULL
, 0);
6693 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
6695 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, htons(80), NULL
, NULL
, 0);
6696 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
6698 ret
= WSAAsyncGetServByPort(hwnd
, WM_ASYNCCOMPLETE
, htons(80), NULL
, buffer
, MAXGETHOSTSTRUCT
);
6699 ok(ret
!= NULL
, "WSAAsyncGetServByPort returned NULL\n");
6701 DestroyWindow(hwnd
);
6704 static void test_WSAAsyncGetServByName(void)
6706 HWND hwnd
= create_async_message_window();
6708 char buffer
[MAXGETHOSTSTRUCT
];
6713 /* FIXME: The asynchronous window messages should be tested. */
6715 /* Parameters are not checked when initiating the asynchronous operation. */
6716 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "", NULL
, NULL
, 0);
6717 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
6719 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "", "", buffer
, MAXGETHOSTSTRUCT
);
6720 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
6722 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "http", NULL
, NULL
, 0);
6723 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
6725 ret
= WSAAsyncGetServByName(hwnd
, WM_ASYNCCOMPLETE
, "http", "tcp", buffer
, MAXGETHOSTSTRUCT
);
6726 ok(ret
!= NULL
, "WSAAsyncGetServByName returned NULL\n");
6728 DestroyWindow(hwnd
);
6732 * Provide consistent initialization for the AcceptEx IOCP tests.
6734 static SOCKET
setup_iocp_src(struct sockaddr_in
*bindAddress
)
6736 SOCKET src
, ret
= INVALID_SOCKET
;
6739 src
= socket(AF_INET
, SOCK_STREAM
, 0);
6740 if (src
== INVALID_SOCKET
)
6742 skip("could not create listener socket, error %d\n", WSAGetLastError());
6746 memset(bindAddress
, 0, sizeof(*bindAddress
));
6747 bindAddress
->sin_family
= AF_INET
;
6748 bindAddress
->sin_addr
.s_addr
= inet_addr("127.0.0.1");
6749 iret
= bind(src
, (struct sockaddr
*)bindAddress
, sizeof(*bindAddress
));
6752 skip("failed to bind, error %d\n", WSAGetLastError());
6756 socklen
= sizeof(*bindAddress
);
6757 iret
= getsockname(src
, (struct sockaddr
*)bindAddress
, &socklen
);
6759 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
6763 if (set_blocking(src
, FALSE
))
6765 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
6769 iret
= listen(src
, 5);
6772 skip("listening failed, errno = %d\n", WSAGetLastError());
6778 if (src
!= ret
&& ret
== INVALID_SOCKET
)
6783 static void test_completion_port(void)
6785 HANDLE previous_port
, io_port
;
6786 WSAOVERLAPPED ov
, *olp
;
6787 SOCKET src
, dest
, dup
, connector
= INVALID_SOCKET
;
6788 WSAPROTOCOL_INFOA info
;
6791 DWORD num_bytes
, flags
;
6796 struct sockaddr_in bindAddress
;
6797 GUID acceptExGuid
= WSAID_ACCEPTEX
;
6798 LPFN_ACCEPTEX pAcceptEx
= NULL
;
6800 previous_port
= CreateIoCompletionPort(INVALID_HANDLE_VALUE
, NULL
, 0, 0);
6801 ok( previous_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
6803 memset(&ov
, 0, sizeof(ov
));
6805 tcp_socketpair(&src
, &dest
);
6806 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
6808 skip("failed to create sockets\n");
6812 bufs
.len
= sizeof(buf
);
6818 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
6819 ok(!iret
, "Failed to set linger %d\n", GetLastError());
6821 io_port
= CreateIoCompletionPort( (HANDLE
)dest
, previous_port
, 125, 0 );
6822 ok(io_port
!= NULL
, "Failed to create completion port %u\n", GetLastError());
6824 SetLastError(0xdeadbeef);
6826 iret
= WSARecv(dest
, &bufs
, 1, &num_bytes
, &flags
, &ov
, NULL
);
6827 ok(iret
== SOCKET_ERROR
, "WSARecv returned %d\n", iret
);
6828 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
6833 src
= INVALID_SOCKET
;
6835 SetLastError(0xdeadbeef);
6837 num_bytes
= 0xdeadbeef;
6838 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6840 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
6841 todo_wine
ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
6842 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
, "Last error was %d\n", GetLastError());
6843 ok(key
== 125, "Key is %lu\n", key
);
6844 ok(num_bytes
== 0, "Number of bytes received is %u\n", num_bytes
);
6845 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
6847 SetLastError(0xdeadbeef);
6849 num_bytes
= 0xdeadbeef;
6850 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6852 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
6853 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %d\n", bret
);
6854 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6855 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6856 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6857 ok(!olp
, "Overlapped structure is at %p\n", olp
);
6859 if (dest
!= INVALID_SOCKET
)
6862 memset(&ov
, 0, sizeof(ov
));
6864 tcp_socketpair(&src
, &dest
);
6865 if (src
== INVALID_SOCKET
|| dest
== INVALID_SOCKET
)
6867 skip("failed to create sockets\n");
6871 bufs
.len
= sizeof(buf
);
6877 iret
= setsockopt (src
, SOL_SOCKET
, SO_LINGER
, (char *) &ling
, sizeof(ling
));
6878 ok(!iret
, "Failed to set linger %d\n", GetLastError());
6880 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 125, 0);
6881 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
6883 set_blocking(dest
, FALSE
);
6886 src
= INVALID_SOCKET
;
6890 num_bytes
= 0xdeadbeef;
6891 SetLastError(0xdeadbeef);
6893 iret
= WSASend(dest
, &bufs
, 1, &num_bytes
, 0, &ov
, NULL
);
6894 ok(iret
== SOCKET_ERROR
, "WSASend failed - %d\n", iret
);
6895 ok(GetLastError() == WSAECONNRESET
, "Last error was %d\n", GetLastError());
6896 ok(num_bytes
== 0xdeadbeef, "Managed to send %d\n", num_bytes
);
6898 SetLastError(0xdeadbeef);
6900 num_bytes
= 0xdeadbeef;
6901 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6903 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
6904 ok(bret
== FALSE
, "GetQueuedCompletionStatus returned %u\n", bret
);
6905 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6906 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6907 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6908 ok(!olp
, "Overlapped structure is at %p\n", olp
);
6910 if (dest
!= INVALID_SOCKET
)
6913 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
6914 if (dest
== INVALID_SOCKET
)
6916 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6920 iret
= WSAIoctl(dest
, SIO_GET_EXTENSION_FUNCTION_POINTER
, &acceptExGuid
, sizeof(acceptExGuid
),
6921 &pAcceptEx
, sizeof(pAcceptEx
), &num_bytes
, NULL
, NULL
);
6924 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret
, WSAGetLastError());
6928 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
6930 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
6933 SetLastError(0xdeadbeef);
6935 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
6936 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6938 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
6939 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
6941 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
6942 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
6945 src
= INVALID_SOCKET
;
6947 SetLastError(0xdeadbeef);
6949 num_bytes
= 0xdeadbeef;
6950 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6952 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
6953 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6954 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
6955 ok(key
== 125, "Key is %lu\n", key
);
6956 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
6957 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
6958 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
6960 SetLastError(0xdeadbeef);
6962 num_bytes
= 0xdeadbeef;
6963 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6964 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
6965 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6966 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
6967 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
6968 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
6969 ok(!olp
, "Overlapped structure is at %p\n", olp
);
6971 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
6973 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
6976 SetLastError(0xdeadbeef);
6978 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
6979 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
6981 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
6982 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
6984 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
6985 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
6988 src
= INVALID_SOCKET
;
6990 SetLastError(0xdeadbeef);
6992 num_bytes
= 0xdeadbeef;
6993 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
6995 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
6996 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
6997 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
6998 ok(key
== 125, "Key is %lu\n", key
);
6999 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7000 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7001 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7003 SetLastError(0xdeadbeef);
7005 num_bytes
= 0xdeadbeef;
7006 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7007 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7008 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7009 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7010 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7011 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7012 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7014 /* Test IOCP with duplicated handle */
7016 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
7019 SetLastError(0xdeadbeef);
7021 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
7022 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7024 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
7025 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
7026 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
7028 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7029 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7031 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7032 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7034 SetLastError(0xdeadbeef);
7036 num_bytes
= 0xdeadbeef;
7037 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7038 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7039 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7040 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7041 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7042 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7043 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7046 src
= INVALID_SOCKET
;
7048 dup
= INVALID_SOCKET
;
7050 SetLastError(0xdeadbeef);
7052 num_bytes
= 0xdeadbeef;
7053 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7054 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7055 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7056 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
7057 ok(key
== 125, "Key is %lu\n", key
);
7058 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7059 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7060 ok(olp
&& olp
->Internal
== (ULONG
)STATUS_CANCELLED
, "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7062 SetLastError(0xdeadbeef);
7064 num_bytes
= 0xdeadbeef;
7065 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7066 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7067 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7068 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7069 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7070 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7071 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7073 /* Test IOCP with duplicated handle (closing duplicated handle) */
7075 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
7078 SetLastError(0xdeadbeef);
7080 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
7081 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7083 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
7084 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
7085 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
7087 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7088 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7090 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7091 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7094 dup
= INVALID_SOCKET
;
7096 SetLastError(0xdeadbeef);
7098 num_bytes
= 0xdeadbeef;
7099 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7100 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7101 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7102 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7103 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7104 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7105 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7107 SetLastError(0xdeadbeef);
7109 num_bytes
= 0xdeadbeef;
7110 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7111 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7112 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7113 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7114 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7115 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7116 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7119 src
= INVALID_SOCKET
;
7121 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7122 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7123 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
7124 ok(key
== 125, "Key is %lu\n", key
);
7125 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7126 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7127 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7129 SetLastError(0xdeadbeef);
7131 num_bytes
= 0xdeadbeef;
7132 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7133 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7134 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7135 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7136 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7137 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7138 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7140 /* Test IOCP with duplicated handle (closing original handle) */
7142 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
7145 SetLastError(0xdeadbeef);
7147 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
7148 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7150 WSADuplicateSocketA( src
, GetCurrentProcessId(), &info
);
7151 dup
= WSASocketA(AF_INET
, SOCK_STREAM
, 0, &info
, 0, WSA_FLAG_OVERLAPPED
);
7152 ok(dup
!= INVALID_SOCKET
, "failed to duplicate socket!\n");
7154 bret
= pAcceptEx(dup
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7155 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7157 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7158 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7161 src
= INVALID_SOCKET
;
7163 SetLastError(0xdeadbeef);
7165 num_bytes
= 0xdeadbeef;
7166 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7167 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7168 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7169 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7170 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7171 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7172 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7175 dup
= INVALID_SOCKET
;
7177 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7178 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7179 ok(GetLastError() == ERROR_OPERATION_ABORTED
, "Last error was %d\n", GetLastError());
7180 ok(key
== 125, "Key is %lu\n", key
);
7181 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7182 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7183 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_CANCELLED
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7185 SetLastError(0xdeadbeef);
7187 num_bytes
= 0xdeadbeef;
7188 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7189 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7190 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7191 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7192 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7193 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7194 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7196 /* Test IOCP without AcceptEx */
7198 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
7201 SetLastError(0xdeadbeef);
7203 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
7204 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7207 src
= INVALID_SOCKET
;
7209 SetLastError(0xdeadbeef);
7211 num_bytes
= 0xdeadbeef;
7212 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7213 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7214 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7215 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7216 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7217 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7218 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7222 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
7225 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7226 if (connector
== INVALID_SOCKET
) {
7227 skip("could not create connector socket, error %d\n", WSAGetLastError());
7231 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
7232 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7234 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
7235 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7237 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7238 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7240 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7241 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7243 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7244 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
7246 closesocket(connector
);
7247 connector
= INVALID_SOCKET
;
7249 SetLastError(0xdeadbeef);
7251 num_bytes
= 0xdeadbeef;
7252 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7254 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7255 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
7256 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
7257 ok(key
== 125, "Key is %lu\n", key
);
7258 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7259 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7260 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7262 SetLastError(0xdeadbeef);
7264 num_bytes
= 0xdeadbeef;
7265 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7266 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7267 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7268 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7269 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7270 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7271 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7273 if (dest
!= INVALID_SOCKET
)
7275 if (src
!= INVALID_SOCKET
)
7280 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
7283 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
7284 if (dest
== INVALID_SOCKET
)
7286 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7290 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7291 if (connector
== INVALID_SOCKET
) {
7292 skip("could not create connector socket, error %d\n", WSAGetLastError());
7296 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
7297 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7299 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
7300 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7302 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7303 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7305 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7306 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7308 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7309 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
7311 iret
= send(connector
, buf
, 1, 0);
7312 ok(iret
== 1, "could not send 1 byte: send %d errno %d\n", iret
, WSAGetLastError());
7317 dest
= INVALID_SOCKET
;
7319 SetLastError(0xdeadbeef);
7321 num_bytes
= 0xdeadbeef;
7322 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7324 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7325 ok(bret
== TRUE
, "failed to get completion status %u\n", bret
);
7326 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
7327 ok(key
== 125, "Key is %lu\n", key
);
7328 ok(num_bytes
== 1, "Number of bytes transferred is %u\n", num_bytes
);
7329 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7330 ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_SUCCESS
), "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7332 SetLastError(0xdeadbeef);
7334 num_bytes
= 0xdeadbeef;
7335 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7336 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7337 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7338 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7339 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7340 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7341 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7343 if (src
!= INVALID_SOCKET
)
7345 if (connector
!= INVALID_SOCKET
)
7346 closesocket(connector
);
7350 if ((src
= setup_iocp_src(&bindAddress
)) == INVALID_SOCKET
)
7353 dest
= socket(AF_INET
, SOCK_STREAM
, 0);
7354 if (dest
== INVALID_SOCKET
)
7356 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7360 connector
= socket(AF_INET
, SOCK_STREAM
, 0);
7361 if (connector
== INVALID_SOCKET
) {
7362 skip("could not create connector socket, error %d\n", WSAGetLastError());
7366 io_port
= CreateIoCompletionPort((HANDLE
)src
, previous_port
, 125, 0);
7367 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7369 io_port
= CreateIoCompletionPort((HANDLE
)dest
, previous_port
, 236, 0);
7370 ok(io_port
!= NULL
, "failed to create completion port %u\n", GetLastError());
7372 bret
= pAcceptEx(src
, dest
, buf
, sizeof(buf
) - 2*(sizeof(struct sockaddr_in
) + 16),
7373 sizeof(struct sockaddr_in
) + 16, sizeof(struct sockaddr_in
) + 16,
7375 ok(bret
== FALSE
, "AcceptEx returned %d\n", bret
);
7376 ok(GetLastError() == ERROR_IO_PENDING
, "Last error was %d\n", GetLastError());
7378 iret
= connect(connector
, (struct sockaddr
*)&bindAddress
, sizeof(bindAddress
));
7379 ok(iret
== 0, "connecting to accepting socket failed, error %d\n", GetLastError());
7382 dest
= INVALID_SOCKET
;
7384 SetLastError(0xdeadbeef);
7386 num_bytes
= 0xdeadbeef;
7387 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7389 bret
= GetQueuedCompletionStatus(io_port
, &num_bytes
, &key
, &olp
, 100);
7390 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7391 todo_wine
ok(GetLastError() == ERROR_NETNAME_DELETED
||
7392 GetLastError() == ERROR_OPERATION_ABORTED
||
7393 GetLastError() == ERROR_CONNECTION_ABORTED
||
7394 GetLastError() == ERROR_PIPE_NOT_CONNECTED
/* win 2000 */,
7395 "Last error was %d\n", GetLastError());
7396 ok(key
== 125, "Key is %lu\n", key
);
7397 ok(num_bytes
== 0, "Number of bytes transferred is %u\n", num_bytes
);
7398 ok(olp
== &ov
, "Overlapped structure is at %p\n", olp
);
7399 todo_wine
ok(olp
&& (olp
->Internal
== (ULONG
)STATUS_LOCAL_DISCONNECT
||
7400 olp
->Internal
== (ULONG
)STATUS_CANCELLED
||
7401 olp
->Internal
== (ULONG
)STATUS_CONNECTION_ABORTED
||
7402 olp
->Internal
== (ULONG
)STATUS_PIPE_DISCONNECTED
/* win 2000 */),
7403 "Internal status is %lx\n", olp
? olp
->Internal
: 0);
7405 SetLastError(0xdeadbeef);
7407 num_bytes
= 0xdeadbeef;
7408 olp
= (WSAOVERLAPPED
*)0xdeadbeef;
7409 bret
= GetQueuedCompletionStatus( io_port
, &num_bytes
, &key
, &olp
, 200 );
7410 ok(bret
== FALSE
, "failed to get completion status %u\n", bret
);
7411 ok(GetLastError() == WAIT_TIMEOUT
, "Last error was %d\n", GetLastError());
7412 ok(key
== 0xdeadbeef, "Key is %lu\n", key
);
7413 ok(num_bytes
== 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes
);
7414 ok(!olp
, "Overlapped structure is at %p\n", olp
);
7418 if (dest
!= INVALID_SOCKET
)
7420 if (src
!= INVALID_SOCKET
)
7422 if (connector
!= INVALID_SOCKET
)
7423 closesocket(connector
);
7424 CloseHandle(previous_port
);
7427 static DWORD WINAPI
inet_ntoa_thread_proc(void *param
)
7431 HANDLE
*event
= param
;
7433 addr
= inet_addr("4.3.2.1");
7434 ok(addr
== htonl(0x04030201), "expected 0x04030201, got %08x\n", addr
);
7435 str
= inet_ntoa(*(struct in_addr
*)&addr
);
7436 ok(!strcmp(str
, "4.3.2.1"), "expected 4.3.2.1, got %s\n", str
);
7439 WaitForSingleObject(event
[1], 3000);
7444 static void test_inet_ntoa(void)
7448 HANDLE thread
, event
[2];
7451 addr
= inet_addr("1.2.3.4");
7452 ok(addr
== htonl(0x01020304), "expected 0x01020304, got %08x\n", addr
);
7453 str
= inet_ntoa(*(struct in_addr
*)&addr
);
7454 ok(!strcmp(str
, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str
);
7456 event
[0] = CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
7457 event
[1] = CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
7459 thread
= CreateThread(NULL
, 0, inet_ntoa_thread_proc
, event
, 0, &tid
);
7460 WaitForSingleObject(event
[0], 3000);
7462 ok(!strcmp(str
, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str
);
7465 WaitForSingleObject(thread
, 3000);
7467 CloseHandle(event
[0]);
7468 CloseHandle(event
[1]);
7469 CloseHandle(thread
);
7472 static void test_WSALookupService(void)
7474 char buffer
[4096], strbuff
[128];
7475 WSAQUERYSETW
*qs
= NULL
;
7479 DWORD error
, offset
, bsize
;
7481 if (!pWSALookupServiceBeginW
|| !pWSALookupServiceEnd
|| !pWSALookupServiceNextW
)
7483 win_skip("WSALookupServiceBeginW or WSALookupServiceEnd or WSALookupServiceNextW not found\n");
7487 qs
= (WSAQUERYSETW
*)buffer
;
7488 memset(qs
, 0, sizeof(*qs
));
7490 /* invalid parameter tests */
7491 ret
= pWSALookupServiceBeginW(NULL
, 0, &hnd
);
7492 error
= WSAGetLastError();
7493 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
7495 ok(error
== WSAEFAULT
, "expected 10014, got %d\n", error
);
7497 ret
= pWSALookupServiceBeginW(qs
, 0, NULL
);
7498 error
= WSAGetLastError();
7499 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
7501 ok(error
== WSAEFAULT
, "expected 10014, got %d\n", error
);
7503 ret
= pWSALookupServiceBeginW(qs
, 0, &hnd
);
7504 error
= WSAGetLastError();
7505 ok(ret
== SOCKET_ERROR
, "WSALookupServiceBeginW should have failed\n");
7507 ok(error
== WSAEINVAL
7508 || broken(error
== ERROR_INVALID_PARAMETER
) /* == XP */
7509 || broken(error
== WSAEFAULT
) /* == NT */
7510 || broken(error
== WSASERVICE_NOT_FOUND
) /* == 2000 */,
7511 "expected 10022, got %d\n", error
);
7513 ret
= pWSALookupServiceEnd(NULL
);
7514 error
= WSAGetLastError();
7516 ok(ret
== SOCKET_ERROR
, "WSALookupServiceEnd should have failed\n");
7518 ok(error
== ERROR_INVALID_HANDLE
, "expected 6, got %d\n", error
);
7520 /* standard network list query */
7521 qs
->dwSize
= sizeof(*qs
);
7522 hnd
= (HANDLE
)0xdeadbeef;
7523 ret
= pWSALookupServiceBeginW(qs
, LUP_RETURN_ALL
| LUP_DEEP
, &hnd
);
7524 error
= WSAGetLastError();
7525 if(ret
&& error
== ERROR_INVALID_PARAMETER
)
7527 win_skip("the current WSALookupServiceBeginW test is not supported in win <= 2000\n");
7532 ok(!ret
, "WSALookupServiceBeginW failed unexpectedly with error %d\n", error
);
7534 ok(hnd
!= (HANDLE
)0xdeadbeef, "Handle was not filled\n");
7539 memset(qs
, 0, sizeof(*qs
));
7540 bsize
= sizeof(buffer
);
7542 if (pWSALookupServiceNextW(hnd
, 0, &bsize
, qs
) == SOCKET_ERROR
)
7544 error
= WSAGetLastError();
7545 if (error
== WSA_E_NO_MORE
) break;
7546 ok(0, "Error %d happened while listing services\n", error
);
7550 WideCharToMultiByte(CP_ACP
, 0, qs
->lpszServiceInstanceName
, -1,
7551 strbuff
, sizeof(strbuff
), NULL
, NULL
);
7552 trace("Network Name: %s\n", strbuff
);
7554 /* network data is written in the blob field */
7557 /* each network may have multiple NLA_BLOB information structures */
7560 netdata
= (PNLA_BLOB
) &qs
->lpBlob
->pBlobData
[offset
];
7561 switch (netdata
->header
.type
)
7564 trace("\tNLA Data Type: NLA_RAW_DATA\n");
7567 trace("\tNLA Data Type: NLA_INTERFACE\n");
7568 trace("\t\tType: %d\n", netdata
->data
.interfaceData
.dwType
);
7569 trace("\t\tSpeed: %d\n", netdata
->data
.interfaceData
.dwSpeed
);
7570 trace("\t\tAdapter Name: %s\n", netdata
->data
.interfaceData
.adapterName
);
7572 case NLA_802_1X_LOCATION
:
7573 trace("\tNLA Data Type: NLA_802_1X_LOCATION\n");
7574 trace("\t\tInformation: %s\n", netdata
->data
.locationData
.information
);
7576 case NLA_CONNECTIVITY
:
7577 switch (netdata
->data
.connectivity
.type
)
7579 case NLA_NETWORK_AD_HOC
:
7580 trace("\t\tNetwork Type: AD HOC\n");
7582 case NLA_NETWORK_MANAGED
:
7583 trace("\t\tNetwork Type: Managed\n");
7585 case NLA_NETWORK_UNMANAGED
:
7586 trace("\t\tNetwork Type: Unmanaged\n");
7588 case NLA_NETWORK_UNKNOWN
:
7589 trace("\t\tNetwork Type: Unknown\n");
7591 switch (netdata
->data
.connectivity
.internet
)
7593 case NLA_INTERNET_NO
:
7594 trace("\t\tInternet connectivity: No\n");
7596 case NLA_INTERNET_YES
:
7597 trace("\t\tInternet connectivity: Yes\n");
7599 case NLA_INTERNET_UNKNOWN
:
7600 trace("\t\tInternet connectivity: Unknown\n");
7605 trace("\tNLA Data Type: NLA_ICS\n");
7606 trace("\t\tSpeed: %d\n",
7607 netdata
->data
.ICS
.remote
.speed
);
7608 trace("\t\tType: %d\n",
7609 netdata
->data
.ICS
.remote
.type
);
7610 trace("\t\tState: %d\n",
7611 netdata
->data
.ICS
.remote
.state
);
7612 WideCharToMultiByte(CP_ACP
, 0, netdata
->data
.ICS
.remote
.machineName
, -1,
7613 strbuff
, sizeof(strbuff
), NULL
, NULL
);
7614 trace("\t\tMachine Name: %s\n", strbuff
);
7615 WideCharToMultiByte(CP_ACP
, 0, netdata
->data
.ICS
.remote
.sharedAdapterName
, -1,
7616 strbuff
, sizeof(strbuff
), NULL
, NULL
);
7617 trace("\t\tShared Adapter Name: %s\n", strbuff
);
7620 trace("\tNLA Data Type: Unknown\n");
7629 ret
= pWSALookupServiceEnd(hnd
);
7630 ok(!ret
, "WSALookupServiceEnd failed unexpectedly\n");
7633 /**************** Main program ***************/
7639 /* Leave these tests at the beginning. They depend on WSAStartup not having been
7640 * called, which is done by Init() below. */
7641 test_WithoutWSAStartup();
7642 test_WithWSAStartup();
7647 test_set_getsockopt();
7648 test_so_reuseaddr();
7650 test_extendedSocketOptions();
7652 for (i
= 0; i
< sizeof(tests
)/sizeof(tests
[0]); i
++)
7654 trace ( " **** STARTING TEST %d ****\n", i
);
7655 do_test ( &tests
[i
] );
7656 trace ( " **** TEST %d COMPLETE ****\n", i
);
7661 test_getservbyname();
7663 test_WSADuplicateSocket();
7665 test_WSAAddressToStringA();
7666 test_WSAAddressToStringW();
7668 test_WSAStringToAddressA();
7669 test_WSAStringToAddressW();
7678 test_addr_to_print();
7681 test_gethostbyname_hack();
7691 test_GetAddrInfoW();
7696 test_sioRoutingInterfaceQuery();
7698 test_WSALookupService();
7700 test_WSAAsyncGetServByPort();
7701 test_WSAAsyncGetServByName();
7703 test_completion_port();
7705 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
7707 test_synchronous_WSAIoctl();