?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ws2_32: Add extended IPX protocol support.
[wine.git] / dlls / ws2_32 / tests / sock.c
blob59c356cf4efcb41ea33e026b73181c0316ecbf05
1 /*
2 * Unit test suite for winsock functions
3 *
4 * Copyright 2002 Martin Wilck
5 * Copyright 2005 Thomas Kho
6 * Copyright 2008 Jeff Zaroyko
7 *
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.
12 *
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.
17 *
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
21 */
22
23 #include <ntstatus.h>
24 #define WIN32_NO_STATUS
25 #include <winsock2.h>
26 #include <windows.h>
27 #include <winternl.h>
28 #include <ws2tcpip.h>
29 #include <wsipx.h>
30 #include <wsnwlink.h>
31 #include <mswsock.h>
32 #include <mstcpip.h>
33 #include <stdio.h>
34 #include "wine/test.h"
35
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 */
42
43 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
44
45 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
46 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
47
48 #define SERVERIP "127.0.0.1" /* IP to bind to */
49 #define SERVERPORT 9374 /* Port number to bind to */
50
51 #define wsa_ok(op, cond, msg) \
52 do { \
53 int tmp, err = 0; \
54 tmp = op; \
55 if ( !(cond tmp) ) err = WSAGetLastError(); \
56 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
57 } while (0);
58
59 #define make_keepalive(k, enable, time, interval) \
60 k.onoff = enable; \
61 k.keepalivetime = time; \
62 k.keepaliveinterval = interval;
63
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
71 /**************** Structs and typedefs ***************/
72
73 typedef struct thread_info
74 {
75 HANDLE thread;
76 DWORD id;
77 } thread_info;
78
79 /* Information in the server about open client connections */
80 typedef struct sock_info
81 {
82 SOCKET s;
83 struct sockaddr_in addr;
84 struct sockaddr_in peer;
85 char *buf;
86 int n_recvd;
87 int n_sent;
88 } sock_info;
89
90 /* Test parameters for both server & client */
91 typedef struct test_params
92 {
93 int sock_type;
94 int sock_prot;
95 const char *inet_addr;
96 short inet_port;
97 int chunk_size;
98 int n_chunks;
99 int n_clients;
100 } test_params;
101
102 /* server-specific test parameters */
103 typedef struct server_params
104 {
105 test_params *general;
106 DWORD sock_flags;
107 int buflen;
108 } server_params;
109
110 /* client-specific test parameters */
111 typedef struct client_params
112 {
113 test_params *general;
114 DWORD sock_flags;
115 int buflen;
116 } client_params;
117
118 /* This type combines all information for setting up a test scenario */
119 typedef struct test_setup
120 {
121 test_params general;
122 LPVOID srv;
123 server_params srv_params;
124 LPVOID clt;
125 client_params clt_params;
126 } test_setup;
127
128 /* Thread local storage for server */
129 typedef struct server_memory
130 {
131 SOCKET s;
132 struct sockaddr_in addr;
133 sock_info sock[MAX_CLIENTS];
134 } server_memory;
135
136 /* Thread local storage for client */
137 typedef struct client_memory
138 {
139 SOCKET s;
140 struct sockaddr_in addr;
141 char *send_buf;
142 char *recv_buf;
143 } client_memory;
144
145 /* SelectReadThread thread parameters */
146 typedef struct select_thread_params
147 {
148 SOCKET s;
149 BOOL ReadKilled;
150 } select_thread_params;
151
152 /**************** Static variables ***************/
153
154 static DWORD tls; /* Thread local storage index */
155 static HANDLE thread[1+MAX_CLIENTS];
156 static DWORD thread_id[1+MAX_CLIENTS];
157 static HANDLE server_ready;
158 static HANDLE client_ready[MAX_CLIENTS];
159 static int client_id;
160
161 /**************** General utility functions ***************/
162
163 static int tcp_socketpair(SOCKET *src, SOCKET *dst)
164 {
165 SOCKET server = INVALID_SOCKET;
166 struct sockaddr_in addr;
167 int len;
168 int ret;
169
170 *src = INVALID_SOCKET;
171 *dst = INVALID_SOCKET;
172
173 *src = socket(AF_INET, SOCK_STREAM, 0);
174 if (*src == INVALID_SOCKET)
175 goto end;
176
177 server = socket(AF_INET, SOCK_STREAM, 0);
178 if (server == INVALID_SOCKET)
179 goto end;
180
181 memset(&addr, 0, sizeof(addr));
182 addr.sin_family = AF_INET;
183 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
184 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
185 if (ret != 0)
186 goto end;
187
188 len = sizeof(addr);
189 ret = getsockname(server, (struct sockaddr*)&addr, &len);
190 if (ret != 0)
191 goto end;
192
193 ret = listen(server, 1);
194 if (ret != 0)
195 goto end;
196
197 ret = connect(*src, (struct sockaddr*)&addr, sizeof(addr));
198 if (ret != 0)
199 goto end;
200
201 len = sizeof(addr);
202 *dst = accept(server, (struct sockaddr*)&addr, &len);
203
204 end:
205 if (server != INVALID_SOCKET)
206 closesocket(server);
207 if (*src != INVALID_SOCKET && *dst != INVALID_SOCKET)
208 return 0;
209 closesocket(*src);
210 closesocket(*dst);
211 return -1;
212 }
213
214 static void set_so_opentype ( BOOL overlapped )
215 {
216 int optval = !overlapped, newval, len = sizeof (int);
217
218 ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
219 (LPVOID) &optval, sizeof (optval) ) == 0,
220 "setting SO_OPENTYPE failed\n" );
221 ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
222 (LPVOID) &newval, &len ) == 0,
223 "getting SO_OPENTYPE failed\n" );
224 ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
225 }
226
227 static int set_blocking ( SOCKET s, BOOL blocking )
228 {
229 u_long val = !blocking;
230 return ioctlsocket ( s, FIONBIO, &val );
231 }
232
233 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
234 {
235 char c, *p;
236 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
237 memset ( p, c, chunk_size );
238 }
239
240 static int test_buffer ( char *buf, int chunk_size, int n_chunks )
241 {
242 char c, *p;
243 int i;
244 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
245 {
246 for ( i = 0; i < chunk_size; i++ )
247 if ( p[i] != c ) return i;
248 }
249 return -1;
250 }
251
252 /*
253 * This routine is called when a client / server does not expect any more data,
254 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
255 */
256 static void read_zero_bytes ( SOCKET s )
257 {
258 char buf[256];
259 int tmp, n = 0;
260 while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
261 n += tmp;
262 ok ( n <= 0, "garbage data received: %d bytes\n", n );
263 }
264
265 static int do_oob_send ( SOCKET s, char *buf, int buflen, int sendlen )
266 {
267 char* last = buf + buflen, *p;
268 int n = 1;
269 for ( p = buf; n > 0 && p < last; p += n )
270 n = send ( s, p, min ( sendlen, last - p ), MSG_OOB );
271 wsa_ok ( n, 0 <=, "do_oob_send (%x): error %d\n" );
272 return p - buf;
273 }
274
275 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int sendlen )
276 {
277 char* last = buf + buflen, *p;
278 int n = 1;
279 for ( p = buf; n > 0 && p < last; p += n )
280 n = send ( s, p, min ( sendlen, last - p ), 0 );
281 wsa_ok ( n, 0 <=, "do_synchronous_send (%x): error %d\n" );
282 return p - buf;
283 }
284
285 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int recvlen )
286 {
287 char* last = buf + buflen, *p;
288 int n = 1;
289 for ( p = buf; n > 0 && p < last; p += n )
290 n = recv ( s, p, min ( recvlen, last - p ), 0 );
291 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
292 return p - buf;
293 }
294
295 static int do_synchronous_recvfrom ( SOCKET s, char *buf, int buflen,int flags,struct sockaddr *from, int *fromlen, int recvlen )
296 {
297 char* last = buf + buflen, *p;
298 int n = 1;
299 for ( p = buf; n > 0 && p < last; p += n )
300 n = recvfrom ( s, p, min ( recvlen, last - p ), 0, from, fromlen );
301 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
302 return p - buf;
303 }
304
305 /*
306 * Call this routine right after thread startup.
307 * SO_OPENTYPE must by 0, regardless what the server did.
308 */
309 static void check_so_opentype (void)
310 {
311 int tmp = 1, len;
312 len = sizeof (tmp);
313 getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
314 ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
315 }
316
317 /**************** Server utility functions ***************/
318
319 /*
320 * Even if we have closed our server socket cleanly,
321 * the OS may mark the address "in use" for some time -
322 * this happens with native Linux apps, too.
323 */
324 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
325 {
326 int err, wsaerr = 0, n_try = BIND_TRIES;
327
328 while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
329 ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
330 n_try-- >= 0)
331 {
332 trace ( "address in use, waiting ...\n" );
333 Sleep ( 1000 * BIND_SLEEP );
334 }
335 ok ( err == 0, "failed to bind: %d\n", wsaerr );
336 }
337
338 static void server_start ( server_params *par )
339 {
340 int i;
341 test_params *gen = par->general;
342 server_memory *mem = LocalAlloc ( LPTR, sizeof ( server_memory ) );
343
344 TlsSetValue ( tls, mem );
345 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
346 NULL, 0, par->sock_flags );
347 ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
348
349 mem->addr.sin_family = AF_INET;
350 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
351 mem->addr.sin_port = htons ( gen->inet_port );
352
353 for (i = 0; i < MAX_CLIENTS; i++)
354 {
355 mem->sock[i].s = INVALID_SOCKET;
356 mem->sock[i].buf = LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
357 mem->sock[i].n_recvd = 0;
358 mem->sock[i].n_sent = 0;
359 }
360
361 if ( gen->sock_type == SOCK_STREAM )
362 do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
363 }
364
365 static void server_stop (void)
366 {
367 int i;
368 server_memory *mem = TlsGetValue ( tls );
369
370 for (i = 0; i < MAX_CLIENTS; i++ )
371 {
372 LocalFree ( mem->sock[i].buf );
373 if ( mem->sock[i].s != INVALID_SOCKET )
374 closesocket ( mem->sock[i].s );
375 }
376 ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
377 LocalFree ( mem );
378 ExitThread ( GetCurrentThreadId () );
379 }
380
381 /**************** Client utilitiy functions ***************/
382
383 static void client_start ( client_params *par )
384 {
385 test_params *gen = par->general;
386 client_memory *mem = LocalAlloc (LPTR, sizeof (client_memory));
387
388 TlsSetValue ( tls, mem );
389
390 WaitForSingleObject ( server_ready, INFINITE );
391
392 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
393 NULL, 0, par->sock_flags );
394
395 mem->addr.sin_family = AF_INET;
396 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
397 mem->addr.sin_port = htons ( gen->inet_port );
398
399 ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
400
401 mem->send_buf = LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
402 mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
403 fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
404
405 SetEvent ( client_ready[client_id] );
406 /* Wait for the other clients to come up */
407 WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
408 }
409
410 static void client_stop (void)
411 {
412 client_memory *mem = TlsGetValue ( tls );
413 wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%x): %d\n" );
414 LocalFree ( mem->send_buf );
415 LocalFree ( mem );
416 ExitThread(0);
417 }
418
419 /**************** Servers ***************/
420
421 /*
422 * simple_server: A very basic server doing synchronous IO.
423 */
424 static VOID WINAPI simple_server ( server_params *par )
425 {
426 test_params *gen = par->general;
427 server_memory *mem;
428 int pos, n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
429 id = GetCurrentThreadId();
430
431 trace ( "simple_server (%x) starting\n", id );
432
433 set_so_opentype ( FALSE ); /* non-overlapped */
434 server_start ( par );
435 mem = TlsGetValue ( tls );
436
437 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
438 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%x): listen failed: %d\n");
439
440 trace ( "simple_server (%x) ready\n", id );
441 SetEvent ( server_ready ); /* notify clients */
442
443 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
444 {
445 trace ( "simple_server (%x): waiting for client\n", id );
446
447 /* accept a single connection */
448 tmp = sizeof ( mem->sock[0].peer );
449 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
450 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%x): accept failed: %d\n" );
451
452 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
453 "simple_server (%x): strange peer address\n", id );
454
455 /* Receive data & check it */
456 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
457 ok ( n_recvd == n_expected,
458 "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
459 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
460 ok ( pos == -1, "simple_server (%x): test pattern error: %d\n", id, pos);
461
462 /* Echo data back */
463 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
464 ok ( n_sent == n_expected,
465 "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
466
467 /* cleanup */
468 read_zero_bytes ( mem->sock[0].s );
469 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "simple_server (%x): closesocket error: %d\n" );
470 mem->sock[0].s = INVALID_SOCKET;
471 }
472
473 trace ( "simple_server (%x) exiting\n", id );
474 server_stop ();
475 }
476
477 /*
478 * oob_server: A very basic server receiving out-of-band data.
479 */
480 static VOID WINAPI oob_server ( server_params *par )
481 {
482 test_params *gen = par->general;
483 server_memory *mem;
484 u_long atmark = 0;
485 int pos, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, tmp,
486 id = GetCurrentThreadId();
487
488 trace ( "oob_server (%x) starting\n", id );
489
490 set_so_opentype ( FALSE ); /* non-overlapped */
491 server_start ( par );
492 mem = TlsGetValue ( tls );
493
494 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "oob_server (%x): failed to set blocking mode: %d\n");
495 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "oob_server (%x): listen failed: %d\n");
496
497 trace ( "oob_server (%x) ready\n", id );
498 SetEvent ( server_ready ); /* notify clients */
499
500 trace ( "oob_server (%x): waiting for client\n", id );
501
502 /* accept a single connection */
503 tmp = sizeof ( mem->sock[0].peer );
504 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
505 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "oob_server (%x): accept failed: %d\n" );
506
507 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
508 "oob_server (%x): strange peer address\n", id );
509
510 /* check atmark state */
511 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
512 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
513
514 /* Receive normal data and check atmark state */
515 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
516 ok ( n_recvd == n_expected,
517 "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
518 pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
519 ok ( pos == -1, "simple_server (%x): test pattern error: %d\n", id, pos);
520
521 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
522 ok ( atmark == 1, "oob_server (%x): unexpectedly at the OOB mark: %i\n", id, atmark );
523
524 /* Receive a part of the out-of-band data and check atmark state */
525 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, 8, par->buflen );
526 ok ( n_recvd == 8,
527 "oob_server (%x): received less data than expected: %d of %d\n", id, n_recvd, 8 );
528 n_expected -= 8;
529
530 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
531 todo_wine ok ( atmark == 0, "oob_server (%x): not at the OOB mark: %i\n", id, atmark );
532
533 /* Receive the rest of the out-of-band data and check atmark state */
534 do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
535
536 ioctlsocket ( mem->sock[0].s, SIOCATMARK, &atmark );
537 todo_wine ok ( atmark == 0, "oob_server (%x): not at the OOB mark: %i\n", id, atmark );
538
539 /* cleanup */
540 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "oob_server (%x): closesocket error: %d\n" );
541 mem->sock[0].s = INVALID_SOCKET;
542
543 trace ( "oob_server (%x) exiting\n", id );
544 server_stop ();
545 }
546
547 /*
548 * select_server: A non-blocking server.
549 */
550 static VOID WINAPI select_server ( server_params *par )
551 {
552 test_params *gen = par->general;
553 server_memory *mem;
554 int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
555 id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
556 n_set, delta, n_ready;
557 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
558 fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
559
560 trace ( "select_server (%x) starting\n", id );
561
562 set_so_opentype ( FALSE ); /* non-overlapped */
563 server_start ( par );
564 mem = TlsGetValue ( tls );
565
566 wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
567 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%x): listen failed: %d\n");
568
569 trace ( "select_server (%x) ready\n", id );
570 SetEvent ( server_ready ); /* notify clients */
571
572 FD_ZERO ( &fds_openrecv );
573 FD_ZERO ( &fds_recv );
574 FD_ZERO ( &fds_send );
575 FD_ZERO ( &fds_opensend );
576
577 FD_SET ( mem->s, &fds_openrecv );
578
579 while(1)
580 {
581 fds_recv = fds_openrecv;
582 fds_send = fds_opensend;
583
584 n_set = 0;
585
586 wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
587 "select_server (%x): select() failed: %d\n" );
588
589 /* check for incoming requests */
590 if ( FD_ISSET ( mem->s, &fds_recv ) ) {
591 n_set += 1;
592
593 trace ( "select_server (%x): accepting client connection\n", id );
594
595 /* accept a single connection */
596 tmp = sizeof ( mem->sock[n_connections].peer );
597 mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
598 wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%x): accept() failed: %d\n" );
599
600 ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
601 "select_server (%x): strange peer address\n", id );
602
603 /* add to list of open connections */
604 FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
605 FD_SET ( mem->sock[n_connections].s, &fds_opensend );
606
607 n_connections++;
608 }
609
610 /* handle open requests */
611
612 for ( i = 0; i < n_connections; i++ )
613 {
614 if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
615 n_set += 1;
616
617 if ( mem->sock[i].n_recvd < n_expected ) {
618 /* Receive data & check it */
619 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 );
620 ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
621 mem->sock[i].n_recvd += n_recvd;
622
623 if ( mem->sock[i].n_recvd == n_expected ) {
624 int pos = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
625 ok ( pos == -1, "select_server (%x): test pattern error: %d\n", id, pos );
626 FD_CLR ( mem->sock[i].s, &fds_openrecv );
627 }
628
629 ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
630 }
631 }
632
633 /* only echo back what we've received */
634 delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
635
636 if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
637 n_set += 1;
638
639 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
640 /* Echo data back */
641 n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
642 ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
643 mem->sock[i].n_sent += n_sent;
644
645 if ( mem->sock[i].n_sent == n_expected ) {
646 FD_CLR ( mem->sock[i].s, &fds_opensend );
647 }
648
649 ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
650 }
651 }
652 }
653
654 /* check that select returned the correct number of ready sockets */
655 ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
656
657 /* check if all clients are done */
658 if ( ( fds_opensend.fd_count == 0 )
659 && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
660 && ( n_connections == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
661 break;
662 }
663 }
664
665 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
666 {
667 /* cleanup */
668 read_zero_bytes ( mem->sock[i].s );
669 wsa_ok ( closesocket ( mem->sock[i].s ), 0 ==, "select_server (%x): closesocket error: %d\n" );
670 mem->sock[i].s = INVALID_SOCKET;
671 }
672
673 trace ( "select_server (%x) exiting\n", id );
674 server_stop ();
675 }
676
677 /**************** Clients ***************/
678
679 /*
680 * simple_client: A very basic client doing synchronous IO.
681 */
682 static VOID WINAPI simple_client ( client_params *par )
683 {
684 test_params *gen = par->general;
685 client_memory *mem;
686 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
687
688 id = GetCurrentThreadId();
689 trace ( "simple_client (%x): starting\n", id );
690 /* wait here because we want to call set_so_opentype before creating a socket */
691 WaitForSingleObject ( server_ready, INFINITE );
692 trace ( "simple_client (%x): server ready\n", id );
693
694 check_so_opentype ();
695 set_so_opentype ( FALSE ); /* non-overlapped */
696 client_start ( par );
697 mem = TlsGetValue ( tls );
698
699 /* Connect */
700 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
701 0 ==, "simple_client (%x): connect error: %d\n" );
702 ok ( set_blocking ( mem->s, TRUE ) == 0,
703 "simple_client (%x): failed to set blocking mode\n", id );
704 trace ( "simple_client (%x) connected\n", id );
705
706 /* send data to server */
707 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, par->buflen );
708 ok ( n_sent == n_expected,
709 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
710
711 /* shutdown send direction */
712 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
713
714 /* Receive data echoed back & check it */
715 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, par->buflen );
716 ok ( n_recvd == n_expected,
717 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
718
719 /* check data */
720 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
721 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
722
723 /* cleanup */
724 read_zero_bytes ( mem->s );
725 trace ( "simple_client (%x) exiting\n", id );
726 client_stop ();
727 }
728
729 /*
730 * oob_client: A very basic client sending out-of-band data.
731 */
732 static VOID WINAPI oob_client ( client_params *par )
733 {
734 test_params *gen = par->general;
735 client_memory *mem;
736 int n_sent, n_expected = gen->n_chunks * gen->chunk_size, id;
737
738 id = GetCurrentThreadId();
739 trace ( "oob_client (%x): starting\n", id );
740 /* wait here because we want to call set_so_opentype before creating a socket */
741 WaitForSingleObject ( server_ready, INFINITE );
742 trace ( "oob_client (%x): server ready\n", id );
743
744 check_so_opentype ();
745 set_so_opentype ( FALSE ); /* non-overlapped */
746 client_start ( par );
747 mem = TlsGetValue ( tls );
748
749 /* Connect */
750 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
751 0 ==, "oob_client (%x): connect error: %d\n" );
752 ok ( set_blocking ( mem->s, TRUE ) == 0,
753 "oob_client (%x): failed to set blocking mode\n", id );
754 trace ( "oob_client (%x) connected\n", id );
755
756 /* send data to server */
757 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, par->buflen );
758 ok ( n_sent == n_expected,
759 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
760
761 /* send out-of-band data to server */
762 n_sent = do_oob_send ( mem->s, mem->send_buf, n_expected, par->buflen );
763 ok ( n_sent == n_expected,
764 "oob_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
765
766 /* shutdown send direction */
767 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
768
769 /* cleanup */
770 read_zero_bytes ( mem->s );
771 trace ( "oob_client (%x) exiting\n", id );
772 client_stop ();
773 }
774
775 /*
776 * simple_mixed_client: mixing send and recvfrom
777 */
778 static VOID WINAPI simple_mixed_client ( client_params *par )
779 {
780 test_params *gen = par->general;
781 client_memory *mem;
782 int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
783 int fromLen = sizeof(mem->addr);
784 struct sockaddr test;
785
786 id = GetCurrentThreadId();
787 trace ( "simple_client (%x): starting\n", id );
788 /* wait here because we want to call set_so_opentype before creating a socket */
789 WaitForSingleObject ( server_ready, INFINITE );
790 trace ( "simple_client (%x): server ready\n", id );
791
792 check_so_opentype ();
793 set_so_opentype ( FALSE ); /* non-overlapped */
794 client_start ( par );
795 mem = TlsGetValue ( tls );
796
797 /* Connect */
798 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
799 0 ==, "simple_client (%x): connect error: %d\n" );
800 ok ( set_blocking ( mem->s, TRUE ) == 0,
801 "simple_client (%x): failed to set blocking mode\n", id );
802 trace ( "simple_client (%x) connected\n", id );
803
804 /* send data to server */
805 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, par->buflen );
806 ok ( n_sent == n_expected,
807 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
808
809 /* shutdown send direction */
810 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
811
812 /* this shouldn't change, since lpFrom, is not updated on
813 connection oriented sockets - exposed by bug 11640
814 */
815 ((struct sockaddr_in*)&test)->sin_addr.s_addr = inet_addr("0.0.0.0");
816
817 /* Receive data echoed back & check it */
818 n_recvd = do_synchronous_recvfrom ( mem->s,
819 mem->recv_buf,
820 n_expected,
821 0,
822 (struct sockaddr *)&test,
823 &fromLen,
824 par->buflen );
825 ok ( n_recvd == n_expected,
826 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
827
828 /* check that lpFrom was not updated */
829 ok(0 ==
830 strcmp(
831 inet_ntoa(((struct sockaddr_in*)&test)->sin_addr),
832 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
833
834 /* check data */
835 pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
836 ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
837
838 /* cleanup */
839 read_zero_bytes ( mem->s );
840 trace ( "simple_client (%x) exiting\n", id );
841 client_stop ();
842 }
843
844 /*
845 * event_client: An event-driven client
846 */
847 static void WINAPI event_client ( client_params *par )
848 {
849 test_params *gen = par->general;
850 client_memory *mem;
851 int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
852 tmp, err, n;
853 HANDLE event;
854 WSANETWORKEVENTS wsa_events;
855 char *send_last, *recv_last, *send_p, *recv_p;
856 LONG mask = FD_READ | FD_WRITE | FD_CLOSE;
857
858 trace ( "event_client (%x): starting\n", id );
859 client_start ( par );
860 trace ( "event_client (%x): server ready\n", id );
861
862 mem = TlsGetValue ( tls );
863
864 /* Prepare event notification for connect, makes socket nonblocking */
865 event = WSACreateEvent ();
866 WSAEventSelect ( mem->s, event, FD_CONNECT );
867 tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
868 if ( tmp != 0 ) {
869 err = WSAGetLastError ();
870 ok ( err == WSAEWOULDBLOCK, "event_client (%x): connect error: %d\n", id, err );
871 tmp = WaitForSingleObject ( event, INFINITE );
872 ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
873 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
874 ok ( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
875 err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
876 ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
877 if ( err ) goto out;
878 }
879
880 trace ( "event_client (%x) connected\n", id );
881
882 WSAEventSelect ( mem->s, event, mask );
883
884 recv_p = mem->recv_buf;
885 recv_last = mem->recv_buf + n_expected;
886 send_p = mem->send_buf;
887 send_last = mem->send_buf + n_expected;
888
889 while ( TRUE )
890 {
891 err = WaitForSingleObject ( event, INFINITE );
892 ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
893
894 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
895 ok( err == 0, "event_client (%x): WSAEnumNetworkEvents error: %d\n", id, err );
896
897 if ( wsa_events.lNetworkEvents & FD_WRITE )
898 {
899 err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
900 ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
901
902 if ( err== 0 )
903 do
904 {
905 n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
906 if ( n < 0 )
907 {
908 err = WSAGetLastError ();
909 ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
910 }
911 else
912 send_p += n;
913 }
914 while ( n >= 0 && send_p < send_last );
915
916 if ( send_p == send_last )
917 {
918 trace ( "event_client (%x): all data sent - shutdown\n", id );
919 shutdown ( mem->s, SD_SEND );
920 mask &= ~FD_WRITE;
921 WSAEventSelect ( mem->s, event, mask );
922 }
923 }
924 if ( wsa_events.lNetworkEvents & FD_READ )
925 {
926 err = wsa_events.iErrorCode[ FD_READ_BIT ];
927 ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
928 if ( err != 0 ) break;
929
930 /* First read must succeed */
931 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
932 wsa_ok ( n, 0 <=, "event_client (%x): recv error: %d\n" );
933
934 while ( n >= 0 ) {
935 recv_p += n;
936 if ( recv_p == recv_last )
937 {
938 mask &= ~FD_READ;
939 trace ( "event_client (%x): all data received\n", id );
940 WSAEventSelect ( mem->s, event, mask );
941 break;
942 }
943 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
944 if ( n < 0 && ( err = WSAGetLastError()) != WSAEWOULDBLOCK )
945 ok ( 0, "event_client (%x): read error: %d\n", id, err );
946
947 }
948 }
949 if ( wsa_events.lNetworkEvents & FD_CLOSE )
950 {
951 trace ( "event_client (%x): close event\n", id );
952 err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
953 ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
954 break;
955 }
956 }
957
958 n = send_p - mem->send_buf;
959 ok ( send_p == send_last,
960 "simple_client (%x): sent less data than expected: %d of %d\n", id, n, n_expected );
961 n = recv_p - mem->recv_buf;
962 ok ( recv_p == recv_last,
963 "simple_client (%x): received less data than expected: %d of %d\n", id, n, n_expected );
964 n = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
965 ok ( n == -1, "event_client (%x): test pattern error: %d\n", id, n);
966
967 out:
968 WSACloseEvent ( event );
969 trace ( "event_client (%x) exiting\n", id );
970 client_stop ();
971 }
972
973 /* Tests for WSAStartup */
974 static void test_WithoutWSAStartup(void)
975 {
976 DWORD err;
977
978 WSASetLastError(0xdeadbeef);
979 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET, "WSASocketA should have failed\n");
980 err = WSAGetLastError();
981 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
982
983 WSASetLastError(0xdeadbeef);
984 ok(gethostbyname("localhost") == NULL, "gethostbyname() succeeded unexpectedly\n");
985 err = WSAGetLastError();
986 ok(err == WSANOTINITIALISED, "Expected 10093, received %d\n", err);
987 }
988
989 static void test_WithWSAStartup(void)
990 {
991 WSADATA data;
992 WORD version = MAKEWORD( 2, 2 );
993 INT res;
994 LPVOID ptr;
995
996 res = WSAStartup( version, &data );
997 ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
998
999 ptr = gethostbyname("localhost");
1000 ok(ptr != NULL, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
1001
1002 WSACleanup();
1003 }
1004
1005 /**************** Main program utility functions ***************/
1006
1007 static void Init (void)
1008 {
1009 WORD ver = MAKEWORD (2, 2);
1010 WSADATA data;
1011 HMODULE hws2_32 = GetModuleHandleA("ws2_32.dll");
1012
1013 pfreeaddrinfo = (void *)GetProcAddress(hws2_32, "freeaddrinfo");
1014 pgetaddrinfo = (void *)GetProcAddress(hws2_32, "getaddrinfo");
1015 pFreeAddrInfoW = (void *)GetProcAddress(hws2_32, "FreeAddrInfoW");
1016 pGetAddrInfoW = (void *)GetProcAddress(hws2_32, "GetAddrInfoW");
1017 pInetNtop = (void *)GetProcAddress(hws2_32, "inet_ntop");
1018
1019 ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
1020 tls = TlsAlloc();
1021 }
1022
1023 static void Exit (void)
1024 {
1025 INT ret, err;
1026 TlsFree ( tls );
1027 ret = WSACleanup();
1028 err = WSAGetLastError();
1029 ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
1030 ret = WSACleanup();
1031 err = WSAGetLastError();
1032 ok ( (ret == SOCKET_ERROR && err == WSANOTINITIALISED) ||
1033 broken(ret == 0), /* WinME */
1034 "WSACleanup returned %d GetLastError is %d\n", ret, err);
1035 }
1036
1037 static void StartServer (LPTHREAD_START_ROUTINE routine,
1038 test_params *general, server_params *par)
1039 {
1040 par->general = general;
1041 thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
1042 ok ( thread[0] != NULL, "Failed to create server thread\n" );
1043 }
1044
1045 static void StartClients (LPTHREAD_START_ROUTINE routine,
1046 test_params *general, client_params *par)
1047 {
1048 int i;
1049 par->general = general;
1050 for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
1051 {
1052 client_id = i - 1;
1053 thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
1054 ok ( thread[i] != NULL, "Failed to create client thread\n" );
1055 /* Make sure the client is up and running */
1056 WaitForSingleObject ( client_ready[client_id], INFINITE );
1057 };
1058 }
1059
1060 static void do_test( test_setup *test )
1061 {
1062 DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
1063 DWORD wait;
1064
1065 server_ready = CreateEventA ( NULL, TRUE, FALSE, NULL );
1066 for (i = 0; i <= n; i++)
1067 client_ready[i] = CreateEventA ( NULL, TRUE, FALSE, NULL );
1068
1069 StartServer ( test->srv, &test->general, &test->srv_params );
1070 StartClients ( test->clt, &test->general, &test->clt_params );
1071 WaitForSingleObject ( server_ready, INFINITE );
1072
1073 wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
1074 ok ( wait <= WAIT_OBJECT_0 + n ,
1075 "some threads have not completed: %x\n", wait );
1076
1077 if ( ! ( wait <= WAIT_OBJECT_0 + n ) )
1078 {
1079 for (i = 0; i <= n; i++)
1080 {
1081 if ( WaitForSingleObject ( thread[i], 0 ) != WAIT_OBJECT_0 )
1082 {
1083 trace ("terminating thread %08x\n", thread_id[i]);
1084 TerminateThread ( thread [i], 0 );
1085 }
1086 }
1087 }
1088 CloseHandle ( server_ready );
1089 for (i = 0; i <= n; i++)
1090 CloseHandle ( client_ready[i] );
1091 }
1092
1093 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
1094 /* optname = SO_LINGER */
1095 static const LINGER linger_testvals[] = {
1096 {0,0},
1097 {0,73},
1098 {1,0},
1099 {5,189}
1100 };
1101
1102 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
1103 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
1104 bug in the linux kernel (fixed in 2.6.8) */
1105 #define SOCKTIMEOUT2 997000 /* 997 seconds */
1106
1107 static void test_set_getsockopt(void)
1108 {
1109 SOCKET s;
1110 int i, err, lasterr;
1111 int timeout;
1112 LINGER lingval;
1113 int size;
1114 WSAPROTOCOL_INFOA infoA;
1115 WSAPROTOCOL_INFOW infoW;
1116 char providername[WSAPROTOCOL_LEN + 1];
1117 struct _prottest
1118 {
1119 int family, type, proto;
1120 } prottest[] = {
1121 {AF_INET, SOCK_STREAM, IPPROTO_TCP},
1122 {AF_INET, SOCK_DGRAM, IPPROTO_UDP},
1123 {AF_INET6, SOCK_STREAM, IPPROTO_TCP},
1124 {AF_INET6, SOCK_DGRAM, IPPROTO_UDP}
1125 };
1126
1127 s = socket(AF_INET, SOCK_STREAM, 0);
1128 ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1129 if( s == INVALID_SOCKET) return;
1130 /* SO_RCVTIMEO */
1131 timeout = SOCKTIMEOUT1;
1132 size = sizeof(timeout);
1133 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1134 if( !err)
1135 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1136 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1137 ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1138
1139 timeout = 0;
1140 size = sizeof(timeout);
1141 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
1142 if( !err)
1143 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
1144 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
1145 ok( timeout == 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
1146
1147 /* SO_SNDTIMEO */
1148 timeout = SOCKTIMEOUT2; /* 997 seconds. See remark above */
1149 size = sizeof(timeout);
1150 err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
1151 if( !err)
1152 err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
1153 ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1154 ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
1155 /* SO_LINGER */
1156 for( i = 0; i < sizeof(linger_testvals)/sizeof(LINGER);i++) {
1157 size = sizeof(lingval);
1158 lingval = linger_testvals[i];
1159 err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, size);
1160 if( !err)
1161 err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, &size);
1162 ok( !err, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1163 ok( !lingval.l_onoff == !linger_testvals[i].l_onoff &&
1164 (lingval.l_linger == linger_testvals[i].l_linger ||
1165 (!lingval.l_linger && !linger_testvals[i].l_onoff))
1166 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i,
1167 lingval.l_onoff, lingval.l_linger,
1168 linger_testvals[i].l_onoff, linger_testvals[i].l_linger);
1169 }
1170
1171 size = sizeof(lingval);
1172 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, size);
1173 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1174 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1175 err = setsockopt(s, SOL_SOCKET, SO_LINGER, NULL, 0);
1176 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1177 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1178
1179 size = sizeof(BOOL);
1180 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, size);
1181 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1182 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1183 err = setsockopt(s, SOL_SOCKET, SO_DONTLINGER, NULL, 0);
1184 ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
1185 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError());
1186
1187 /* Test for erroneously passing a value instead of a pointer as optval */
1188 size = sizeof(char);
1189 err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
1190 ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
1191 "instead of failing.\n");
1192 lasterr = WSAGetLastError();
1193 ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
1194 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1195 lasterr, WSAEFAULT);
1196
1197 /* SO_RCVTIMEO with invalid values for level */
1198 size = sizeof(timeout);
1199 timeout = SOCKTIMEOUT1;
1200 SetLastError(0xdeadbeef);
1201 err = setsockopt(s, 0xffffffff, SO_RCVTIMEO, (char *) &timeout, size);
1202 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1203 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1204 err, WSAGetLastError());
1205
1206 timeout = SOCKTIMEOUT1;
1207 SetLastError(0xdeadbeef);
1208 err = setsockopt(s, 0x00008000, SO_RCVTIMEO, (char *) &timeout, size);
1209 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1210 "got %d with %d (expected SOCKET_ERROR with WSAEINVAL)\n",
1211 err, WSAGetLastError());
1212
1213 /* Test SO_ERROR set/get */
1214 SetLastError(0xdeadbeef);
1215 i = 1234;
1216 err = setsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, size);
1217 todo_wine
1218 ok( !err && !WSAGetLastError(),
1219 "got %d with %d (expected 0 with 0)\n",
1220 err, WSAGetLastError());
1221
1222 SetLastError(0xdeadbeef);
1223 i = 4321;
1224 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1225 todo_wine
1226 ok( !err && !WSAGetLastError(),
1227 "got %d with %d (expected 0 with 0)\n",
1228 err, WSAGetLastError());
1229 todo_wine
1230 ok (i == 1234, "got %d (expected 1234)\n", i);
1231
1232 /* Test invalid optlen */
1233 SetLastError(0xdeadbeef);
1234 size = 1;
1235 err = getsockopt(s, SOL_SOCKET, SO_ERROR, (char *) &i, &size);
1236 todo_wine
1237 ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEFAULT),
1238 "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n",
1239 err, WSAGetLastError());
1240
1241 closesocket(s);
1242
1243 /* test SO_PROTOCOL_INFOA invalid parameters */
1244 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1245 "getsockopt should have failed\n");
1246 err = WSAGetLastError();
1247 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1248 size = sizeof(WSAPROTOCOL_INFOA);
1249 ok(getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1250 "getsockopt should have failed\n");
1251 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1252 err = WSAGetLastError();
1253 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
1254 s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1255 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, NULL),
1256 "getsockopt should have failed\n");
1257 err = WSAGetLastError();
1258 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1259 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, NULL),
1260 "getsockopt should have failed\n");
1261 err = WSAGetLastError();
1262 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1263 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, NULL, &size),
1264 "getsockopt should have failed\n");
1265 err = WSAGetLastError();
1266 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1267 size = sizeof(WSAPROTOCOL_INFOA) / 2;
1268 ok(getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size),
1269 "getsockopt should have failed\n");
1270 err = WSAGetLastError();
1271 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
1272 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1273 size = sizeof(WSAPROTOCOL_INFOA) * 2;
1274 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1275 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1276 ok(size == sizeof(WSAPROTOCOL_INFOA) * 2, "got size %d\n", size);
1277
1278 closesocket(s);
1279
1280 /* test SO_PROTOCOL_INFO structure returned for different protocols */
1281 for (i = 0; i < sizeof(prottest) / sizeof(prottest[0]); i++)
1282 {
1283 s = socket(prottest[i].family, prottest[i].type, prottest[i].proto);
1284 if (s == INVALID_SOCKET && prottest[i].family == AF_INET6) continue;
1285
1286 ok(s != INVALID_SOCKET, "Failed to create socket: %d\n",
1287 WSAGetLastError());
1288
1289 /* compare both A and W version */
1290 infoA.szProtocol[0] = 0;
1291 size = sizeof(WSAPROTOCOL_INFOA);
1292 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &infoA, &size);
1293 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1294 ok(size == sizeof(WSAPROTOCOL_INFOA), "got size %d\n", size);
1295
1296 infoW.szProtocol[0] = 0;
1297 size = sizeof(WSAPROTOCOL_INFOW);
1298 err = getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFOW, (char *) &infoW, &size);
1299 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1300 ok(size == sizeof(WSAPROTOCOL_INFOW), "got size %d\n", size);
1301
1302 trace("provider name '%s', family %d, type %d, proto %d\n",
1303 infoA.szProtocol, prottest[i].family, prottest[i].type, prottest[i].proto);
1304
1305 ok(infoA.szProtocol[0] || broken(!infoA.szProtocol[0]) /* NT4 */,
1306 "WSAPROTOCOL_INFOA was not filled\n");
1307 ok(infoW.szProtocol[0] || broken(!infoA.szProtocol[0]) /* NT4 */,
1308 "WSAPROTOCOL_INFOW was not filled\n");
1309
1310 WideCharToMultiByte(CP_ACP, 0, infoW.szProtocol, -1,
1311 providername, sizeof(providername), NULL, NULL);
1312 ok(!strcmp(infoA.szProtocol,providername),
1313 "different provider names '%s' != '%s'\n", infoA.szProtocol, providername);
1314
1315 ok(!memcmp(&infoA, &infoW, FIELD_OFFSET(WSAPROTOCOL_INFOA, szProtocol)),
1316 "SO_PROTOCOL_INFO[A/W] comparison failed\n");
1317
1318 /* Remove IF when WSAEnumProtocols support IPV6 data */
1319 if (prottest[i].family == AF_INET6)
1320 {
1321 todo_wine
1322 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1323 prottest[i].family, infoA.iAddressFamily);
1324 }
1325 else
1326 {
1327 ok(infoA.iAddressFamily == prottest[i].family, "socket family invalid, expected %d received %d\n",
1328 prottest[i].family, infoA.iAddressFamily);
1329 } ok(infoA.iSocketType == prottest[i].type, "socket type invalid, expected %d received %d\n",
1330 prottest[i].type, infoA.iSocketType);
1331 ok(infoA.iProtocol == prottest[i].proto, "socket protocol invalid, expected %d received %d\n",
1332 prottest[i].proto, infoA.iProtocol);
1333
1334 closesocket(s);
1335 }
1336 }
1337
1338 static void test_so_reuseaddr(void)
1339 {
1340 struct sockaddr_in saddr;
1341 SOCKET s1,s2;
1342 unsigned int rc,reuse;
1343 int size;
1344
1345 saddr.sin_family = AF_INET;
1346 saddr.sin_port = htons(9375);
1347 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1348
1349 s1=socket(AF_INET, SOCK_STREAM, 0);
1350 ok(s1!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1351 rc = bind(s1, (struct sockaddr*)&saddr, sizeof(saddr));
1352 ok(rc!=SOCKET_ERROR, "bind(s1) failed error: %d\n", WSAGetLastError());
1353
1354 s2=socket(AF_INET, SOCK_STREAM, 0);
1355 ok(s2!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1356
1357 reuse=0x1234;
1358 size=sizeof(reuse);
1359 rc=getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size );
1360 ok(rc==0 && reuse==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc,reuse);
1361
1362 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1363 ok(rc==SOCKET_ERROR, "bind() succeeded\n");
1364
1365 reuse = 1;
1366 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
1367 ok(rc==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1368
1369 /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1370 * a port immediately after closing another socket on that port, so
1371 * basically following the BSD socket semantics here. */
1372 closesocket(s1);
1373 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1374 ok(rc==0, "bind() failed error: %d\n", WSAGetLastError());
1375
1376 closesocket(s2);
1377 }
1378
1379 #define IP_PKTINFO_LEN (sizeof(WSACMSGHDR) + WSA_CMSG_ALIGN(sizeof(struct in_pktinfo)))
1380
1381 static void test_ip_pktinfo(void)
1382 {
1383 ULONG addresses[2] = {inet_addr("127.0.0.1"), htonl(INADDR_ANY)};
1384 char recvbuf[10], pktbuf[512], msg[] = "HELLO";
1385 struct sockaddr_in s1addr, s2addr, s3addr;
1386 GUID WSARecvMsg_GUID = WSAID_WSARECVMSG;
1387 LPFN_WSARECVMSG pWSARecvMsg = NULL;
1388 unsigned int rc, yes = 1;
1389 BOOL foundhdr;
1390 DWORD dwBytes, dwSize, dwFlags;
1391 socklen_t addrlen;
1392 WSACMSGHDR *cmsg;
1393 WSAOVERLAPPED ov;
1394 WSABUF iovec[1];
1395 SOCKET s1, s2;
1396 WSAMSG hdr;
1397 int i, err;
1398
1399 memset(&ov, 0, sizeof(ov));
1400 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1401 if (ov.hEvent == INVALID_HANDLE_VALUE)
1402 {
1403 skip("Could not create event object, some tests will be skipped. errno = %d\n", GetLastError());
1404 return;
1405 }
1406
1407 memset(&hdr, 0x00, sizeof(hdr));
1408 s1addr.sin_family = AF_INET;
1409 s1addr.sin_port = htons(0);
1410 /* Note: s1addr.sin_addr is set below */
1411 iovec[0].buf = recvbuf;
1412 iovec[0].len = sizeof(recvbuf);
1413 hdr.name = (struct sockaddr*)&s3addr;
1414 hdr.namelen = sizeof(s3addr);
1415 hdr.lpBuffers = &iovec[0];
1416 hdr.dwBufferCount = 1;
1417 hdr.Control.buf = pktbuf;
1418 /* Note: hdr.Control.len is set below */
1419 hdr.dwFlags = 0;
1420
1421 for (i=0;i<sizeof(addresses)/sizeof(UINT32);i++)
1422 {
1423 s1addr.sin_addr.s_addr = addresses[i];
1424
1425 /* Build "server" side socket */
1426 s1=socket(AF_INET, SOCK_DGRAM, 0);
1427 if (s1 == INVALID_SOCKET)
1428 {
1429 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1430 goto cleanup;
1431 }
1432
1433 /* Obtain the WSARecvMsg function */
1434 WSAIoctl(s1, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
1435 &pWSARecvMsg, sizeof(pWSARecvMsg), &dwBytes, NULL, NULL);
1436 if (!pWSARecvMsg)
1437 {
1438 win_skip("WSARecvMsg is unsupported, some tests will be skipped.\n");
1439 closesocket(s1);
1440 goto cleanup;
1441 }
1442
1443 /* Setup the server side socket */
1444 rc=bind(s1, (struct sockaddr*)&s1addr, sizeof(s1addr));
1445 ok(rc != SOCKET_ERROR, "bind() failed error: %d\n", WSAGetLastError());
1446 rc=setsockopt(s1, IPPROTO_IP, IP_PKTINFO, (const char*)&yes, sizeof(yes));
1447 ok(rc == 0, "failed to set IPPROTO_IP flag IP_PKTINFO!\n");
1448
1449 /* Build "client" side socket */
1450 addrlen = sizeof(s2addr);
1451 if (getsockname(s1, (struct sockaddr *) &s2addr, &addrlen) != 0)
1452 {
1453 skip("Failed to call getsockname, some tests skipped: %d\n", WSAGetLastError());
1454 closesocket(s1);
1455 goto cleanup;
1456 }
1457 s2addr.sin_addr.s_addr = addresses[0]; /* Always target the local adapter address */
1458 s2=socket(AF_INET, SOCK_DGRAM, 0);
1459 if (s2 == INVALID_SOCKET)
1460 {
1461 skip("socket() failed error, some tests skipped: %d\n", WSAGetLastError());
1462 closesocket(s1);
1463 goto cleanup;
1464 }
1465
1466 /* Test an empty message header */
1467 rc=pWSARecvMsg(s1, NULL, NULL, NULL, NULL);
1468 err=WSAGetLastError();
1469 ok(rc == SOCKET_ERROR && err == WSAEFAULT, "WSARecvMsg() failed error: %d (ret = %d)\n", err, rc);
1470
1471 /*
1472 * Send a packet from the client to the server and test for specifying
1473 * a short control header.
1474 */
1475 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1476 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1477 hdr.Control.len = 1;
1478 rc=pWSARecvMsg(s1, &hdr, &dwSize, NULL, NULL);
1479 err=WSAGetLastError();
1480 ok(rc == SOCKET_ERROR && err == WSAEMSGSIZE && (hdr.dwFlags & MSG_CTRUNC),
1481 "WSARecvMsg() failed error: %d (ret: %d, flags: %d)\n", err, rc, hdr.dwFlags);
1482 hdr.dwFlags = 0; /* Reset flags */
1483
1484 /* Perform another short control header test, this time with an overlapped receive */
1485 hdr.Control.len = 1;
1486 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
1487 err=WSAGetLastError();
1488 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
1489 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1490 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1491 if (WaitForSingleObject(ov.hEvent, 100) != WAIT_OBJECT_0)
1492 {
1493 skip("Server side did not receive packet, some tests skipped.\n");
1494 closesocket(s2);
1495 closesocket(s1);
1496 continue;
1497 }
1498 dwFlags = 0;
1499 WSAGetOverlappedResult(s1, &ov, NULL, FALSE, &dwFlags);
1500 ok(dwFlags == 0,
1501 "WSAGetOverlappedResult() returned unexpected flags %d!\n", dwFlags);
1502 ok(hdr.dwFlags == MSG_CTRUNC,
1503 "WSARecvMsg() overlapped operation set unexpected flags %d.\n", hdr.dwFlags);
1504 hdr.dwFlags = 0; /* Reset flags */
1505
1506 /*
1507 * Setup an overlapped receive, send a packet, then wait for the packet to be retrieved
1508 * on the server end and check that the returned packet matches what was sent.
1509 */
1510 hdr.Control.len = sizeof(pktbuf);
1511 rc=pWSARecvMsg(s1, &hdr, NULL, &ov, NULL);
1512 err=WSAGetLastError();
1513 ok(rc != 0 && err == WSA_IO_PENDING, "WSARecvMsg() failed error: %d\n", err);
1514 ok(hdr.Control.len == sizeof(pktbuf),
1515 "WSARecvMsg() control length mismatch (%d != sizeof pktbuf).\n", hdr.Control.len);
1516 rc=sendto(s2, msg, sizeof(msg), 0, (struct sockaddr*)&s2addr, sizeof(s2addr));
1517 ok(rc == sizeof(msg), "sendto() failed error: %d\n", WSAGetLastError());
1518 if (WaitForSingleObject(ov.hEvent, 100) != WAIT_OBJECT_0)
1519 {
1520 skip("Server side did not receive packet, some tests skipped.\n");
1521 closesocket(s2);
1522 closesocket(s1);
1523 continue;
1524 }
1525 dwSize = 0;
1526 WSAGetOverlappedResult(s1, &ov, &dwSize, FALSE, NULL);
1527 ok(dwSize == sizeof(msg),
1528 "WSARecvMsg() buffer length does not match transmitted data!\n");
1529 ok(strncmp(iovec[0].buf, msg, sizeof(msg)) == 0,
1530 "WSARecvMsg() buffer does not match transmitted data!\n");
1531 ok(hdr.Control.len == IP_PKTINFO_LEN,
1532 "WSARecvMsg() control length mismatch (%d).\n", hdr.Control.len);
1533
1534 /* Test for the expected IP_PKTINFO return information. */
1535 foundhdr = FALSE;
1536 for (cmsg = WSA_CMSG_FIRSTHDR(&hdr); cmsg != NULL; cmsg = WSA_CMSG_NXTHDR(&hdr, cmsg))
1537 {
1538 if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO)
1539 {
1540 struct in_pktinfo *pi = (struct in_pktinfo *)WSA_CMSG_DATA(cmsg);
1541
1542 ok(pi->ipi_addr.s_addr == s2addr.sin_addr.s_addr, "destination ip mismatch!\n");
1543 foundhdr = TRUE;
1544 }
1545 }
1546 ok(foundhdr, "IP_PKTINFO header information was not returned!\n");
1547
1548 closesocket(s2);
1549 closesocket(s1);
1550 }
1551
1552 cleanup:
1553 CloseHandle(ov.hEvent);
1554 }
1555
1556 /************* Array containing the tests to run **********/
1557
1558 #define STD_STREAM_SOCKET \
1559 SOCK_STREAM, \
1560 0, \
1561 SERVERIP, \
1562 SERVERPORT
1563
1564 static test_setup tests [] =
1565 {
1566 /* Test 0: synchronous client and server */
1567 {
1568 {
1569 STD_STREAM_SOCKET,
1570 2048,
1571 16,
1572 2
1573 },
1574 simple_server,
1575 {
1576 NULL,
1577 0,
1578 64
1579 },
1580 simple_client,
1581 {
1582 NULL,
1583 0,
1584 128
1585 }
1586 },
1587 /* Test 1: event-driven client, synchronous server */
1588 {
1589 {
1590 STD_STREAM_SOCKET,
1591 2048,
1592 16,
1593 2
1594 },
1595 simple_server,
1596 {
1597 NULL,
1598 0,
1599 64
1600 },
1601 event_client,
1602 {
1603 NULL,
1604 WSA_FLAG_OVERLAPPED,
1605 128
1606 }
1607 },
1608 /* Test 2: synchronous client, non-blocking server via select() */
1609 {
1610 {
1611 STD_STREAM_SOCKET,
1612 2048,
1613 16,
1614 2
1615 },
1616 select_server,
1617 {
1618 NULL,
1619 0,
1620 64
1621 },
1622 simple_client,
1623 {
1624 NULL,
1625 0,
1626 128
1627 }
1628 },
1629 /* Test 3: OOB client, OOB server */
1630 {
1631 {
1632 STD_STREAM_SOCKET,
1633 128,
1634 16,
1635 1
1636 },
1637 oob_server,
1638 {
1639 NULL,
1640 0,
1641 128
1642 },
1643 oob_client,
1644 {
1645 NULL,
1646 0,
1647 128
1648 }
1649 },
1650 /* Test 4: synchronous mixed client and server */
1651 {
1652 {
1653 STD_STREAM_SOCKET,
1654 2048,
1655 16,
1656 2
1657 },
1658 simple_server,
1659 {
1660 NULL,
1661 0,
1662 64
1663 },
1664 simple_mixed_client,
1665 {
1666 NULL,
1667 0,
1668 128
1669 }
1670 }
1671 };
1672
1673 static void test_UDP(void)
1674 {
1675 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
1676 possible that this test fails due to dropped packets. */
1677
1678 /* peer 0 receives data from all other peers */
1679 struct sock_info peer[NUM_UDP_PEERS];
1680 char buf[16];
1681 int ss, i, n_recv, n_sent;
1682
1683 memset (buf,0,sizeof(buf));
1684 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
1685 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
1686
1687 peer[i].addr.sin_family = AF_INET;
1688 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
1689
1690 if ( i == 0 ) {
1691 peer[i].addr.sin_port = htons ( SERVERPORT );
1692 } else {
1693 peer[i].addr.sin_port = htons ( 0 );
1694 }
1695
1696 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
1697
1698 /* test getsockname() to get peer's port */
1699 ss = sizeof ( peer[i].addr );
1700 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
1701 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
1702 }
1703
1704 /* test getsockname() */
1705 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
1706
1707 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
1708 /* send client's ip */
1709 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
1710 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
1711 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
1712 }
1713
1714 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
1715 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
1716 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
1717 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
1718 }
1719 }
1720
1721 static DWORD WINAPI do_getservbyname( void *param )
1722 {
1723 struct {
1724 const char *name;
1725 const char *proto;
1726 int port;
1727 } serv[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
1728
1729 HANDLE *starttest = param;
1730 int i, j;
1731 struct servent *pserv[2];
1732
1733 ok ( WaitForSingleObject ( *starttest, TEST_TIMEOUT * 1000 ) != WAIT_TIMEOUT, "test_getservbyname: timeout waiting for start signal\n");
1734
1735 /* ensure that necessary buffer resizes are completed */
1736 for ( j = 0; j < 2; j++) {
1737 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1738 }
1739
1740 for ( i = 0; i < NUM_QUERIES / 2; i++ ) {
1741 for ( j = 0; j < 2; j++ ) {
1742 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1743 ok ( pserv[j] != NULL, "getservbyname could not retrieve information for %s: %d\n", serv[j].name, WSAGetLastError() );
1744 if ( !pserv[j] ) continue;
1745 ok ( pserv[j]->s_port == htons(serv[j].port), "getservbyname returned the wrong port for %s: %d\n", serv[j].name, ntohs(pserv[j]->s_port) );
1746 ok ( !strcmp ( pserv[j]->s_proto, serv[j].proto ), "getservbyname returned the wrong protocol for %s: %s\n", serv[j].name, pserv[j]->s_proto );
1747 ok ( !strcmp ( pserv[j]->s_name, serv[j].name ), "getservbyname returned the wrong name for %s: %s\n", serv[j].name, pserv[j]->s_name );
1748 }
1749
1750 ok ( pserv[0] == pserv[1], "getservbyname: winsock resized servent buffer when not necessary\n" );
1751 }
1752
1753 return 0;
1754 }
1755
1756 static void test_getservbyname(void)
1757 {
1758 int i;
1759 HANDLE starttest, thread[NUM_THREADS];
1760 DWORD thread_id[NUM_THREADS];
1761
1762 starttest = CreateEventA ( NULL, 1, 0, "test_getservbyname_starttest" );
1763
1764 /* create threads */
1765 for ( i = 0; i < NUM_THREADS; i++ ) {
1766 thread[i] = CreateThread ( NULL, 0, do_getservbyname, &starttest, 0, &thread_id[i] );
1767 }
1768
1769 /* signal threads to start */
1770 SetEvent ( starttest );
1771
1772 for ( i = 0; i < NUM_THREADS; i++) {
1773 WaitForSingleObject ( thread[i], TEST_TIMEOUT * 1000 );
1774 }
1775 }
1776
1777 static void test_WSASocket(void)
1778 {
1779 SOCKET sock = INVALID_SOCKET;
1780 WSAPROTOCOL_INFOA *pi;
1781 int wsaproviders[] = {IPPROTO_TCP, IPPROTO_IP};
1782 int autoprotocols[] = {IPPROTO_TCP, IPPROTO_UDP};
1783 int items, err, size, socktype, i, j;
1784 UINT pi_size;
1785
1786 SetLastError(0xdeadbeef);
1787 ok(WSASocketA(0, 0, 0, NULL, 0, 0) == INVALID_SOCKET,
1788 "WSASocketA should have failed\n");
1789 err = WSAGetLastError();
1790 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
1791
1792 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
1793 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
1794 closesocket(sock);
1795
1796 sock = WSASocketA(AF_INET, SOCK_STREAM, 0, NULL, 0, 0);
1797 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
1798 closesocket(sock);
1799
1800 SetLastError(0xdeadbeef);
1801 ok(WSASocketA(0, SOCK_STREAM, -1, NULL, 0, 0) == INVALID_SOCKET,
1802 "WSASocketA should have failed\n");
1803 err = WSAGetLastError();
1804 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
1805
1806 SetLastError(0xdeadbeef);
1807 ok(WSASocketA(0, -1, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
1808 "WSASocketA should have failed\n");
1809 err = WSAGetLastError();
1810 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
1811
1812 SetLastError(0xdeadbeef);
1813 ok(WSASocketA(0, -1, 0, NULL, 0, 0) == INVALID_SOCKET,
1814 "WSASocketA should have failed\n");
1815 err = WSAGetLastError();
1816 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
1817
1818 SetLastError(0xdeadbeef);
1819 ok(WSASocketA(AF_INET, -1, 0, NULL, 0, 0) == INVALID_SOCKET,
1820 "WSASocketA should have failed\n");
1821 err = WSAGetLastError();
1822 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
1823
1824 SetLastError(0xdeadbeef);
1825 ok(WSASocketA(AF_INET, 0, -1, NULL, 0, 0) == INVALID_SOCKET,
1826 "WSASocketA should have failed\n");
1827 err = WSAGetLastError();
1828 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
1829
1830 SetLastError(0xdeadbeef);
1831 ok(WSASocketA(0, -1, -1, NULL, 0, 0) == INVALID_SOCKET,
1832 "WSASocketA should have failed\n");
1833 err = WSAGetLastError();
1834 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
1835
1836 SetLastError(0xdeadbeef);
1837 ok(WSASocketA(-1, SOCK_STREAM, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
1838 "WSASocketA should have failed\n");
1839 err = WSAGetLastError();
1840 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
1841
1842 sock = WSASocketA(AF_INET, 0, IPPROTO_TCP, NULL, 0, 0);
1843 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
1844 closesocket(sock);
1845
1846 SetLastError(0xdeadbeef);
1847 ok(WSASocketA(0, SOCK_STREAM, 0, NULL, 0, 0) == INVALID_SOCKET,
1848 "WSASocketA should have failed\n");
1849 err = WSAGetLastError();
1850 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
1851
1852 SetLastError(0xdeadbeef);
1853 ok(WSASocketA(0, 0, 0xdead, NULL, 0, 0) == INVALID_SOCKET,
1854 "WSASocketA should have failed\n");
1855 err = WSAGetLastError();
1856 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
1857
1858 SetLastError(0xdeadbeef);
1859 ok(WSASocketA(AF_INET, 0xdead, 0, NULL, 0, 0) == INVALID_SOCKET,
1860 "WSASocketA should have failed\n");
1861 err = WSAGetLastError();
1862 ok(err == WSAESOCKTNOSUPPORT, "Expected 10044, received %d\n", err);
1863
1864 SetLastError(0xdeadbeef);
1865 ok(WSASocketA(0, 0xdead, 0, NULL, 0, 0) == INVALID_SOCKET,
1866 "WSASocketA should have failed\n");
1867 err = WSAGetLastError();
1868 ok(err == WSAEINVAL, "Expected 10022, received %d\n", err);
1869
1870 sock = WSASocketA(0, 0, IPPROTO_TCP, NULL, 0, 0);
1871 ok(sock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
1872 closesocket(sock);
1873
1874 /* SOCK_STREAM does not support IPPROTO_UDP */
1875 SetLastError(0xdeadbeef);
1876 ok(WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_UDP, NULL, 0, 0) == INVALID_SOCKET,
1877 "WSASocketA should have failed\n");
1878 err = WSAGetLastError();
1879 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
1880
1881 /* SOCK_DGRAM does not support IPPROTO_TCP */
1882 SetLastError(0xdeadbeef);
1883 ok(WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_TCP, NULL, 0, 0) == INVALID_SOCKET,
1884 "WSASocketA should have failed\n");
1885 err = WSAGetLastError();
1886 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
1887
1888 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
1889 * to avoid a crash on win98.
1890 */
1891 pi_size = 0;
1892 items = WSAEnumProtocolsA(wsaproviders, NULL, &pi_size);
1893 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
1894 items);
1895 err = WSAGetLastError();
1896 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
1897 err, WSAENOBUFS);
1898
1899 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
1900 ok(pi != NULL, "Failed to allocate memory\n");
1901 if (pi == NULL) {
1902 skip("Can't continue without memory.\n");
1903 return;
1904 }
1905
1906 items = WSAEnumProtocolsA(wsaproviders, pi, &pi_size);
1907 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
1908 WSAGetLastError());
1909
1910 if (items == 0) {
1911 skip("No protocols enumerated.\n");
1912 HeapFree(GetProcessHeap(), 0, pi);
1913 return;
1914 }
1915
1916 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
1917 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
1918 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
1919 WSAGetLastError());
1920 closesocket(sock);
1921
1922 /* find what parameters are used first: plain parameters or protocol info struct */
1923 pi[0].iProtocol = -1;
1924 pi[0].iSocketType = -1;
1925 pi[0].iAddressFamily = -1;
1926 ok(WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0) == INVALID_SOCKET,
1927 "WSASocketA should have failed\n");
1928 err = WSAGetLastError();
1929 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
1930
1931 pi[0].iProtocol = 0;
1932 pi[0].iSocketType = 0;
1933 pi[0].iAddressFamily = 0;
1934 sock = WSASocketA(0, 0, IPPROTO_UDP, &pi[0], 0, 0);
1935 if(sock != INVALID_SOCKET)
1936 {
1937 win_skip("must work only in OS <= 2003\n");
1938 closesocket(sock);
1939 }
1940 else
1941 {
1942 err = WSAGetLastError();
1943 ok(err == WSAEAFNOSUPPORT, "Expected 10047, received %d\n", err);
1944 }
1945
1946 pi[0].iProtocol = IPPROTO_UDP;
1947 pi[0].iSocketType = SOCK_DGRAM;
1948 pi[0].iAddressFamily = AF_INET;
1949 sock = WSASocketA(0, 0, 0, &pi[0], 0, 0);
1950 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
1951 WSAGetLastError());
1952 size = sizeof(socktype);
1953 socktype = 0xdead;
1954 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
1955 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1956 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
1957 SOCK_DGRAM, socktype);
1958 closesocket(sock);
1959
1960 sock = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, &pi[0], 0, 0);
1961 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
1962 WSAGetLastError());
1963 size = sizeof(socktype);
1964 socktype = 0xdead;
1965 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
1966 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
1967 ok(socktype == SOCK_STREAM, "Wrong socket type, expected %d received %d\n",
1968 SOCK_STREAM, socktype);
1969 closesocket(sock);
1970
1971 HeapFree(GetProcessHeap(), 0, pi);
1972
1973 pi_size = 0;
1974 items = WSAEnumProtocolsA(NULL, NULL, &pi_size);
1975 ok(items == SOCKET_ERROR, "WSAEnumProtocolsA(NULL, NULL, 0) returned %d\n",
1976 items);
1977 err = WSAGetLastError();
1978 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
1979 err, WSAENOBUFS);
1980
1981 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
1982 ok(pi != NULL, "Failed to allocate memory\n");
1983 if (pi == NULL) {
1984 skip("Can't continue without memory.\n");
1985 return;
1986 }
1987
1988 items = WSAEnumProtocolsA(NULL, pi, &pi_size);
1989 ok(items != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
1990 WSAGetLastError());
1991
1992 /* when no protocol and socket type are specified the first entry
1993 * from WSAEnumProtocols that has the flag PFL_MATCHES_PROTOCOL_ZERO
1994 * is returned */
1995 sock = WSASocketA(AF_INET, 0, 0, NULL, 0, 0);
1996 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
1997 WSAGetLastError());
1998
1999 size = sizeof(socktype);
2000 socktype = 0xdead;
2001 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2002 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2003 for(i = 0; i < items; i++)
2004 {
2005 if(pi[i].dwProviderFlags & PFL_MATCHES_PROTOCOL_ZERO)
2006 {
2007 ok(socktype == pi[i].iSocketType, "Wrong socket type, expected %d received %d\n",
2008 pi[i].iSocketType, socktype);
2009 break;
2010 }
2011 }
2012 ok(i != items, "Creating a socket without protocol and socket type didn't work\n");
2013 closesocket(sock);
2014
2015 /* when no socket type is specified the first entry from WSAEnumProtocols
2016 * that matches the protocol is returned */
2017 for (i = 0; i < sizeof(autoprotocols) / sizeof(autoprotocols[0]); i++)
2018 {
2019 sock = WSASocketA(0, 0, autoprotocols[i], NULL, 0, 0);
2020 ok(sock != INVALID_SOCKET, "Failed to create socket for protocol %d, received %d\n",
2021 autoprotocols[i], WSAGetLastError());
2022
2023 size = sizeof(socktype);
2024 socktype = 0xdead;
2025 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2026 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2027
2028 for (err = 1, j = 0; j < items; j++)
2029 {
2030 if (pi[j].iProtocol == autoprotocols[i])
2031 {
2032 if (socktype == pi[j].iSocketType)
2033 err = 0;
2034 else
2035 ok(0, "Wrong socket type, expected %d received %d\n",
2036 pi[j].iSocketType, socktype);
2037 break;
2038 }
2039 }
2040 ok(!err, "Protocol %d not found in WSAEnumProtocols\n", autoprotocols[i]);
2041
2042 closesocket(sock);
2043 }
2044
2045 HeapFree(GetProcessHeap(), 0, pi);
2046
2047 SetLastError(0xdeadbeef);
2048 /* starting on vista the socket function returns error during the socket
2049 creation and no longer in the socket operations (sendto, readfrom) */
2050 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
2051 if (sock == INVALID_SOCKET)
2052 {
2053 err = WSAGetLastError();
2054 ok(err == WSAEACCES, "Expected 10013, received %d\n", err);
2055 skip("SOCK_RAW is not supported\n");
2056 }
2057 else
2058 {
2059 trace("SOCK_RAW is supported\n");
2060
2061 size = sizeof(socktype);
2062 socktype = 0xdead;
2063 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2064 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2065 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2066 SOCK_RAW, socktype);
2067 closesocket(sock);
2068
2069 todo_wine {
2070 sock = WSASocketA(0, 0, IPPROTO_RAW, NULL, 0, 0);
2071 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2072 WSAGetLastError());
2073 size = sizeof(socktype);
2074 socktype = 0xdead;
2075 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2076 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2077 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2078 SOCK_RAW, socktype);
2079 closesocket(sock);
2080 }
2081
2082 sock = WSASocketA(AF_INET, SOCK_RAW, IPPROTO_TCP, NULL, 0, 0);
2083 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2084 WSAGetLastError());
2085 size = sizeof(socktype);
2086 socktype = 0xdead;
2087 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2088 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2089 ok(socktype == SOCK_RAW, "Wrong socket type, expected %d received %d\n",
2090 SOCK_RAW, socktype);
2091 closesocket(sock);
2092 }
2093
2094 /* IPX socket tests */
2095
2096 SetLastError(0xdeadbeef);
2097 sock = WSASocketA(AF_IPX, SOCK_DGRAM, NSPROTO_IPX, NULL, 0, 0);
2098 if (sock == INVALID_SOCKET)
2099 {
2100 err = WSAGetLastError();
2101 ok(err == WSAEAFNOSUPPORT || broken(err == WSAEPROTONOSUPPORT), "Expected 10047, received %d\n", err);
2102 skip("IPX is not supported\n");
2103 }
2104 else
2105 {
2106 WSAPROTOCOL_INFOA info;
2107 closesocket(sock);
2108
2109 trace("IPX is supported\n");
2110
2111 sock = WSASocketA(0, 0, NSPROTO_IPX, NULL, 0, 0);
2112 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2113 WSAGetLastError());
2114
2115 size = sizeof(socktype);
2116 socktype = 0xdead;
2117 err = getsockopt(sock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2118 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2119 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2120 SOCK_DGRAM, socktype);
2121
2122 /* check socket family, type and protocol */
2123 size = sizeof(WSAPROTOCOL_INFOA);
2124 err = getsockopt(sock, SOL_SOCKET, SO_PROTOCOL_INFOA, (char *) &info, &size);
2125 ok(!err,"getsockopt failed with %d\n", WSAGetLastError());
2126 ok(info.iProtocol == NSPROTO_IPX, "expected protocol %d, received %d\n",
2127 NSPROTO_IPX, info.iProtocol);
2128 ok(info.iAddressFamily == AF_IPX, "expected family %d, received %d\n",
2129 AF_IPX, info.iProtocol);
2130 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2131 SOCK_DGRAM, info.iSocketType);
2132 closesocket(sock);
2133
2134 /* SOCK_STREAM does not support NSPROTO_IPX */
2135 SetLastError(0xdeadbeef);
2136 ok(WSASocketA(AF_IPX, SOCK_STREAM, NSPROTO_IPX, NULL, 0, 0) == INVALID_SOCKET,
2137 "WSASocketA should have failed\n");
2138 err = WSAGetLastError();
2139 ok(err == WSAEPROTONOSUPPORT, "Expected 10043, received %d\n", err);
2140
2141 /* test extended IPX support - that is adding any number between 0 and 255
2142 * to the IPX protocol value will make it be used as IPX packet type */
2143 for(i = 0;i <= 255;i += 17)
2144 {
2145 SetLastError(0xdeadbeef);
2146 sock = WSASocketA(0, 0, NSPROTO_IPX + i, NULL, 0, 0);
2147 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
2148 WSAGetLastError());
2149
2150 size = sizeof(int);
2151 socktype = -1;
2152 err = getsockopt(sock, NSPROTO_IPX, IPX_PTYPE, (char *) &socktype, &size);
2153 ok(!err, "getsockopt failed with %d\n", WSAGetLastError());
2154 ok(socktype == i, "Wrong IPX packet type, expected %d received %d\n",
2155 i, socktype);
2156
2157 closesocket(sock);
2158 }
2159 }
2160 }
2161
2162 static void test_WSADuplicateSocket(void)
2163 {
2164 SOCKET source, dupsock;
2165 WSAPROTOCOL_INFOA info;
2166 DWORD err;
2167 struct sockaddr_in addr;
2168 int socktype, size, addrsize, ret;
2169 char teststr[] = "TEST", buffer[16];
2170
2171 source = WSASocketA(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
2172 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2173
2174 /* test invalid parameters */
2175 SetLastError(0xdeadbeef);
2176 ok(WSADuplicateSocketA(0, 0, NULL), "WSADuplicateSocketA should have failed\n");
2177 err = WSAGetLastError();
2178 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2179
2180 SetLastError(0xdeadbeef);
2181 ok(WSADuplicateSocketA(source, 0, NULL),
2182 "WSADuplicateSocketA should have failed\n");
2183 err = WSAGetLastError();
2184 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2185
2186 SetLastError(0xdeadbeef);
2187 ok(WSADuplicateSocketA(source, ~0, &info),
2188 "WSADuplicateSocketA should have failed\n");
2189 err = WSAGetLastError();
2190 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2191
2192 SetLastError(0xdeadbeef);
2193 ok(WSADuplicateSocketA(0, GetCurrentProcessId(), &info),
2194 "WSADuplicateSocketA should have failed\n");
2195 err = WSAGetLastError();
2196 ok(err == WSAENOTSOCK, "expected 10038, received %d\n", err);
2197
2198 SetLastError(0xdeadbeef);
2199 ok(WSADuplicateSocketA(source, GetCurrentProcessId(), NULL),
2200 "WSADuplicateSocketA should have failed\n");
2201 err = WSAGetLastError();
2202 ok(err == WSAEFAULT, "expected 10014, received %d\n", err);
2203
2204 /* test returned structure */
2205 memset(&info, 0, sizeof(info));
2206 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2207 "WSADuplicateSocketA should have worked\n");
2208
2209 ok(info.iProtocol == IPPROTO_TCP, "expected protocol %d, received %d\n",
2210 IPPROTO_TCP, info.iProtocol);
2211 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2212 AF_INET, info.iProtocol);
2213 ok(info.iSocketType == SOCK_STREAM, "expected type %d, received %d\n",
2214 SOCK_STREAM, info.iSocketType);
2215
2216 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2217 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2218
2219 closesocket(dupsock);
2220 closesocket(source);
2221
2222 /* create a socket, bind it, duplicate it then send data on source and
2223 * receve in the duplicated socket */
2224 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2225 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2226
2227 memset(&info, 0, sizeof(info));
2228 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2229 "WSADuplicateSocketA should have worked\n");
2230
2231 ok(info.iProtocol == IPPROTO_UDP, "expected protocol %d, received %d\n",
2232 IPPROTO_UDP, info.iProtocol);
2233 ok(info.iAddressFamily == AF_INET, "expected family %d, received %d\n",
2234 AF_INET, info.iProtocol);
2235 ok(info.iSocketType == SOCK_DGRAM, "expected type %d, received %d\n",
2236 SOCK_DGRAM, info.iSocketType);
2237
2238 memset(&addr, 0, sizeof(addr));
2239 addr.sin_family = AF_INET;
2240 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2241 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2242 "bind should have worked\n");
2243
2244 /* read address to find out the port number to be used in sendto */
2245 memset(&addr, 0, sizeof(addr));
2246 addrsize = sizeof(addr);
2247 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2248 "getsockname should have worked\n");
2249 ok(addr.sin_port, "socket port should be != 0\n");
2250
2251 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2252 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2253
2254 size = sizeof(int);
2255 ret = getsockopt(dupsock, SOL_SOCKET, SO_TYPE, (char *) &socktype, &size);
2256 ok(!ret, "getsockopt failed with %d\n", WSAGetLastError());
2257 ok(socktype == SOCK_DGRAM, "Wrong socket type, expected %d received %d\n",
2258 SOCK_DGRAM, socktype);
2259
2260 set_blocking(source, TRUE);
2261
2262 /* send data on source socket */
2263 addrsize = sizeof(addr);
2264 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2265 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2266
2267 /* receive on duplicated socket */
2268 addrsize = sizeof(addr);
2269 memset(buffer, 0, sizeof(buffer));
2270 size = recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize);
2271 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2272 buffer[sizeof(teststr) - 1] = 0;
2273 ok(!strcmp(buffer, teststr), "expected '%s', received '%s'\n", teststr, buffer);
2274
2275 closesocket(dupsock);
2276 closesocket(source);
2277
2278 /* show that the source socket need to be bound before the duplicated
2279 * socket is created */
2280 source = WSASocketA(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, 0);
2281 ok(source != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2282
2283 memset(&info, 0, sizeof(info));
2284 ok(!WSADuplicateSocketA(source, GetCurrentProcessId(), &info),
2285 "WSADuplicateSocketA should have worked\n");
2286
2287 dupsock = WSASocketA(0, 0, 0, &info, 0, 0);
2288 ok(dupsock != INVALID_SOCKET, "WSASocketA should have succeeded\n");
2289
2290 memset(&addr, 0, sizeof(addr));
2291 addr.sin_family = AF_INET;
2292 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2293 ok(!bind(source, (struct sockaddr*)&addr, sizeof(addr)),
2294 "bind should have worked\n");
2295
2296 /* read address to find out the port number to be used in sendto */
2297 memset(&addr, 0, sizeof(addr));
2298 addrsize = sizeof(addr);
2299 ok(!getsockname(source, (struct sockaddr *) &addr, &addrsize),
2300 "getsockname should have worked\n");
2301 ok(addr.sin_port, "socket port should be != 0\n");
2302
2303 set_blocking(source, TRUE);
2304
2305 addrsize = sizeof(addr);
2306 size = sendto(source, teststr, sizeof(teststr), 0, (struct sockaddr *) &addr, addrsize);
2307 ok(size == sizeof(teststr), "got %d (err %d)\n", size, WSAGetLastError());
2308
2309 SetLastError(0xdeadbeef);
2310 addrsize = sizeof(addr);
2311 memset(buffer, 0, sizeof(buffer));
2312 todo_wine {
2313 ok(recvfrom(dupsock, buffer, sizeof(teststr), 0, (struct sockaddr *) &addr, &addrsize) == -1,
2314 "recvfrom should have failed\n");
2315 err = WSAGetLastError();
2316 ok(err == WSAEINVAL, "expected 10022, received %d\n", err);
2317 }
2318
2319 closesocket(dupsock);
2320 closesocket(source);
2321 }
2322
2323 static void test_WSAAddressToStringA(void)
2324 {
2325 SOCKET v6 = INVALID_SOCKET;
2326 INT ret;
2327 DWORD len;
2328 int GLE;
2329 SOCKADDR_IN sockaddr;
2330 CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2331
2332 CHAR expect1[] = "0.0.0.0";
2333 CHAR expect2[] = "255.255.255.255";
2334 CHAR expect3[] = "0.0.0.0:65535";
2335 CHAR expect4[] = "255.255.255.255:65535";
2336
2337 SOCKADDR_IN6 sockaddr6;
2338 CHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2339
2340 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2341 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2342 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2343
2344 CHAR expect6_1[] = "::1";
2345 CHAR expect6_2[] = "20ab::1";
2346 CHAR expect6_3[] = "[20ab::2001]:33274";
2347 CHAR expect6_3_nt[] = "20ab::2001@33274";
2348 CHAR expect6_3_w2k[] = "20ab::2001";
2349 CHAR expect6_3_2[] = "[20ab::2001%4660]:33274";
2350 CHAR expect6_3_2_nt[] = "4660/20ab::2001@33274";
2351 CHAR expect6_3_2_w2k[] = "20ab::2001%4660";
2352 CHAR expect6_3_3[] = "20ab::2001%4660";
2353 CHAR expect6_3_3_nt[] = "4660/20ab::2001";
2354
2355 len = 0;
2356
2357 sockaddr.sin_family = AF_INET;
2358 sockaddr.sin_port = 0;
2359 sockaddr.sin_addr.s_addr = 0;
2360
2361 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2362 GLE = WSAGetLastError();
2363 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
2364 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2365 GLE, ret );
2366
2367 len = sizeof(address);
2368
2369 sockaddr.sin_family = AF_INET;
2370 sockaddr.sin_port = 0;
2371 sockaddr.sin_addr.s_addr = 0;
2372
2373 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2374 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2375
2376 ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
2377 ok( len == sizeof( expect1 ), "Got size %d\n", len);
2378
2379 len = sizeof(address);
2380
2381 sockaddr.sin_family = AF_INET;
2382 sockaddr.sin_port = 0;
2383 sockaddr.sin_addr.s_addr = 0xffffffff;
2384
2385 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2386 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2387
2388 ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
2389
2390 len = sizeof(address);
2391
2392 sockaddr.sin_family = AF_INET;
2393 sockaddr.sin_port = 0xffff;
2394 sockaddr.sin_addr.s_addr = 0;
2395
2396 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2397 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2398
2399 ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
2400
2401 len = sizeof(address);
2402
2403 sockaddr.sin_family = AF_INET;
2404 sockaddr.sin_port = 0xffff;
2405 sockaddr.sin_addr.s_addr = 0xffffffff;
2406
2407 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2408 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2409
2410 ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
2411 ok( len == sizeof( expect4 ), "Got size %d\n", len);
2412
2413 /*check to see it IPv6 is available */
2414 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
2415 if (v6 == INVALID_SOCKET) {
2416 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2417 WSAGetLastError(), WSAEAFNOSUPPORT);
2418 goto end;
2419 }
2420 /* Test a short IPv6 address */
2421 len = sizeof(address6);
2422
2423 sockaddr6.sin6_family = AF_INET6;
2424 sockaddr6.sin6_port = 0x0000;
2425 sockaddr6.sin6_scope_id = 0;
2426 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
2427
2428 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2429 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2430 ok( !strcmp( address6, expect6_1 ), "Expected: %s, got: %s\n", expect6_1, address6 );
2431 ok( len == sizeof(expect6_1), "Got size %d\n", len);
2432
2433 /* Test a longer IPv6 address */
2434 len = sizeof(address6);
2435
2436 sockaddr6.sin6_family = AF_INET6;
2437 sockaddr6.sin6_port = 0x0000;
2438 sockaddr6.sin6_scope_id = 0;
2439 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
2440
2441 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2442 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2443 ok( !strcmp( address6, expect6_2 ), "Expected: %s, got: %s\n", expect6_2, address6 );
2444 ok( len == sizeof(expect6_2), "Got size %d\n", len);
2445
2446 /* Test IPv6 address and port number */
2447 len = sizeof(address6);
2448
2449 sockaddr6.sin6_family = AF_INET6;
2450 sockaddr6.sin6_port = 0xfa81;
2451 sockaddr6.sin6_scope_id = 0;
2452 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2453
2454 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2455 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2456 ok( !strcmp( address6, expect6_3 ) ||
2457 broken( !strcmp( address6, expect6_3_nt ) ) || /* NT4 */
2458 broken( !strcmp( address6, expect6_3_w2k ) ), /* Win2000 */
2459 "Expected: %s, got: %s\n", expect6_3, address6 );
2460 ok( len == sizeof(expect6_3) ||
2461 broken( len == sizeof(expect6_3_nt) ) || /* NT4 */
2462 broken( len == sizeof(expect6_3_w2k) ), /* Win2000 */
2463 "Got size %d\n", len);
2464
2465 /* Test IPv6 address, port number and scope_id */
2466 len = sizeof(address6);
2467
2468 sockaddr6.sin6_family = AF_INET6;
2469 sockaddr6.sin6_port = 0xfa81;
2470 sockaddr6.sin6_scope_id = 0x1234;
2471 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2472
2473 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2474 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2475 ok( !strcmp( address6, expect6_3_2 ) ||
2476 broken( !strcmp( address6, expect6_3_2_nt ) ) || /* NT4 */
2477 broken( !strcmp( address6, expect6_3_2_w2k ) ), /* Win2000 */
2478 "Expected: %s, got: %s\n", expect6_3_2, address6 );
2479 ok( len == sizeof(expect6_3_2) ||
2480 broken( len == sizeof(expect6_3_2_nt) ) || /* NT4 */
2481 broken( len == sizeof(expect6_3_2_w2k) ), /* Win2000 */
2482 "Got size %d\n", len);
2483
2484 /* Test IPv6 address and scope_id */
2485 len = sizeof(address6);
2486
2487 sockaddr6.sin6_family = AF_INET6;
2488 sockaddr6.sin6_port = 0x0000;
2489 sockaddr6.sin6_scope_id = 0x1234;
2490 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2491
2492 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2493 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
2494 ok( !strcmp( address6, expect6_3_3 ) ||
2495 broken( !strcmp( address6, expect6_3_3_nt ) ), /* NT4 */
2496 "Expected: %s, got: %s\n", expect6_3_3, address6 );
2497 ok( len == sizeof(expect6_3_3) ||
2498 broken( len == sizeof(expect6_3_3_nt) ), /* NT4 */
2499 "Got size %d\n", len);
2500
2501 end:
2502 if (v6 != INVALID_SOCKET)
2503 closesocket(v6);
2504 }
2505
2506 static void test_WSAAddressToStringW(void)
2507 {
2508 SOCKET v6 = INVALID_SOCKET;
2509 INT ret;
2510 DWORD len;
2511 int GLE;
2512 SOCKADDR_IN sockaddr;
2513 WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
2514
2515 WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
2516 WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
2517 WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
2518 WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
2519 '6', '5', '5', '3', '5', 0 };
2520
2521 SOCKADDR_IN6 sockaddr6;
2522 WCHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2523
2524 CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2525 CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
2526 CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
2527
2528 WCHAR expect6_1[] = {':',':','1',0};
2529 WCHAR expect6_2[] = {'2','0','a','b',':',':','1',0};
2530 WCHAR expect6_3[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
2531 WCHAR expect6_3_nt[] = {'2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
2532 WCHAR expect6_3_w2k[] = {'2','0','a','b',':',':','2','0','0','1',0};
2533 WCHAR expect6_3_2[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
2534 WCHAR expect6_3_2_nt[] = {'4','6','6','0','/','2','0','a','b',':',':','2','0','0','1','@','3','3','2','7','4',0};
2535 WCHAR expect6_3_2_w2k[] = {'2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',0};
2536 WCHAR expect6_3_3[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
2537 WCHAR expect6_3_3_nt[] = {'6','5','5','3','4','/','2','0','a','b',':',':','2','0','0','1',0};
2538
2539 len = 0;
2540
2541 sockaddr.sin_family = AF_INET;
2542 sockaddr.sin_port = 0;
2543 sockaddr.sin_addr.s_addr = 0;
2544
2545 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2546 GLE = WSAGetLastError();
2547 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
2548 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
2549 GLE, ret );
2550
2551 len = sizeof(address);
2552
2553 sockaddr.sin_family = AF_INET;
2554 sockaddr.sin_port = 0;
2555 sockaddr.sin_addr.s_addr = 0;
2556
2557 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2558 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2559
2560 ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
2561 ok( len == sizeof( expect1 )/sizeof( WCHAR ), "Got size %d\n", len);
2562
2563 len = sizeof(address);
2564
2565 sockaddr.sin_family = AF_INET;
2566 sockaddr.sin_port = 0;
2567 sockaddr.sin_addr.s_addr = 0xffffffff;
2568
2569 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2570 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2571
2572 ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
2573
2574 len = sizeof(address);
2575
2576 sockaddr.sin_family = AF_INET;
2577 sockaddr.sin_port = 0xffff;
2578 sockaddr.sin_addr.s_addr = 0;
2579
2580 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2581 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2582
2583 ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
2584
2585 len = sizeof(address);
2586
2587 sockaddr.sin_family = AF_INET;
2588 sockaddr.sin_port = 0xffff;
2589 sockaddr.sin_addr.s_addr = 0xffffffff;
2590
2591 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
2592 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2593
2594 ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
2595 ok( len == sizeof( expect4 )/sizeof( WCHAR ), "Got %d\n", len);
2596
2597 /*check to see it IPv6 is available */
2598 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
2599 if (v6 == INVALID_SOCKET) {
2600 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2601 WSAGetLastError(), WSAEAFNOSUPPORT);
2602 goto end;
2603 }
2604
2605 /* Test a short IPv6 address */
2606 len = sizeof(address6)/sizeof(WCHAR);
2607
2608 sockaddr6.sin6_family = AF_INET6;
2609 sockaddr6.sin6_port = 0x0000;
2610 sockaddr6.sin6_scope_id = 0;
2611 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
2612
2613 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2614 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2615 ok( !lstrcmpW( address6, expect6_1 ), "Wrong string returned\n" );
2616 ok( len == sizeof(expect6_1)/sizeof(WCHAR), "Got %d\n", len);
2617
2618 /* Test a longer IPv6 address */
2619 len = sizeof(address6)/sizeof(WCHAR);
2620
2621 sockaddr6.sin6_family = AF_INET6;
2622 sockaddr6.sin6_port = 0x0000;
2623 sockaddr6.sin6_scope_id = 0;
2624 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
2625
2626 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2627 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2628
2629 ok( !lstrcmpW( address6, expect6_2 ), "Wrong string returned\n" );
2630 ok( len == sizeof(expect6_2)/sizeof(WCHAR), "Got %d\n", len);
2631
2632 /* Test IPv6 address and port number */
2633 len = sizeof(address6)/sizeof(WCHAR);
2634
2635 sockaddr6.sin6_family = AF_INET6;
2636 sockaddr6.sin6_port = 0xfa81;
2637 sockaddr6.sin6_scope_id = 0;
2638 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2639
2640 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2641 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2642 ok( !lstrcmpW( address6, expect6_3 ) ||
2643 broken( !lstrcmpW( address6, expect6_3_nt ) ) || /* NT4 */
2644 broken( !lstrcmpW( address6, expect6_3_w2k ) ), /* Win2000 */
2645 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3),
2646 wine_dbgstr_w(address6) );
2647 ok( len == sizeof(expect6_3)/sizeof(WCHAR) ||
2648 broken(len == sizeof(expect6_3_nt)/sizeof(WCHAR) ) || /* NT4 */
2649 broken(len == sizeof(expect6_3_w2k)/sizeof(WCHAR) ), /* Win2000 */
2650 "Got %d\n", len);
2651
2652 /* Test IPv6 address, port number and scope_id */
2653 len = sizeof(address6)/sizeof(WCHAR);
2654
2655 sockaddr6.sin6_family = AF_INET6;
2656 sockaddr6.sin6_port = 0xfa81;
2657 sockaddr6.sin6_scope_id = 0x1234;
2658 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2659
2660 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2661 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2662 ok( !lstrcmpW( address6, expect6_3_2 ) ||
2663 broken( !lstrcmpW( address6, expect6_3_2_nt ) ) || /* NT4 */
2664 broken( !lstrcmpW( address6, expect6_3_2_w2k ) ), /* Win2000 */
2665 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_2),
2666 wine_dbgstr_w(address6) );
2667 ok( len == sizeof(expect6_3_2)/sizeof(WCHAR) ||
2668 broken( len == sizeof(expect6_3_2_nt)/sizeof(WCHAR) ) || /* NT4 */
2669 broken( len == sizeof(expect6_3_2_w2k)/sizeof(WCHAR) ), /* Win2000 */
2670 "Got %d\n", len);
2671
2672 /* Test IPv6 address and scope_id */
2673 len = sizeof(address6)/sizeof(WCHAR);
2674
2675 sockaddr6.sin6_family = AF_INET6;
2676 sockaddr6.sin6_port = 0x0000;
2677 sockaddr6.sin6_scope_id = 0xfffe;
2678 memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
2679
2680 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
2681 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
2682 ok( !lstrcmpW( address6, expect6_3_3 ) ||
2683 broken( !lstrcmpW( address6, expect6_3_3_nt ) ), /* NT4 */
2684 "Expected: %s, got: %s\n", wine_dbgstr_w(expect6_3_3),
2685 wine_dbgstr_w(address6) );
2686 ok( len == sizeof(expect6_3_3)/sizeof(WCHAR) ||
2687 broken( len == sizeof(expect6_3_3_nt)/sizeof(WCHAR) ), /* NT4 */
2688 "Got %d\n", len);
2689
2690 end:
2691 if (v6 != INVALID_SOCKET)
2692 closesocket(v6);
2693 }
2694
2695 static void test_WSAStringToAddressA(void)
2696 {
2697 INT ret, len;
2698 SOCKADDR_IN sockaddr;
2699 SOCKADDR_IN6 sockaddr6;
2700 int GLE;
2701
2702 CHAR address1[] = "0.0.0.0";
2703 CHAR address2[] = "127.127.127.127";
2704 CHAR address3[] = "255.255.255.255";
2705 CHAR address4[] = "127.127.127.127:65535";
2706 CHAR address5[] = "255.255.255.255:65535";
2707 CHAR address6[] = "::1";
2708 CHAR address7[] = "[::1]";
2709 CHAR address8[] = "[::1]:65535";
2710
2711 len = 0;
2712 sockaddr.sin_family = AF_INET;
2713
2714 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
2715 ok( ret == SOCKET_ERROR, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
2716 WSAGetLastError() );
2717
2718 len = sizeof(sockaddr);
2719 sockaddr.sin_port = 0;
2720 sockaddr.sin_addr.s_addr = 0;
2721
2722 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
2723 ok( !ret && sockaddr.sin_addr.s_addr == 0,
2724 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
2725
2726 len = sizeof(sockaddr);
2727 sockaddr.sin_port = 0;
2728 sockaddr.sin_addr.s_addr = 0;
2729
2730 ret = WSAStringToAddressA( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
2731 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
2732 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
2733
2734 len = sizeof(sockaddr);
2735 sockaddr.sin_port = 0;
2736 sockaddr.sin_addr.s_addr = 0;
2737
2738 ret = WSAStringToAddressA( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
2739 GLE = WSAGetLastError();
2740 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
2741 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
2742 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
2743
2744 len = sizeof(sockaddr);
2745 sockaddr.sin_port = 0;
2746 sockaddr.sin_addr.s_addr = 0;
2747
2748 ret = WSAStringToAddressA( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
2749 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
2750 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
2751
2752 len = sizeof(sockaddr);
2753 sockaddr.sin_port = 0;
2754 sockaddr.sin_addr.s_addr = 0;
2755
2756 ret = WSAStringToAddressA( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
2757 GLE = WSAGetLastError();
2758 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
2759 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
2760 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
2761
2762 len = sizeof(sockaddr6);
2763 memset(&sockaddr6, 0, len);
2764 sockaddr6.sin6_family = AF_INET6;
2765
2766 ret = WSAStringToAddressA( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
2767 &len );
2768 GLE = WSAGetLastError();
2769 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
2770 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
2771
2772 len = sizeof(sockaddr6);
2773 memset(&sockaddr6, 0, len);
2774 sockaddr6.sin6_family = AF_INET6;
2775
2776 ret = WSAStringToAddressA( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
2777 &len );
2778 GLE = WSAGetLastError();
2779 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
2780 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
2781
2782 len = sizeof(sockaddr6);
2783 memset(&sockaddr6, 0, len);
2784 sockaddr6.sin6_family = AF_INET6;
2785
2786 ret = WSAStringToAddressA( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
2787 &len );
2788 GLE = WSAGetLastError();
2789 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
2790 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
2791 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
2792
2793 }
2794
2795 static void test_WSAStringToAddressW(void)
2796 {
2797 INT ret, len;
2798 SOCKADDR_IN sockaddr, *sin;
2799 SOCKADDR_IN6 sockaddr6;
2800 SOCKADDR_STORAGE sockaddr_storage;
2801 int GLE;
2802
2803 WCHAR address1[] = { '0','.','0','.','0','.','0', 0 };
2804 WCHAR address2[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
2805 WCHAR address3[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
2806 WCHAR address4[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
2807 ':', '6', '5', '5', '3', '5', 0 };
2808 WCHAR address5[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
2809 '6', '5', '5', '3', '5', 0 };
2810 WCHAR address6[] = {':',':','1','\0'};
2811 WCHAR address7[] = {'[',':',':','1',']','\0'};
2812 WCHAR address8[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
2813
2814 len = 0;
2815 sockaddr.sin_family = AF_INET;
2816
2817 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
2818 ok( ret == SOCKET_ERROR, "WSAStringToAddressW() failed unexpectedly: %d\n",
2819 WSAGetLastError() );
2820
2821 len = sizeof(sockaddr);
2822 sockaddr.sin_port = 0;
2823 sockaddr.sin_addr.s_addr = 0;
2824
2825 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
2826 ok( !ret && sockaddr.sin_addr.s_addr == 0,
2827 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2828
2829 len = sizeof(sockaddr);
2830 sockaddr.sin_port = 0;
2831 sockaddr.sin_addr.s_addr = 0;
2832
2833 ret = WSAStringToAddressW( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
2834 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
2835 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2836
2837 len = sizeof(sockaddr);
2838 sockaddr.sin_port = 0;
2839 sockaddr.sin_addr.s_addr = 0;
2840
2841 ret = WSAStringToAddressW( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
2842 GLE = WSAGetLastError();
2843 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
2844 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
2845 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
2846
2847 len = sizeof(sockaddr);
2848 sockaddr.sin_port = 0;
2849 sockaddr.sin_addr.s_addr = 0;
2850
2851 ret = WSAStringToAddressW( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
2852 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
2853 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
2854
2855 len = sizeof(sockaddr);
2856 sockaddr.sin_port = 0;
2857 sockaddr.sin_addr.s_addr = 0;
2858
2859 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
2860 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
2861 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
2862 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
2863
2864 /* Test with a larger buffer than necessary */
2865 len = sizeof(sockaddr_storage);
2866 sin = (SOCKADDR_IN *)&sockaddr_storage;
2867 sin->sin_port = 0;
2868 sin->sin_addr.s_addr = 0;
2869
2870 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)sin, &len );
2871 ok( (ret == 0 && sin->sin_addr.s_addr == 0xffffffff && sin->sin_port == 0xffff) ||
2872 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
2873 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
2874 ok( len == sizeof(SOCKADDR_IN) ||
2875 broken(len == sizeof(SOCKADDR_STORAGE)) /* NT4/2k */,
2876 "unexpected length %d\n", len );
2877
2878 len = sizeof(sockaddr6);
2879 memset(&sockaddr6, 0, len);
2880 sockaddr6.sin6_family = AF_INET6;
2881
2882 ret = WSAStringToAddressW( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
2883 &len );
2884 GLE = WSAGetLastError();
2885 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
2886 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
2887
2888 len = sizeof(sockaddr6);
2889 memset(&sockaddr6, 0, len);
2890 sockaddr6.sin6_family = AF_INET6;
2891
2892 ret = WSAStringToAddressW( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
2893 &len );
2894 GLE = WSAGetLastError();
2895 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
2896 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
2897
2898 len = sizeof(sockaddr6);
2899 memset(&sockaddr6, 0, len);
2900 sockaddr6.sin6_family = AF_INET6;
2901
2902 ret = WSAStringToAddressW( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
2903 &len );
2904 GLE = WSAGetLastError();
2905 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
2906 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
2907 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
2908
2909 }
2910
2911 static DWORD WINAPI SelectReadThread(void *param)
2912 {
2913 select_thread_params *par = param;
2914 fd_set readfds;
2915 int ret;
2916 struct sockaddr_in addr;
2917 struct timeval select_timeout;
2918
2919 FD_ZERO(&readfds);
2920 FD_SET(par->s, &readfds);
2921 select_timeout.tv_sec=5;
2922 select_timeout.tv_usec=0;
2923 addr.sin_family = AF_INET;
2924 addr.sin_addr.s_addr = inet_addr(SERVERIP);
2925 addr.sin_port = htons(SERVERPORT);
2926
2927 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
2928 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
2929
2930 SetEvent(server_ready);
2931 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
2932 par->ReadKilled = (ret == 1);
2933
2934 return 0;
2935 }
2936
2937 static void test_errors(void)
2938 {
2939 SOCKET sock;
2940 SOCKADDR_IN SockAddr;
2941 int ret, err;
2942
2943 WSASetLastError(NO_ERROR);
2944 sock = socket(PF_INET, SOCK_STREAM, 0);
2945 ok( (sock != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2946 memset(&SockAddr, 0, sizeof(SockAddr));
2947 SockAddr.sin_family = AF_INET;
2948 SockAddr.sin_port = htons(6924);
2949 SockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
2950
2951 ret = connect(sock, (PSOCKADDR)&SockAddr, sizeof(SockAddr));
2952 ok( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got: %d\n", ret );
2953 if (ret == SOCKET_ERROR)
2954 {
2955 err = WSAGetLastError();
2956 ok( (err == WSAECONNREFUSED), "expected WSAECONNREFUSED, got: %d\n", err );
2957 }
2958
2959 {
2960 TIMEVAL timeval;
2961 fd_set set = {1, {sock}};
2962
2963 timeval.tv_sec = 0;
2964 timeval.tv_usec = 50000;
2965
2966 ret = select(1, NULL, &set, NULL, &timeval);
2967 ok( (ret == 0), "expected 0 (timeout), got: %d\n", ret );
2968 }
2969
2970 ret = closesocket(sock);
2971 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", WSAGetLastError());
2972 }
2973
2974 static void test_listen(void)
2975 {
2976 SOCKET fdA, fdB;
2977 int ret, acceptc, olen = sizeof(acceptc);
2978 struct sockaddr_in address;
2979
2980 memset(&address, 0, sizeof(address));
2981 address.sin_addr.s_addr = inet_addr("127.0.0.1");
2982 address.sin_family = AF_INET;
2983 address.sin_port = htons(SERVERPORT);
2984
2985 /* invalid socket tests */
2986 SetLastError(0xdeadbeef);
2987 ok ((listen(0, 0) == SOCKET_ERROR), "listen did not fail\n");
2988 ret = WSAGetLastError();
2989 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
2990
2991 SetLastError(0xdeadbeef);
2992 ok ((listen(0xdeadbeef, 0) == SOCKET_ERROR), "listen did not fail\n");
2993 ret = WSAGetLastError();
2994 ok (ret == WSAENOTSOCK, "expected 10038, received %d\n", ret);
2995
2996 /* tcp tests */
2997 fdA = socket(AF_INET, SOCK_STREAM, 0);
2998 ok ((fdA != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
2999
3000 fdB = socket(AF_INET, SOCK_STREAM, 0);
3001 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3002
3003 SetLastError(0xdeadbeef);
3004 ok ((listen(fdA, -2) == SOCKET_ERROR), "listen did not fail\n");
3005 ret = WSAGetLastError();
3006 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3007
3008 SetLastError(0xdeadbeef);
3009 ok ((listen(fdA, 1) == SOCKET_ERROR), "listen did not fail\n");
3010 ret = WSAGetLastError();
3011 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3012
3013 SetLastError(0xdeadbeef);
3014 ok ((listen(fdA, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3015 ret = WSAGetLastError();
3016 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3017
3018 ok (!bind(fdA, (struct sockaddr*) &address, sizeof(address)), "bind failed\n");
3019
3020 SetLastError(0xdeadbeef);
3021 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3022 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3023
3024 acceptc = 0xdead;
3025 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3026 ok (!ret, "getsockopt failed\n");
3027 ok (acceptc == 0, "SO_ACCEPTCONN should be 0, received %d\n", acceptc);
3028
3029 ok (!listen(fdA, 0), "listen failed\n");
3030 ok (!listen(fdA, SOMAXCONN), "double listen failed\n");
3031
3032 acceptc = 0xdead;
3033 ret = getsockopt(fdA, SOL_SOCKET, SO_ACCEPTCONN, (char*)&acceptc, &olen);
3034 ok (!ret, "getsockopt failed\n");
3035 ok (acceptc == 1, "SO_ACCEPTCONN should be 1, received %d\n", acceptc);
3036
3037 SetLastError(0xdeadbeef);
3038 ok ((listen(fdB, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3039 ret = WSAGetLastError();
3040 ok (ret == WSAEINVAL, "expected 10022, received %d\n", ret);
3041
3042 ret = closesocket(fdB);
3043 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3044
3045 fdB = socket(AF_INET, SOCK_STREAM, 0);
3046 ok ((fdB != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3047
3048 SetLastError(0xdeadbeef);
3049 ok (bind(fdB, (struct sockaddr*) &address, sizeof(address)), "bind should have failed\n");
3050 ret = WSAGetLastError();
3051 ok (ret == WSAEADDRINUSE, "expected 10048, received %d\n", ret);
3052
3053 ret = closesocket(fdA);
3054 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3055 ret = closesocket(fdB);
3056 ok (ret == 0, "closesocket failed unexpectedly: %d\n", ret);
3057 }
3058
3059 static void test_select(void)
3060 {
3061 SOCKET fdRead, fdWrite;
3062 fd_set readfds, writefds, exceptfds;
3063 unsigned int maxfd;
3064 int ret;
3065 char buffer;
3066 struct timeval select_timeout;
3067 select_thread_params thread_params;
3068 HANDLE thread_handle;
3069 DWORD id;
3070
3071 fdRead = socket(AF_INET, SOCK_STREAM, 0);
3072 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3073 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
3074 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
3075
3076 FD_ZERO(&readfds);
3077 FD_ZERO(&writefds);
3078 FD_ZERO(&exceptfds);
3079 FD_SET(fdRead, &readfds);
3080 FD_SET(fdWrite, &writefds);
3081 FD_SET(fdRead, &exceptfds);
3082 FD_SET(fdWrite, &exceptfds);
3083 select_timeout.tv_sec=0;
3084 select_timeout.tv_usec=500;
3085
3086 maxfd = fdRead;
3087 if (fdWrite > maxfd)
3088 maxfd = fdWrite;
3089
3090 todo_wine {
3091 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3092 ok ( (ret == 0), "select should not return any socket handles\n");
3093 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3094 }
3095 ok ( !FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
3096
3097 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3098 ok ( !FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
3099
3100 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
3101 ret = closesocket(fdWrite);
3102 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3103
3104 thread_params.s = fdRead;
3105 thread_params.ReadKilled = FALSE;
3106 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
3107 thread_handle = CreateThread (NULL, 0, SelectReadThread, &thread_params, 0, &id );
3108 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
3109
3110 WaitForSingleObject (server_ready, INFINITE);
3111 Sleep(200);
3112 ret = closesocket(fdRead);
3113 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
3114
3115 WaitForSingleObject (thread_handle, 1000);
3116 ok ( (thread_params.ReadKilled) ||
3117 broken(thread_params.ReadKilled == 0), /*Win98*/
3118 "closesocket did not wakeup select\n");
3119 ret = recv(fdRead, &buffer, 1, MSG_PEEK);
3120 ok( (ret == -1), "peek at closed socket expected -1 got %d\n", ret);
3121
3122 /* Test selecting invalid handles */
3123 FD_ZERO(&readfds);
3124 FD_ZERO(&writefds);
3125 FD_ZERO(&exceptfds);
3126
3127 SetLastError(0);
3128 ret = select(maxfd+1, 0, 0, 0, &select_timeout);
3129 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3130 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3131
3132 SetLastError(0);
3133 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3134 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3135 ok ( WSAGetLastError() == WSAEINVAL, "expected WSAEINVAL, got %i\n", WSAGetLastError());
3136
3137 FD_SET(INVALID_SOCKET, &readfds);
3138 SetLastError(0);
3139 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3140 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3141 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3142 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
3143
3144 FD_ZERO(&readfds);
3145 FD_SET(INVALID_SOCKET, &writefds);
3146 SetLastError(0);
3147 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3148 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3149 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3150 ok ( !FD_ISSET(fdRead, &writefds), "FD should not be set\n");
3151
3152 FD_ZERO(&writefds);
3153 FD_SET(INVALID_SOCKET, &exceptfds);
3154 SetLastError(0);
3155 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
3156 ok ( (ret == SOCKET_ERROR), "expected SOCKET_ERROR, got %i\n", ret);
3157 ok ( WSAGetLastError() == WSAENOTSOCK, "expected WSAENOTSOCK, got %i\n", WSAGetLastError());
3158 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
3159 }
3160
3161 static DWORD WINAPI AcceptKillThread(void *param)
3162 {
3163 select_thread_params *par = param;
3164 struct sockaddr_in address;
3165 int len = sizeof(address);
3166 SOCKET client_socket;
3167
3168 SetEvent(server_ready);
3169 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
3170 if (client_socket != INVALID_SOCKET)
3171 closesocket(client_socket);
3172 par->ReadKilled = (client_socket == INVALID_SOCKET);
3173 return 0;
3174 }
3175
3176
3177 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
3178 LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
3179 GROUP *g, DWORD_PTR dwCallbackData)
3180 {
3181 return CF_DEFER;
3182 }
3183
3184 static SOCKET setup_server_socket(struct sockaddr_in *addr, int *len)
3185 {
3186 int ret, val;
3187 SOCKET server_socket;
3188
3189 server_socket = socket(AF_INET, SOCK_STREAM, 0);
3190 if (server_socket == INVALID_SOCKET)
3191 {
3192 trace("error creating server socket: %d\n", WSAGetLastError());
3193 return INVALID_SOCKET;
3194 }
3195
3196 val = 1;
3197 ret = setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
3198 if (ret)
3199 {
3200 trace("error setting SO_REUSEADDR: %d\n", WSAGetLastError());
3201 closesocket(server_socket);
3202 return INVALID_SOCKET;
3203 }
3204
3205 ret = bind(server_socket, (struct sockaddr *)addr, *len);
3206 if (ret)
3207 {
3208 trace("error binding server socket: %d\n", WSAGetLastError());
3209 }
3210
3211 ret = getsockname(server_socket, (struct sockaddr *)addr, len);
3212 if (ret)
3213 {
3214 skip("failed to lookup bind address: %d\n", WSAGetLastError());
3215 closesocket(server_socket);
3216 return INVALID_SOCKET;
3217 }
3218
3219 ret = listen(server_socket, 5);
3220 if (ret)
3221 {
3222 trace("error making server socket listen: %d\n", WSAGetLastError());
3223 closesocket(server_socket);
3224 return INVALID_SOCKET;
3225 }
3226
3227 return server_socket;
3228 }
3229
3230 static SOCKET setup_connector_socket(struct sockaddr_in *addr, int len)
3231 {
3232 int ret;
3233 SOCKET connector;
3234
3235 connector = socket(AF_INET, SOCK_STREAM, 0);
3236 ok(connector != INVALID_SOCKET, "failed to create connector socket %d\n", WSAGetLastError());
3237
3238 ret = connect(connector, (struct sockaddr *)addr, len);
3239 ok(!ret, "connecting to accepting socket failed %d\n", WSAGetLastError());
3240
3241 return connector;
3242 }
3243
3244 static void test_accept(void)
3245 {
3246 int ret;
3247 SOCKET server_socket, accepted = INVALID_SOCKET, connector;
3248 struct sockaddr_in address;
3249 SOCKADDR_STORAGE ss;
3250 int socklen;
3251 select_thread_params thread_params;
3252 HANDLE thread_handle = NULL;
3253 DWORD id;
3254
3255 memset(&address, 0, sizeof(address));
3256 address.sin_addr.s_addr = inet_addr("127.0.0.1");
3257 address.sin_family = AF_INET;
3258
3259 socklen = sizeof(address);
3260 server_socket = setup_server_socket(&address, &socklen);
3261 if (server_socket == INVALID_SOCKET)
3262 {
3263 trace("error creating server socket: %d\n", WSAGetLastError());
3264 return;
3265 }
3266
3267 connector = setup_connector_socket(&address, socklen);
3268 if (connector == INVALID_SOCKET) goto done;
3269
3270 trace("Blocking accept next\n");
3271
3272 accepted = WSAAccept(server_socket, NULL, NULL, AlwaysDeferConditionFunc, 0);
3273 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
3274
3275 accepted = accept(server_socket, NULL, 0);
3276 ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
3277
3278 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
3279 if (server_ready == INVALID_HANDLE_VALUE)
3280 {
3281 trace("error creating event: %d\n", GetLastError());
3282 goto done;
3283 }
3284
3285 thread_params.s = server_socket;
3286 thread_params.ReadKilled = FALSE;
3287 thread_handle = CreateThread(NULL, 0, AcceptKillThread, &thread_params, 0, &id);
3288 if (thread_handle == NULL)
3289 {
3290 trace("error creating thread: %d\n", GetLastError());
3291 goto done;
3292 }
3293
3294 WaitForSingleObject(server_ready, INFINITE);
3295 Sleep(200);
3296 ret = closesocket(server_socket);
3297 if (ret != 0)
3298 {
3299 trace("closesocket failed: %d\n", WSAGetLastError());
3300 goto done;
3301 }
3302
3303 WaitForSingleObject(thread_handle, 1000);
3304 ok(thread_params.ReadKilled || broken(!thread_params.ReadKilled) /* Win98/ME, after accept */,
3305 "closesocket did not wakeup accept\n");
3306
3307 closesocket(accepted);
3308 closesocket(connector);
3309 accepted = connector = server_socket = INVALID_SOCKET;
3310
3311 socklen = sizeof(address);
3312 server_socket = setup_server_socket(&address, &socklen);
3313 if (server_socket == INVALID_SOCKET) goto done;
3314
3315 connector = setup_connector_socket(&address, socklen);
3316 if (connector == INVALID_SOCKET) goto done;
3317
3318 socklen = 0;
3319 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
3320 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
3321 ok(!socklen, "got %d\n", socklen);
3322 closesocket(connector);
3323 connector = INVALID_SOCKET;
3324
3325 socklen = sizeof(address);
3326 connector = setup_connector_socket(&address, socklen);
3327 if (connector == INVALID_SOCKET) goto done;
3328
3329 accepted = WSAAccept(server_socket, NULL, NULL, NULL, 0);
3330 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
3331 closesocket(accepted);
3332 closesocket(connector);
3333 accepted = connector = INVALID_SOCKET;
3334
3335 socklen = sizeof(address);
3336 connector = setup_connector_socket(&address, socklen);
3337 if (connector == INVALID_SOCKET) goto done;
3338
3339 socklen = sizeof(ss);
3340 memset(&ss, 0, sizeof(ss));
3341 accepted = WSAAccept(server_socket, (struct sockaddr *)&ss, &socklen, NULL, 0);
3342 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
3343 ok(socklen != sizeof(ss), "unexpected length\n");
3344 ok(ss.ss_family, "family not set\n");
3345 closesocket(accepted);
3346 closesocket(connector);
3347 accepted = connector = INVALID_SOCKET;
3348
3349 socklen = sizeof(address);
3350 connector = setup_connector_socket(&address, socklen);
3351 if (connector == INVALID_SOCKET) goto done;
3352
3353 socklen = 0;
3354 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
3355 ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSAEFAULT, "got %d\n", WSAGetLastError());
3356 ok(!socklen, "got %d\n", socklen);
3357 closesocket(connector);
3358 accepted = connector = INVALID_SOCKET;
3359
3360 socklen = sizeof(address);
3361 connector = setup_connector_socket(&address, socklen);
3362 if (connector == INVALID_SOCKET) goto done;
3363
3364 accepted = accept(server_socket, NULL, NULL);
3365 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
3366 closesocket(accepted);
3367 closesocket(connector);
3368 accepted = connector = INVALID_SOCKET;
3369
3370 socklen = sizeof(address);
3371 connector = setup_connector_socket(&address, socklen);
3372 if (connector == INVALID_SOCKET) goto done;
3373
3374 socklen = sizeof(ss);
3375 memset(&ss, 0, sizeof(ss));
3376 accepted = accept(server_socket, (struct sockaddr *)&ss, &socklen);
3377 ok(accepted != INVALID_SOCKET, "Failed to accept connection, %d\n", WSAGetLastError());
3378 ok(socklen != sizeof(ss), "unexpected length\n");
3379 ok(ss.ss_family, "family not set\n");
3380
3381 done:
3382 if (accepted != INVALID_SOCKET)
3383 closesocket(accepted);
3384 if (connector != INVALID_SOCKET)
3385 closesocket(connector);
3386 if (thread_handle != NULL)
3387 CloseHandle(thread_handle);
3388 if (server_ready != INVALID_HANDLE_VALUE)
3389 CloseHandle(server_ready);
3390 if (server_socket != INVALID_SOCKET)
3391 closesocket(server_socket);
3392 }
3393
3394 static void test_extendedSocketOptions(void)
3395 {
3396 WSADATA wsa;
3397 SOCKET sock;
3398 struct sockaddr_in sa;
3399 int sa_len = sizeof(struct sockaddr_in);
3400 int optval, optlen = sizeof(int), ret;
3401 BOOL bool_opt_val;
3402 LINGER linger_val;
3403
3404 if(WSAStartup(MAKEWORD(2,0), &wsa)){
3405 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
3406 return;
3407 }
3408
3409 memset(&sa, 0, sa_len);
3410
3411 sa.sin_family = AF_INET;
3412 sa.sin_port = htons(0);
3413 sa.sin_addr.s_addr = htonl(INADDR_ANY);
3414
3415 if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) == INVALID_SOCKET) {
3416 trace("Creating the socket failed: %d\n", WSAGetLastError());
3417 WSACleanup();
3418 return;
3419 }
3420
3421 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
3422 trace("Failed to bind socket: %d\n", WSAGetLastError());
3423 closesocket(sock);
3424 WSACleanup();
3425 return;
3426 }
3427
3428 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
3429
3430 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
3431 ok((optval == 65507) || (optval == 65527),
3432 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
3433
3434 /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
3435 SetLastError(0xdeadbeef);
3436 optval = 0xdeadbeef;
3437 optlen = sizeof(int);
3438 ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
3439 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
3440 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3441 ret, WSAGetLastError(), optval, optval);
3442
3443 /* more invalid values for level */
3444 SetLastError(0xdeadbeef);
3445 optval = 0xdeadbeef;
3446 optlen = sizeof(int);
3447 ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
3448 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
3449 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3450 ret, WSAGetLastError(), optval, optval);
3451
3452 SetLastError(0xdeadbeef);
3453 optval = 0xdeadbeef;
3454 optlen = sizeof(int);
3455 ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
3456 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
3457 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3458 ret, WSAGetLastError(), optval, optval);
3459
3460 SetLastError(0xdeadbeef);
3461 optval = 0xdeadbeef;
3462 optlen = sizeof(int);
3463 ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
3464 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
3465 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3466 ret, WSAGetLastError(), optval, optval);
3467
3468 SetLastError(0xdeadbeef);
3469 optval = 0xdeadbeef;
3470 optlen = sizeof(int);
3471 ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
3472 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
3473 "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
3474 ret, WSAGetLastError(), optval, optval);
3475
3476 SetLastError(0xdeadbeef);
3477 optlen = sizeof(LINGER);
3478 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
3479 ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAENOPROTOOPT),
3480 "getsockopt should fail for UDP sockets setting last error to WSAENOPROTOOPT, got %d with %d\n",
3481 ret, WSAGetLastError());
3482 closesocket(sock);
3483
3484 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
3485 trace("Creating the socket failed: %d\n", WSAGetLastError());
3486 WSACleanup();
3487 return;
3488 }
3489
3490 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
3491 trace("Failed to bind socket: %d\n", WSAGetLastError());
3492 closesocket(sock);
3493 WSACleanup();
3494 return;
3495 }
3496
3497 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
3498 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
3499
3500 optlen = sizeof(BOOL);
3501 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
3502 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
3503 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
3504 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
3505 bool_opt_val, linger_val.l_onoff);
3506
3507 closesocket(sock);
3508 WSACleanup();
3509 }
3510
3511 static void test_getsockname(void)
3512 {
3513 WSADATA wsa;
3514 SOCKET sock;
3515 struct sockaddr_in sa_set, sa_get;
3516 int sa_set_len = sizeof(struct sockaddr_in);
3517 int sa_get_len = sa_set_len;
3518 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
3519 int ret;
3520
3521 if(WSAStartup(MAKEWORD(2,0), &wsa)){
3522 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
3523 return;
3524 }
3525
3526 memset(&sa_set, 0, sa_set_len);
3527
3528 sa_set.sin_family = AF_INET;
3529 sa_set.sin_port = htons(0);
3530 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
3531
3532 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
3533 trace("Creating the socket failed: %d\n", WSAGetLastError());
3534 WSACleanup();
3535 return;
3536 }
3537
3538 sa_get = sa_set;
3539 if (getsockname(sock, (struct sockaddr*) &sa_get, &sa_get_len) == 0)
3540 ok(0, "getsockname on unbound socket should fail\n");
3541 else {
3542 ok(WSAGetLastError() == WSAEINVAL, "getsockname on unbound socket "
3543 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL);
3544 ok(memcmp(&sa_get, &sa_set, sizeof(sa_get)) == 0,
3545 "failed getsockname modified sockaddr when it shouldn't\n");
3546 }
3547
3548 if(bind(sock, (struct sockaddr *) &sa_set, sa_set_len) < 0){
3549 trace("Failed to bind socket: %d\n", WSAGetLastError());
3550 closesocket(sock);
3551 WSACleanup();
3552 return;
3553 }
3554
3555 if(getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len) != 0){
3556 trace("Failed to call getsockname: %d\n", WSAGetLastError());
3557 closesocket(sock);
3558 WSACleanup();
3559 return;
3560 }
3561
3562 ret = memcmp(sa_get.sin_zero, null_padding, 8);
3563 ok(ret == 0 || broken(ret != 0), /* NT4 */
3564 "getsockname did not zero the sockaddr_in structure\n");
3565
3566 closesocket(sock);
3567 WSACleanup();
3568 }
3569
3570 static void test_dns(void)
3571 {
3572 struct hostent *h;
3573 union memaddress
3574 {
3575 char *chr;
3576 void *mem;
3577 } addr;
3578 char **ptr;
3579 int acount;
3580
3581 h = gethostbyname("");
3582 ok(h != NULL, "gethostbyname(\"\") failed with %d\n", h_errno);
3583
3584 /* Use an address with valid alias names if possible */
3585 h = gethostbyname("source.winehq.org");
3586 if(!h)
3587 {
3588 skip("Can't test the hostent structure because gethostbyname failed\n");
3589 return;
3590 }
3591
3592 /* The returned struct must be allocated in a very strict way. First we need to
3593 * count how many aliases there are because they must be located right after
3594 * the struct hostent size. Knowing the amount of aliases we know the exact
3595 * location of the first IP returned. Rule valid for >= XP, for older OS's
3596 * it's somewhat the opposite. */
3597 addr.mem = h + 1;
3598 if(h->h_addr_list == addr.mem) /* <= W2K */
3599 {
3600 win_skip("Skipping hostent tests since this OS is unsupported\n");
3601 return;
3602 }
3603
3604 ok(h->h_aliases == addr.mem,
3605 "hostent->h_aliases should be in %p, it is in %p\n", addr.mem, h->h_aliases);
3606
3607 for(ptr = h->h_aliases, acount = 1; *ptr; ptr++) acount++;
3608 addr.chr += sizeof(*ptr) * acount;
3609 ok(h->h_addr_list == addr.mem,
3610 "hostent->h_addr_list should be in %p, it is in %p\n", addr.mem, h->h_addr_list);
3611
3612 for(ptr = h->h_addr_list, acount = 1; *ptr; ptr++) acount++;
3613
3614 addr.chr += sizeof(*ptr) * acount;
3615 ok(h->h_addr_list[0] == addr.mem,
3616 "hostent->h_addr_list[0] should be in %p, it is in %p\n", addr.mem, h->h_addr_list[0]);
3617 }
3618
3619 /* Our winsock headers don't define gethostname because it conflicts with the
3620 * definition in unistd.h. Define it here to get rid of the warning. */
3621
3622 int WINAPI gethostname(char *name, int namelen);
3623
3624 static void test_gethostbyname_hack(void)
3625 {
3626 struct hostent *he;
3627 char name[256];
3628 static BYTE loopback[] = {127, 0, 0, 1};
3629 static BYTE magic_loopback[] = {127, 12, 34, 56};
3630 int ret;
3631
3632 ret = gethostname(name, 256);
3633 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
3634
3635 he = gethostbyname("localhost");
3636 ok(he != NULL, "gethostbyname(\"localhost\") failed: %d\n", h_errno);
3637 if(he)
3638 {
3639 if(he->h_length != 4)
3640 {
3641 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
3642 return;
3643 }
3644
3645 ok(memcmp(he->h_addr_list[0], loopback, he->h_length) == 0,
3646 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
3647 he->h_addr_list[0][0], he->h_addr_list[0][1], he->h_addr_list[0][2],
3648 he->h_addr_list[0][3]);
3649 }
3650
3651 if(strcmp(name, "localhost") == 0)
3652 {
3653 skip("hostname seems to be \"localhost\", skipping test.\n");
3654 return;
3655 }
3656
3657 he = NULL;
3658 he = gethostbyname(name);
3659 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, h_errno);
3660 if(he)
3661 {
3662 if(he->h_length != 4)
3663 {
3664 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
3665 return;
3666 }
3667
3668 if (he->h_addr_list[0][0] == 127)
3669 {
3670 ok(memcmp(he->h_addr_list[0], magic_loopback, he->h_length) == 0,
3671 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
3672 name, he->h_addr_list[0][0], he->h_addr_list[0][1],
3673 he->h_addr_list[0][2], he->h_addr_list[0][3]);
3674 }
3675 }
3676
3677 gethostbyname("nonexistent.winehq.org");
3678 /* Don't check for the return value, as some braindead ISPs will kindly
3679 * resolve nonexistent host names to addresses of the ISP's spam pages. */
3680 }
3681
3682 static void test_inet_addr(void)
3683 {
3684 u_long addr;
3685
3686 addr = inet_addr(NULL);
3687 ok(addr == INADDR_NONE, "inet_addr succeeded unexpectedly\n");
3688 }
3689
3690 static void test_addr_to_print(void)
3691 {
3692 char dst[16];
3693 char dst6[64];
3694 const char * pdst;
3695 struct in_addr in;
3696 struct in6_addr in6;
3697
3698 u_long addr0_Num = 0x00000000;
3699 PCSTR addr0_Str = "0.0.0.0";
3700 u_long addr1_Num = 0x20201015;
3701 PCSTR addr1_Str = "21.16.32.32";
3702 u_char addr2_Num[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
3703 PCSTR addr2_Str = "::fffe:cc98:bd74";
3704 u_char addr3_Num[16] = {0x20,0x30,0xa4,0xb1};
3705 PCSTR addr3_Str = "2030:a4b1::";
3706 u_char addr4_Num[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
3707 PCSTR addr4_Str = "::204.152.189.116";
3708
3709 /* Test IPv4 addresses */
3710 in.s_addr = addr0_Num;
3711
3712 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
3713 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
3714 ok(!strcmp(pdst, addr0_Str),"Address %s != %s\n", pdst, addr0_Str);
3715
3716 /* Test that inet_ntoa and inet_ntop return the same value */
3717 in.S_un.S_addr = addr1_Num;
3718 pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
3719 ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
3720 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
3721
3722 /* InetNtop became available in Vista and Win2008 */
3723 if (!pInetNtop)
3724 {
3725 win_skip("InetNtop not present, not executing tests\n");
3726 return;
3727 }
3728
3729 /* Second part of test */
3730 pdst = pInetNtop(AF_INET,(void*)&in.s_addr, dst, sizeof(dst));
3731 ok(pdst != NULL, "InetNtop failed %s\n", dst);
3732 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
3733
3734 /* Test invalid parm conditions */
3735 pdst = pInetNtop(1, (void*)&in.s_addr, dst, sizeof(dst));
3736 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
3737 ok(WSAGetLastError() == WSAEAFNOSUPPORT, "Should be WSAEAFNOSUPPORT\n");
3738
3739 /* Test Null destination */
3740 pdst = NULL;
3741 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, NULL, sizeof(dst));
3742 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
3743 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
3744 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3745
3746 /* Test zero length passed */
3747 WSASetLastError(0);
3748 pdst = NULL;
3749 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 0);
3750 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
3751 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
3752 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3753
3754 /* Test length one shorter than the address length */
3755 WSASetLastError(0);
3756 pdst = NULL;
3757 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 6);
3758 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
3759 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
3760 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3761
3762 /* Test longer length is ok */
3763 WSASetLastError(0);
3764 pdst = NULL;
3765 pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, sizeof(dst)+1);
3766 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
3767 ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
3768
3769 /* Test the IPv6 addresses */
3770
3771 /* Test an zero prefixed IPV6 address */
3772 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
3773 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
3774 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
3775 ok(!strcmp(pdst, addr2_Str),"Address %s != %s\n", pdst, addr2_Str);
3776
3777 /* Test an zero suffixed IPV6 address */
3778 memcpy(in6.s6_addr, addr3_Num, sizeof(addr3_Num));
3779 pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
3780 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
3781 ok(!strcmp(pdst, addr3_Str),"Address %s != %s\n", pdst, addr3_Str);
3782
3783 /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
3784 memcpy(in6.s6_addr, addr4_Num, sizeof(addr4_Num));
3785 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, sizeof(dst6));
3786 ok(pdst != NULL, "InetNtop failed %s\n", dst6);
3787 ok(!strcmp(pdst, addr4_Str),"Address %s != %s\n", pdst, addr4_Str);
3788
3789 /* Test invalid parm conditions */
3790 memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
3791
3792 /* Test Null destination */
3793 pdst = NULL;
3794 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, NULL, sizeof(dst6));
3795 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
3796 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
3797 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3798
3799 /* Test zero length passed */
3800 WSASetLastError(0);
3801 pdst = NULL;
3802 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 0);
3803 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
3804 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
3805 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3806
3807 /* Test length one shorter than the address length */
3808 WSASetLastError(0);
3809 pdst = NULL;
3810 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 16);
3811 ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
3812 ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
3813 "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
3814
3815 /* Test longer length is ok */
3816 WSASetLastError(0);
3817 pdst = NULL;
3818 pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 18);
3819 ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
3820 }
3821
3822 static void test_ioctlsocket(void)
3823 {
3824 SOCKET sock;
3825 struct tcp_keepalive kalive;
3826 int ret, optval;
3827 static const LONG cmds[] = {FIONBIO, FIONREAD, SIOCATMARK};
3828 UINT i;
3829 u_long arg = 0;
3830
3831 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3832 ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
3833 if(sock == INVALID_SOCKET)
3834 {
3835 skip("Can't continue without a socket.\n");
3836 return;
3837 }
3838
3839 for(i = 0; i < sizeof(cmds)/sizeof(cmds[0]); i++)
3840 {
3841 /* broken apps like defcon pass the argp value directly instead of a pointer to it */
3842 ret = ioctlsocket(sock, cmds[i], (u_long *)1);
3843 ok(ret == SOCKET_ERROR, "ioctlsocket succeeded unexpectedly\n");
3844 ret = WSAGetLastError();
3845 ok(ret == WSAEFAULT, "expected WSAEFAULT, got %d instead\n", ret);
3846 }
3847
3848 /* A fresh and not connected socket has no urgent data, this test shows
3849 * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
3850
3851 ret = ioctlsocket(sock, SIOCATMARK, &arg);
3852 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
3853 ok(arg, "SIOCATMARK expected a non-zero value\n");
3854
3855 /* when SO_OOBINLINE is set SIOCATMARK must always return TRUE */
3856 optval = 1;
3857 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
3858 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
3859 arg = 0;
3860 ret = ioctlsocket(sock, SIOCATMARK, &arg);
3861 ok(ret != SOCKET_ERROR, "ioctlsocket failed unexpectedly\n");
3862 ok(arg, "SIOCATMARK expected a non-zero value\n");
3863
3864 /* disable SO_OOBINLINE and get the same old behavior */
3865 optval = 0;
3866 ret = setsockopt(sock, SOL_SOCKET, SO_OOBINLINE, (void *)&optval, sizeof(optval));
3867 ok(ret != SOCKET_ERROR, "setsockopt failed unexpectedly\n");
3868 arg = 0;
3869 ret = ioctlsocket(sock, SIOCATMARK, &arg);
3870 ok(arg, "SIOCATMARK expected a non-zero value\n");
3871
3872 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &arg, 0, NULL, 0, &arg, NULL, NULL);
3873 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
3874 ret = WSAGetLastError();
3875 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
3876
3877 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, NULL, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
3878 ok(ret == SOCKET_ERROR, "WSAIoctl succeeded unexpectedly\n");
3879 ret = WSAGetLastError();
3880 ok(ret == WSAEFAULT || broken(ret == WSAEINVAL), "expected WSAEFAULT, got %d instead\n", ret);
3881
3882 /* broken used to catch W95, W98, NT4 */
3883 make_keepalive(kalive, 0, 0, 0);
3884 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
3885 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
3886
3887 make_keepalive(kalive, 1, 0, 0);
3888 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
3889 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
3890
3891 make_keepalive(kalive, 1, 1000, 1000);
3892 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
3893 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
3894
3895 make_keepalive(kalive, 1, 10000, 10000);
3896 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
3897 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
3898
3899 make_keepalive(kalive, 1, 100, 100);
3900 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
3901 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
3902
3903 make_keepalive(kalive, 0, 100, 100);
3904 ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &kalive, sizeof(struct tcp_keepalive), NULL, 0, &arg, NULL, NULL);
3905 ok(ret == 0 || broken(ret == SOCKET_ERROR), "WSAIoctl failed unexpectedly\n");
3906
3907 closesocket(sock);
3908 }
3909
3910 static BOOL drain_pause = FALSE;
3911 static DWORD WINAPI drain_socket_thread(LPVOID arg)
3912 {
3913 char buffer[1024];
3914 SOCKET sock = *(SOCKET*)arg;
3915 int ret;
3916
3917 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
3918 {
3919 if (ret < 0)
3920 {
3921 if (WSAGetLastError() == WSAEWOULDBLOCK)
3922 {
3923 fd_set readset;
3924 FD_ZERO(&readset);
3925 FD_SET(sock, &readset);
3926 select(sock+1, &readset, NULL, NULL, NULL);
3927 while (drain_pause)
3928 Sleep(100);
3929 }
3930 else
3931 break;
3932 }
3933 }
3934 return 0;
3935 }
3936
3937 static void test_send(void)
3938 {
3939 SOCKET src = INVALID_SOCKET;
3940 SOCKET dst = INVALID_SOCKET;
3941 HANDLE hThread = NULL;
3942 const int buflen = 1024*1024;
3943 char *buffer = NULL;
3944 int ret, i, zero = 0;
3945 WSABUF buf;
3946 OVERLAPPED ov;
3947 BOOL bret;
3948 DWORD id, bytes_sent, dwRet;
3949
3950 memset(&ov, 0, sizeof(ov));
3951
3952 if (tcp_socketpair(&src, &dst) != 0)
3953 {
3954 ok(0, "creating socket pair failed, skipping test\n");
3955 return;
3956 }
3957
3958 set_blocking(dst, FALSE);
3959 /* force disable buffering so we can get a pending overlapped request */
3960 ret = setsockopt(dst, SOL_SOCKET, SO_SNDBUF, (char *) &zero, sizeof(zero));
3961 ok(!ret, "setsockopt SO_SNDBUF failed: %d - %d\n", ret, GetLastError());
3962
3963 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
3964 if (hThread == NULL)
3965 {
3966 ok(0, "CreateThread failed, error %d\n", GetLastError());
3967 goto end;
3968 }
3969
3970 buffer = HeapAlloc(GetProcessHeap(), 0, buflen);
3971 if (buffer == NULL)
3972 {
3973 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
3974 goto end;
3975 }
3976
3977 /* fill the buffer with some nonsense */
3978 for (i = 0; i < buflen; ++i)
3979 {
3980 buffer[i] = (char) i;
3981 }
3982
3983 ret = send(src, buffer, buflen, 0);
3984 if (ret >= 0)
3985 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
3986 else
3987 ok(0, "send failed, error %d\n", WSAGetLastError());
3988
3989 buf.buf = buffer;
3990 buf.len = buflen;
3991
3992 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
3993 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
3994 if (!ov.hEvent)
3995 goto end;
3996
3997 bytes_sent = 0;
3998 WSASetLastError(12345);
3999 ret = WSASend(dst, &buf, 1, &bytes_sent, 0, &ov, NULL);
4000 ok((ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING) || broken(bytes_sent == buflen),
4001 "Failed to start overlapped send %d - %d - %d/%d\n", ret, WSAGetLastError(), bytes_sent, buflen);
4002
4003 /* don't check for completion yet, we may need to drain the buffer while still sending */
4004 set_blocking(src, FALSE);
4005 for (i = 0; i < buflen; ++i)
4006 {
4007 int j = 0;
4008
4009 ret = recv(src, buffer, 1, 0);
4010 while (ret == SOCKET_ERROR && GetLastError() == WSAEWOULDBLOCK && j < 100)
4011 {
4012 j++;
4013 Sleep(50);
4014 ret = recv(src, buffer, 1, 0);
4015 }
4016
4017 ok(ret == 1, "Failed to receive data %d - %d (got %d/%d)\n", ret, GetLastError(), i, buflen);
4018 if (ret != 1)
4019 break;
4020
4021 ok(buffer[0] == (char) i, "Received bad data at position %d\n", i);
4022 }
4023
4024 dwRet = WaitForSingleObject(ov.hEvent, 1000);
4025 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
4026 if (dwRet == WAIT_OBJECT_0)
4027 {
4028 bret = GetOverlappedResult((HANDLE)dst, &ov, &bytes_sent, FALSE);
4029 ok((bret && bytes_sent == buflen) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
4030 "Got %d instead of %d (%d - %d)\n", bytes_sent, buflen, bret, GetLastError());
4031 }
4032
4033 WSASetLastError(12345);
4034 ret = WSASend(INVALID_SOCKET, &buf, 1, NULL, 0, &ov, NULL);
4035 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
4036 "WSASend failed %d - %d\n", ret, WSAGetLastError());
4037
4038 WSASetLastError(12345);
4039 ret = WSASend(dst, &buf, 1, NULL, 0, &ov, NULL);
4040 ok(ret == SOCKET_ERROR && WSAGetLastError() == ERROR_IO_PENDING,
4041 "Failed to start overlapped send %d - %d\n", ret, WSAGetLastError());
4042
4043 end:
4044 if (src != INVALID_SOCKET)
4045 closesocket(src);
4046 if (dst != INVALID_SOCKET)
4047 closesocket(dst);
4048 if (hThread != NULL)
4049 CloseHandle(hThread);
4050 if (ov.hEvent)
4051 CloseHandle(ov.hEvent);
4052 HeapFree(GetProcessHeap(), 0, buffer);
4053 }
4054
4055 typedef struct async_message
4056 {
4057 SOCKET socket;
4058 LPARAM lparam;
4059 struct async_message *next;
4060 } async_message;
4061
4062 static struct async_message *messages_received;
4063
4064 #define WM_SOCKET (WM_USER+100)
4065 static LRESULT CALLBACK ws2_test_WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
4066 {
4067 struct async_message *message;
4068
4069 switch (msg)
4070 {
4071 case WM_SOCKET:
4072 message = HeapAlloc(GetProcessHeap(), 0, sizeof(*message));
4073 message->socket = (SOCKET) wparam;
4074 message->lparam = lparam;
4075 message->next = NULL;
4076
4077 if (messages_received)
4078 {
4079 struct async_message *last = messages_received;
4080 while (last->next) last = last->next;
4081 last->next = message;
4082 }
4083 else
4084 messages_received = message;
4085 return 0;
4086 }
4087
4088 return DefWindowProcA(hwnd, msg, wparam, lparam);
4089 }
4090
4091 static void get_event_details(int event, int *bit, char *name)
4092 {
4093 switch (event)
4094 {
4095 case FD_ACCEPT:
4096 if (bit) *bit = FD_ACCEPT_BIT;
4097 if (name) strcpy(name, "FD_ACCEPT");
4098 break;
4099 case FD_CONNECT:
4100 if (bit) *bit = FD_CONNECT_BIT;
4101 if (name) strcpy(name, "FD_CONNECT");
4102 break;
4103 case FD_READ:
4104 if (bit) *bit = FD_READ_BIT;
4105 if (name) strcpy(name, "FD_READ");
4106 break;
4107 case FD_OOB:
4108 if (bit) *bit = FD_OOB_BIT;
4109 if (name) strcpy(name, "FD_OOB");
4110 break;
4111 case FD_WRITE:
4112 if (bit) *bit = FD_WRITE_BIT;
4113 if (name) strcpy(name, "FD_WRITE");
4114 break;
4115 case FD_CLOSE:
4116 if (bit) *bit = FD_CLOSE_BIT;
4117 if (name) strcpy(name, "FD_CLOSE");
4118 break;
4119 default:
4120 if (bit) *bit = -1;
4121 if (name) sprintf(name, "bad%x", event);
4122 }
4123 }
4124
4125 static const char *dbgstr_event_seq(const LPARAM *seq)
4126 {
4127 static char message[1024];
4128 char name[12];
4129 int len = 1;
4130
4131 message[0] = '[';
4132 message[1] = 0;
4133 while (*seq)
4134 {
4135 get_event_details(WSAGETSELECTEVENT(*seq), NULL, name);
4136 len += sprintf(message + len, "%s(%d) ", name, WSAGETSELECTERROR(*seq));
4137 seq++;
4138 }
4139 if (len > 1) len--;
4140 strcpy( message + len, "]" );
4141 return message;
4142 }
4143
4144 static char *dbgstr_event_seq_result(SOCKET s, WSANETWORKEVENTS *netEvents)
4145 {
4146 static char message[1024];
4147 struct async_message *curr = messages_received;
4148 int index, error, bit = 0;
4149 char name[12];
4150 int len = 1;
4151
4152 message[0] = '[';
4153 message[1] = 0;
4154 while (1)
4155 {
4156 if (netEvents)
4157 {
4158 if (bit >= FD_MAX_EVENTS) break;
4159 if ( !(netEvents->lNetworkEvents & (1 << bit)) )
4160 {
4161 bit++;
4162 continue;
4163 }
4164 get_event_details(1 << bit, &index, name);
4165 error = netEvents->iErrorCode[index];
4166 bit++;
4167 }
4168 else
4169 {
4170 if (!curr) break;
4171 if (curr->socket != s)
4172 {
4173 curr = curr->next;
4174 continue;
4175 }
4176 get_event_details(WSAGETSELECTEVENT(curr->lparam), NULL, name);
4177 error = WSAGETSELECTERROR(curr->lparam);
4178 curr = curr->next;
4179 }
4180
4181 len += sprintf(message + len, "%s(%d) ", name, error);
4182 }
4183 if (len > 1) len--;
4184 strcpy( message + len, "]" );
4185 return message;
4186 }
4187
4188 static void flush_events(SOCKET s, HANDLE hEvent)
4189 {
4190 WSANETWORKEVENTS netEvents;
4191 struct async_message *prev = NULL, *curr = messages_received;
4192 int ret;
4193 DWORD dwRet;
4194
4195 if (hEvent != INVALID_HANDLE_VALUE)
4196 {
4197 dwRet = WaitForSingleObject(hEvent, 100);
4198 if (dwRet == WAIT_OBJECT_0)
4199 {
4200 ret = WSAEnumNetworkEvents(s, hEvent, &netEvents);
4201 if (ret)
4202 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
4203 }
4204 }
4205 else
4206 {
4207 while (curr)
4208 {
4209 if (curr->socket == s)
4210 {
4211 if (prev) prev->next = curr->next;
4212 else messages_received = curr->next;
4213
4214 HeapFree(GetProcessHeap(), 0, curr);
4215
4216 if (prev) curr = prev->next;
4217 else curr = messages_received;
4218 }
4219 else
4220 {
4221 prev = curr;
4222 curr = curr->next;
4223 }
4224 }
4225 }
4226 }
4227
4228 static int match_event_sequence(SOCKET s, WSANETWORKEVENTS *netEvents, const LPARAM *seq)
4229 {
4230 int event, index, error, events;
4231 struct async_message *curr;
4232
4233 if (netEvents)
4234 {
4235 events = netEvents->lNetworkEvents;
4236 while (*seq)
4237 {
4238 event = WSAGETSELECTEVENT(*seq);
4239 error = WSAGETSELECTERROR(*seq);
4240 get_event_details(event, &index, NULL);
4241
4242 if (!(events & event) && index != -1)
4243 return 0;
4244 if (events & event && index != -1)
4245 {
4246 if (netEvents->iErrorCode[index] != error)
4247 return 0;
4248 }
4249 events &= ~event;
4250 seq++;
4251 }
4252 if (events)
4253 return 0;
4254 }
4255 else
4256 {
4257 curr = messages_received;
4258 while (curr)
4259 {
4260 if (curr->socket == s)
4261 {
4262 if (!*seq) return 0;
4263 if (*seq != curr->lparam) return 0;
4264 seq++;
4265 }
4266 curr = curr->next;
4267 }
4268 if (*seq)
4269 return 0;
4270 }
4271 return 1;
4272 }
4273
4274 /* checks for a sequence of events, (order only checked if window is used) */
4275 static void ok_event_sequence(SOCKET s, HANDLE hEvent, const LPARAM *seq, const LPARAM **broken_seqs, int completelyBroken)
4276 {
4277 MSG msg;
4278 WSANETWORKEVENTS events, *netEvents = NULL;
4279 int ret;
4280 DWORD dwRet;
4281
4282 if (hEvent != INVALID_HANDLE_VALUE)
4283 {
4284 netEvents = &events;
4285
4286 dwRet = WaitForSingleObject(hEvent, 200);
4287 if (dwRet == WAIT_OBJECT_0)
4288 {
4289 ret = WSAEnumNetworkEvents(s, hEvent, netEvents);
4290 if (ret)
4291 {
4292 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
4293 return;
4294 }
4295 }
4296 else
4297 memset(netEvents, 0, sizeof(*netEvents));
4298 }
4299 else
4300 {
4301 Sleep(200);
4302 /* Run the message loop a little */
4303 while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
4304 {
4305 DispatchMessageA(&msg);
4306 }
4307 }
4308
4309 if (match_event_sequence(s, netEvents, seq))
4310 {
4311 winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq));
4312 flush_events(s, hEvent);
4313 return;
4314 }
4315
4316 if (broken_seqs)
4317 {
4318 for (; *broken_seqs; broken_seqs++)
4319 {
4320 if (match_event_sequence(s, netEvents, *broken_seqs))
4321 {
4322 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s, netEvents), dbgstr_event_seq(seq));
4323 flush_events(s, hEvent);
4324 return;
4325 }
4326 }
4327 }
4328
4329 winetest_ok(broken(completelyBroken), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq),
4330 dbgstr_event_seq_result(s, netEvents));
4331 flush_events(s, hEvent);
4332 }
4333
4334 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
4335
4336 static void test_events(int useMessages)
4337 {
4338 SOCKET server = INVALID_SOCKET;
4339 SOCKET src = INVALID_SOCKET, src2 = INVALID_SOCKET;
4340 SOCKET dst = INVALID_SOCKET, dst2 = INVALID_SOCKET;
4341 struct sockaddr_in addr;
4342 HANDLE hThread = NULL;
4343 HANDLE hEvent = INVALID_HANDLE_VALUE, hEvent2 = INVALID_HANDLE_VALUE;
4344 WNDCLASSEXA wndclass;
4345 HWND hWnd = NULL;
4346 char *buffer = NULL;
4347 int bufferSize = 1024*1024;
4348 WSABUF bufs;
4349 OVERLAPPED ov, ov2;
4350 DWORD flags = 0;
4351 DWORD bytesReturned;
4352 DWORD id;
4353 int len;
4354 int ret;
4355 DWORD dwRet;
4356 BOOL bret;
4357 static char szClassName[] = "wstestclass";
4358 const LPARAM *broken_seq[3];
4359 static const LPARAM empty_seq[] = { 0 };
4360 static const LPARAM close_seq[] = { WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
4361 static const LPARAM write_seq[] = { WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
4362 static const LPARAM read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0), 0 };
4363 static const LPARAM oob_seq[] = { WSAMAKESELECTREPLY(FD_OOB, 0), 0 };
4364 static const LPARAM connect_seq[] = { WSAMAKESELECTREPLY(FD_CONNECT, 0),
4365 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
4366 static const LPARAM read_read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
4367 WSAMAKESELECTREPLY(FD_READ, 0), 0 };
4368 static const LPARAM read_write_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
4369 WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
4370 static const LPARAM read_close_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
4371 WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
4372
4373 memset(&ov, 0, sizeof(ov));
4374 memset(&ov2, 0, sizeof(ov2));
4375
4376 /* don't use socketpair, we want connection event */
4377 src = socket(AF_INET, SOCK_STREAM, 0);
4378 if (src == INVALID_SOCKET)
4379 {
4380 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4381 goto end;
4382 }
4383
4384 ret = set_blocking(src, TRUE);
4385 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
4386
4387 src2 = socket(AF_INET, SOCK_STREAM, 0);
4388 if (src2 == INVALID_SOCKET)
4389 {
4390 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4391 goto end;
4392 }
4393
4394 ret = set_blocking(src2, TRUE);
4395 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
4396
4397 len = sizeof(BOOL);
4398 if (getsockopt(src, SOL_SOCKET, SO_OOBINLINE, (void *)&bret, &len) == SOCKET_ERROR)
4399 {
4400 ok(0, "failed to get oobinline status, %d\n", GetLastError());
4401 goto end;
4402 }
4403 ok(bret == FALSE, "OOB not inline\n");
4404
4405 if (useMessages)
4406 {
4407 trace("Event test using messages\n");
4408
4409 wndclass.cbSize = sizeof(wndclass);
4410 wndclass.style = CS_HREDRAW | CS_VREDRAW;
4411 wndclass.lpfnWndProc = ws2_test_WndProc;
4412 wndclass.cbClsExtra = 0;
4413 wndclass.cbWndExtra = 0;
4414 wndclass.hInstance = GetModuleHandleA(NULL);
4415 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
4416 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
4417 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
4418 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
4419 wndclass.lpszClassName = szClassName;
4420 wndclass.lpszMenuName = NULL;
4421 RegisterClassExA(&wndclass);
4422
4423 hWnd = CreateWindowA(szClassName, "WS2Test", WS_OVERLAPPEDWINDOW,
4424 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
4425 if (!hWnd)
4426 {
4427 ok(0, "failed to create window: %d\n", GetLastError());
4428 return;
4429 }
4430
4431 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
4432 if (ret)
4433 {
4434 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
4435 goto end;
4436 }
4437
4438 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
4439 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
4440
4441 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
4442 if (ret)
4443 {
4444 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
4445 goto end;
4446 }
4447
4448 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
4449 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
4450 }
4451 else
4452 {
4453 trace("Event test using events\n");
4454
4455 hEvent = WSACreateEvent();
4456 if (hEvent == INVALID_HANDLE_VALUE)
4457 {
4458 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
4459 goto end;
4460 }
4461
4462 hEvent2 = WSACreateEvent();
4463 if (hEvent2 == INVALID_HANDLE_VALUE)
4464 {
4465 ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
4466 goto end;
4467 }
4468
4469 ret = WSAEventSelect(src, hEvent, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
4470 if (ret)
4471 {
4472 ok(0, "WSAEventSelect failed, error %d\n", ret);
4473 goto end;
4474 }
4475
4476 ok(set_blocking(src, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
4477 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
4478
4479 ret = WSAEventSelect(src2, hEvent2, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
4480 if (ret)
4481 {
4482 ok(0, "WSAEventSelect failed, error %d\n", ret);
4483 goto end;
4484 }
4485
4486 ok(set_blocking(src2, TRUE) == SOCKET_ERROR, "set_blocking should failed!\n");
4487 ok(WSAGetLastError() == WSAEINVAL, "expect WSAEINVAL, returned %x\n", WSAGetLastError());
4488 }
4489
4490 server = socket(AF_INET, SOCK_STREAM, 0);
4491 if (server == INVALID_SOCKET)
4492 {
4493 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4494 goto end;
4495 }
4496
4497 memset(&addr, 0, sizeof(addr));
4498 addr.sin_family = AF_INET;
4499 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
4500 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
4501 if (ret != 0)
4502 {
4503 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4504 goto end;
4505 }
4506
4507 len = sizeof(addr);
4508 ret = getsockname(server, (struct sockaddr*)&addr, &len);
4509 if (ret != 0)
4510 {
4511 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4512 goto end;
4513 }
4514
4515 ret = listen(server, 2);
4516 if (ret != 0)
4517 {
4518 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4519 goto end;
4520 }
4521
4522 ret = connect(src, (struct sockaddr*)&addr, sizeof(addr));
4523 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
4524 {
4525 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4526 goto end;
4527 }
4528
4529 ret = connect(src2, (struct sockaddr*)&addr, sizeof(addr));
4530 if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
4531 {
4532 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4533 goto end;
4534 }
4535
4536 len = sizeof(addr);
4537 dst = accept(server, (struct sockaddr*)&addr, &len);
4538 if (dst == INVALID_SOCKET)
4539 {
4540 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4541 goto end;
4542 }
4543
4544 len = sizeof(addr);
4545 dst2 = accept(server, (struct sockaddr*)&addr, &len);
4546 if (dst2 == INVALID_SOCKET)
4547 {
4548 ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
4549 goto end;
4550 }
4551
4552 closesocket(server);
4553 server = INVALID_SOCKET;
4554
4555 /* On Windows it seems when a non-blocking socket sends to a
4556 blocking socket on the same host, the send() is BLOCKING,
4557 so make both sockets non-blocking. src is already non-blocking
4558 from the async select */
4559
4560 if (set_blocking(dst, FALSE))
4561 {
4562 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
4563 goto end;
4564 }
4565
4566 buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufferSize);
4567 if (buffer == NULL)
4568 {
4569 ok(0, "could not allocate memory for test\n");
4570 goto end;
4571 }
4572
4573 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
4574 if (ov.hEvent == NULL)
4575 {
4576 ok(0, "could not create event object, errno = %d\n", GetLastError());
4577 goto end;
4578 }
4579
4580 ov2.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
4581 if (ov2.hEvent == NULL)
4582 {
4583 ok(0, "could not create event object, errno = %d\n", GetLastError());
4584 goto end;
4585 }
4586
4587 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
4588 ok_event_seq(src, hEvent, connect_seq, NULL, 1);
4589 ok_event_seq(src2, hEvent2, connect_seq, NULL, 1);
4590 /* broken on all windows - FD_CONNECT error is garbage */
4591
4592 /* Test simple send/recv */
4593 ret = send(dst, buffer, 100, 0);
4594 ok(ret == 100, "Failed to send buffer %d err %d\n", ret, GetLastError());
4595 ok_event_seq(src, hEvent, read_seq, NULL, 0);
4596
4597 ret = recv(src, buffer, 1, MSG_PEEK);
4598 ok(ret == 1, "Failed to peek at recv buffer %d err %d\n", ret, GetLastError());
4599 ok_event_seq(src, hEvent, read_seq, NULL, 0);
4600
4601 ret = recv(src, buffer, 50, 0);
4602 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
4603 ok_event_seq(src, hEvent, read_seq, NULL, 0);
4604
4605 ret = recv(src, buffer, 50, 0);
4606 ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
4607 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
4608
4609 /* fun fact - events are re-enabled even on failure, but only for messages */
4610 ret = send(dst, "1", 1, 0);
4611 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
4612 ok_event_seq(src, hEvent, read_seq, NULL, 0);
4613
4614 ret = recv(src, buffer, -1, 0);
4615 ok(ret == SOCKET_ERROR && (GetLastError() == WSAEFAULT || GetLastError() == WSAENOBUFS),
4616 "Failed to recv buffer %d err %d\n", ret, GetLastError());
4617 if (useMessages)
4618 {
4619 broken_seq[0] = empty_seq; /* win9x */
4620 broken_seq[1] = NULL;
4621 todo_wine ok_event_seq(src, hEvent, read_seq, broken_seq, 0);
4622 }
4623 else
4624 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
4625
4626 ret = recv(src, buffer, 1, 0);
4627 ok(ret == 1, "Failed to recv buffer %d err %d\n", ret, GetLastError());
4628 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
4629
4630 /* Interaction with overlapped */
4631 bufs.len = sizeof(char);
4632 bufs.buf = buffer;
4633 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
4634 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
4635 "WSARecv failed - %d error %d\n", ret, GetLastError());
4636
4637 bufs.len = sizeof(char);
4638 bufs.buf = buffer+1;
4639 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov2, NULL);
4640 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
4641 "WSARecv failed - %d error %d\n", ret, GetLastError());
4642
4643 ret = send(dst, "12", 2, 0);
4644 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
4645 broken_seq[0] = read_read_seq; /* win9x */
4646 broken_seq[1] = NULL;
4647 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
4648
4649 dwRet = WaitForSingleObject(ov.hEvent, 100);
4650 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
4651 if (dwRet == WAIT_OBJECT_0)
4652 {
4653 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
4654 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
4655 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
4656 ok(buffer[0] == '1', "Got %c instead of 1\n", buffer[0]);
4657 }
4658
4659 dwRet = WaitForSingleObject(ov2.hEvent, 100);
4660 ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
4661 if (dwRet == WAIT_OBJECT_0)
4662 {
4663 bret = GetOverlappedResult((HANDLE)src, &ov2, &bytesReturned, FALSE);
4664 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
4665 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
4666 ok(buffer[1] == '2', "Got %c instead of 2\n", buffer[1]);
4667 }
4668
4669 ret = send(dst, "1", 1, 0);
4670 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
4671 ok_event_seq(src, hEvent, read_seq, NULL, 0);
4672
4673 ret = recv(src, buffer, 1, 0);
4674 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
4675 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
4676
4677 /* Notifications are delivered as soon as possible, blocked only on
4678 * async requests on the same type */
4679 bufs.len = sizeof(char);
4680 bufs.buf = buffer;
4681 ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
4682 ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
4683 "WSARecv failed - %d error %d\n", ret, GetLastError());
4684
4685 if (0) {
4686 ret = send(dst, "1", 1, MSG_OOB);
4687 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
4688 ok_event_seq(src, hEvent, oob_seq, NULL, 0);
4689 }
4690
4691 dwRet = WaitForSingleObject(ov.hEvent, 100);
4692 ok(dwRet == WAIT_TIMEOUT, "OOB message activated read?: %d - %d\n", dwRet, GetLastError());
4693
4694 ret = send(dst, "2", 1, 0);
4695 ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
4696 broken_seq[0] = read_seq; /* win98 */
4697 broken_seq[1] = NULL;
4698 ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
4699
4700 dwRet = WaitForSingleObject(ov.hEvent, 100);
4701 ok(dwRet == WAIT_OBJECT_0 || broken(dwRet == WAIT_TIMEOUT),
4702 "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
4703 if (dwRet == WAIT_OBJECT_0)
4704 {
4705 bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
4706 ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
4707 "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
4708 ok(buffer[0] == '2', "Got %c instead of 2\n", buffer[0]);
4709 }
4710 else if (dwRet == WAIT_TIMEOUT)
4711 {
4712 /* this happens on win98. We get an FD_READ later on the next test */
4713 CancelIo((HANDLE) src);
4714 }
4715
4716 if (0) {
4717 ret = recv(src, buffer, 1, MSG_OOB);
4718 todo_wine ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
4719 /* We get OOB notification, but no data on wine */
4720 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
4721 }
4722
4723 /* Flood the send queue */
4724 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
4725 if (hThread == NULL)
4726 {
4727 ok(0, "CreateThread failed, error %d\n", GetLastError());
4728 goto end;
4729 }
4730
4731 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
4732 ok_event_seq(src, hEvent, empty_seq, NULL, 0);
4733
4734 /* Now if we send a ton of data and the 'server' does not drain it fast
4735 * enough (set drain_pause to be sure), the socket send buffer will only
4736 * take some of it, and we will get a short write. This will trigger
4737 * another FD_WRITE event as soon as data is sent and more space becomes
4738 * available, but not any earlier. */
4739 drain_pause = TRUE;
4740 do
4741 {
4742 ret = send(src, buffer, bufferSize, 0);
4743 } while (ret == bufferSize);
4744 drain_pause = FALSE;
4745 if (ret >= 0 || WSAGetLastError() == WSAEWOULDBLOCK)
4746 {
4747 Sleep(400); /* win9x */
4748 broken_seq[0] = read_write_seq;
4749 broken_seq[1] = NULL;
4750 ok_event_seq(src, hEvent, write_seq, broken_seq, 0);
4751 }
4752 else
4753 {
4754 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
4755 }
4756
4757 /* Test how FD_CLOSE is handled */
4758 ret = send(dst, "12", 2, 0);
4759 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
4760
4761 /* Wait a little and let the send complete */
4762 Sleep(100);
4763 closesocket(dst);
4764 dst = INVALID_SOCKET;
4765 Sleep(100);
4766
4767 /* We can never implement this in wine, best we can hope for is
4768 sending FD_CLOSE after the reads complete */
4769 broken_seq[0] = read_seq; /* win9x */
4770 broken_seq[1] = NULL;
4771 todo_wine ok_event_seq(src, hEvent, read_close_seq, broken_seq, 0);
4772
4773 ret = recv(src, buffer, 1, 0);
4774 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
4775 ok_event_seq(src, hEvent, read_seq, NULL, 0);
4776
4777 ret = recv(src, buffer, 1, 0);
4778 ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
4779 /* want it? it's here, but you can't have it */
4780 broken_seq[0] = close_seq; /* win9x */
4781 broken_seq[1] = NULL;
4782 todo_wine ok_event_seq(src, hEvent, empty_seq, /* wine sends FD_CLOSE here */
4783 broken_seq, 0);
4784
4785 /* Test how FD_CLOSE is handled */
4786 ret = send(dst2, "12", 2, 0);
4787 ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
4788
4789 Sleep(200);
4790 shutdown(dst2, SD_SEND);
4791 Sleep(200);
4792
4793 /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
4794 regressions, don't mark them as todo_wine, and mark windows as broken */
4795 broken_seq[0] = read_close_seq;
4796 broken_seq[1] = close_seq;
4797 broken_seq[2] = NULL;
4798 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
4799
4800 ret = recv(src2, buffer, 1, 0);
4801 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
4802 broken_seq[0] = close_seq; /* win98 */
4803 broken_seq[1] = NULL;
4804 ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
4805
4806 ret = recv(src2, buffer, 1, 0);
4807 ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
4808 broken_seq[0] = empty_seq;
4809 broken_seq[1] = NULL;
4810 ok_event_seq(src2, hEvent2, close_seq, broken_seq, 0);
4811
4812 ret = send(src2, "1", 1, 0);
4813 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
4814 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
4815
4816 ret = send(src2, "1", 1, 0);
4817 ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
4818 ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
4819
4820 if (useMessages)
4821 {
4822 ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, 0);
4823 if (ret)
4824 {
4825 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
4826 goto end;
4827 }
4828
4829 ret = set_blocking(src, TRUE);
4830 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
4831
4832 ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, 0);
4833 if (ret)
4834 {
4835 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
4836 goto end;
4837 }
4838
4839 ret = set_blocking(src2, TRUE);
4840 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
4841 }
4842 else
4843 {
4844 ret = WSAEventSelect(src, hEvent2, 0);
4845 if (ret)
4846 {
4847 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
4848 goto end;
4849 }
4850
4851 ret = set_blocking(src, TRUE);
4852 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
4853
4854 ret = WSAEventSelect(src2, hEvent2, 0);
4855 if (ret)
4856 {
4857 ok(0, "WSAAsyncSelect failed, error %d\n", ret);
4858 goto end;
4859 }
4860
4861 ret = set_blocking(src2, TRUE);
4862 ok(!ret, "set_blocking failed, error %d\n", WSAGetLastError());
4863 }
4864
4865 end:
4866 if (src != INVALID_SOCKET)
4867 {
4868 flush_events(src, hEvent);
4869 closesocket(src);
4870 }
4871 if (src2 != INVALID_SOCKET)
4872 {
4873 flush_events(src2, hEvent2);
4874 closesocket(src2);
4875 }
4876 HeapFree(GetProcessHeap(), 0, buffer);
4877 if (server != INVALID_SOCKET)
4878 closesocket(server);
4879 if (dst != INVALID_SOCKET)
4880 closesocket(dst);
4881 if (dst2 != INVALID_SOCKET)
4882 closesocket(dst2);
4883 if (hThread != NULL)
4884 CloseHandle(hThread);
4885 if (hWnd != NULL)
4886 DestroyWindow(hWnd);
4887 if (hEvent != NULL)
4888 CloseHandle(hEvent);
4889 if (hEvent2 != NULL)
4890 CloseHandle(hEvent2);
4891 if (ov.hEvent != NULL)
4892 CloseHandle(ov.hEvent);
4893 if (ov2.hEvent != NULL)
4894 CloseHandle(ov2.hEvent);
4895 }
4896
4897 static void test_ipv6only(void)
4898 {
4899 SOCKET v4 = INVALID_SOCKET,
4900 v6 = INVALID_SOCKET;
4901 struct sockaddr_in sin4;
4902 struct sockaddr_in6 sin6;
4903 int ret;
4904
4905 memset(&sin4, 0, sizeof(sin4));
4906 sin4.sin_family = AF_INET;
4907 sin4.sin_port = htons(SERVERPORT);
4908
4909 memset(&sin6, 0, sizeof(sin6));
4910 sin6.sin6_family = AF_INET6;
4911 sin6.sin6_port = htons(SERVERPORT);
4912
4913 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
4914 if (v6 == INVALID_SOCKET) {
4915 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
4916 WSAGetLastError(), WSAEAFNOSUPPORT);
4917 goto end;
4918 }
4919 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
4920 if (ret) {
4921 skip("Could not bind IPv6 address (LastError: %d).\n",
4922 WSAGetLastError());
4923 goto end;
4924 }
4925
4926 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
4927 if (v4 == INVALID_SOCKET) {
4928 skip("Could not create IPv4 socket (LastError: %d).\n",
4929 WSAGetLastError());
4930 goto end;
4931 }
4932 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
4933 ok(!ret, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
4934 WSAGetLastError(), WSAEADDRINUSE);
4935
4936 end:
4937 if (v4 != INVALID_SOCKET)
4938 closesocket(v4);
4939 if (v6 != INVALID_SOCKET)
4940 closesocket(v6);
4941 }
4942
4943 static void test_WSASendMsg(void)
4944 {
4945 SOCKET sock, dst;
4946 struct sockaddr_in sendaddr, sockaddr;
4947 GUID WSASendMsg_GUID = WSAID_WSASENDMSG;
4948 LPFN_WSASENDMSG pWSASendMsg = NULL;
4949 char teststr[12] = "hello world", buffer[32];
4950 WSABUF iovec[2];
4951 WSAMSG msg;
4952 DWORD bytesSent, err;
4953 int ret, addrlen;
4954
4955 /* FIXME: Missing OVERLAPPED and OVERLAPPED COMPLETION ROUTINE tests */
4956
4957 sock = socket(AF_INET, SOCK_DGRAM, 0);
4958 ok(sock != INVALID_SOCKET, "socket() failed\n");
4959
4960 /* Obtain the WSASendMsg function */
4961 WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &WSASendMsg_GUID, sizeof(WSASendMsg_GUID),
4962 &pWSASendMsg, sizeof(pWSASendMsg), &err, NULL, NULL);
4963 if (!pWSASendMsg)
4964 {
4965 closesocket(sock);
4966 win_skip("WSASendMsg is unsupported, some tests will be skipped.\n");
4967 return;
4968 }
4969
4970 /* fake address for now */
4971 sendaddr.sin_family = AF_INET;
4972 sendaddr.sin_port = htons(139);
4973 sendaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
4974
4975 memset(&msg, 0, sizeof(msg));
4976 iovec[0].buf = teststr;
4977 iovec[0].len = sizeof(teststr);
4978 iovec[1].buf = teststr;
4979 iovec[1].len = sizeof(teststr) / 2;
4980 msg.name = (struct sockaddr *) &sendaddr;
4981 msg.namelen = sizeof(sendaddr);
4982 msg.lpBuffers = iovec;
4983 msg.dwBufferCount = 1; /* send only one buffer for now */
4984
4985 WSASetLastError(0xdeadbeef);
4986 ret = pWSASendMsg(INVALID_SOCKET, &msg, 0, NULL, NULL, NULL);
4987 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
4988 err = WSAGetLastError();
4989 ok(err == WSAENOTSOCK, "expected 10038, got %d instead\n", err);
4990
4991 WSASetLastError(0xdeadbeef);
4992 ret = pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL);
4993 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
4994 err = WSAGetLastError();
4995 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
4996
4997 WSASetLastError(0xdeadbeef);
4998 ret = pWSASendMsg(sock, NULL, 0, &bytesSent, NULL, NULL);
4999 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5000 err = WSAGetLastError();
5001 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
5002
5003 WSASetLastError(0xdeadbeef);
5004 ret = pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL);
5005 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5006 err = WSAGetLastError();
5007 ok(err == WSAEFAULT, "expected 10014, got %d instead\n", err);
5008
5009 closesocket(sock);
5010
5011 sock = socket(AF_INET, SOCK_DGRAM, 0);
5012 ok(sock != INVALID_SOCKET, "socket() failed\n");
5013
5014 dst = socket(AF_INET, SOCK_DGRAM, 0);
5015 ok(dst != INVALID_SOCKET, "socket() failed\n");
5016
5017 memset(&sockaddr, 0, sizeof(sockaddr));
5018 sockaddr.sin_family = AF_INET;
5019 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5020 ok(!bind(dst, (struct sockaddr*)&sockaddr, sizeof(sockaddr)),
5021 "bind should have worked\n");
5022
5023 /* read address to find out the port number to be used in send */
5024 memset(&sendaddr, 0, sizeof(sendaddr));
5025 addrlen = sizeof(sendaddr);
5026 ok(!getsockname(dst, (struct sockaddr *) &sendaddr, &addrlen),
5027 "getsockname should have worked\n");
5028 ok(sendaddr.sin_port, "socket port should be != 0\n");
5029
5030 /* ensure the sending socket is not bound */
5031 WSASetLastError(0xdeadbeef);
5032 addrlen = sizeof(sockaddr);
5033 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
5034 ok(ret == SOCKET_ERROR, "getsockname should have failed\n");
5035 err = WSAGetLastError();
5036 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
5037
5038 set_blocking(sock, TRUE);
5039
5040 bytesSent = 0;
5041 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
5042 ok(!ret, "WSASendMsg should have worked\n");
5043 ok(bytesSent == iovec[0].len, "incorret bytes sent, expected %d, sent %d\n",
5044 iovec[0].len, bytesSent);
5045
5046 /* receive data */
5047 addrlen = sizeof(sockaddr);
5048 memset(buffer, 0, sizeof(buffer));
5049 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
5050 ok(ret == bytesSent, "got %d, expected %d\n",
5051 ret, bytesSent);
5052
5053 /* A successful call to WSASendMsg must have bound the socket */
5054 addrlen = sizeof(sockaddr);
5055 sockaddr.sin_port = 0;
5056 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5057 ret = getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen);
5058 ok(!ret, "getsockname should have worked\n");
5059 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
5060 inet_ntoa(sockaddr.sin_addr));
5061 ok(sockaddr.sin_port, "sin_port should be != 0\n");
5062
5063 msg.dwBufferCount = 2; /* send both buffers */
5064
5065 bytesSent = 0;
5066 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
5067 ok(!ret, "WSASendMsg should have worked\n");
5068 ok(bytesSent == iovec[0].len + iovec[1].len, "incorret bytes sent, expected %d, sent %d\n",
5069 iovec[0].len + iovec[1].len, bytesSent);
5070
5071 /* receive data */
5072 addrlen = sizeof(sockaddr);
5073 memset(buffer, 0, sizeof(buffer));
5074 ret = recvfrom(dst, buffer, sizeof(buffer), 0, (struct sockaddr *) &sockaddr, &addrlen);
5075 ok(ret == bytesSent, "got %d, expected %d\n",
5076 ret, bytesSent);
5077
5078 closesocket(sock);
5079 closesocket(dst);
5080
5081 /* a bad call to WSASendMsg will also bind the socket */
5082 addrlen = sizeof(sockaddr);
5083 sockaddr.sin_port = 0;
5084 sockaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
5085 sock = socket(AF_INET, SOCK_DGRAM, 0);
5086 ok(sock != INVALID_SOCKET, "socket() failed\n");
5087 ok(pWSASendMsg(sock, &msg, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
5088 todo_wine {
5089 ok(!getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have worked\n");
5090 ok(sockaddr.sin_addr.s_addr == htonl(INADDR_ANY), "expected 0.0.0.0, got %s\n",
5091 inet_ntoa(sockaddr.sin_addr));
5092 ok(sockaddr.sin_port, "sin_port should be > 0\n");
5093 }
5094 closesocket(sock);
5095
5096 /* a bad call without msg parameter will not trigger the auto-bind */
5097 sock = socket(AF_INET, SOCK_DGRAM, 0);
5098 ok(sock != INVALID_SOCKET, "socket() failed\n");
5099 ok(pWSASendMsg(sock, NULL, 0, NULL, NULL, NULL) == SOCKET_ERROR, "WSASendMsg should have failed\n");
5100 ok(getsockname(sock, (struct sockaddr*)&sockaddr, &addrlen), "getsockname should have failed\n");
5101 err = WSAGetLastError();
5102 ok(err == WSAEINVAL, "expected 10022, got %d instead\n", err);
5103 closesocket(sock);
5104
5105 /* SOCK_STREAM sockets are not supported */
5106 bytesSent = 0;
5107 sock = socket(AF_INET, SOCK_STREAM, 0);
5108 ok(sock != INVALID_SOCKET, "socket() failed\n");
5109 SetLastError(0xdeadbeef);
5110 ret = pWSASendMsg(sock, &msg, 0, &bytesSent, NULL, NULL);
5111 ok(ret == SOCKET_ERROR, "WSASendMsg should have failed\n");
5112 err = WSAGetLastError();
5113 todo_wine
5114 ok(err == WSAEINVAL, "expected 10014, got %d instead\n", err);
5115 closesocket(sock);
5116 }
5117
5118 static void test_WSASendTo(void)
5119 {
5120 SOCKET s;
5121 struct sockaddr_in addr;
5122 char buf[12] = "hello world";
5123 WSABUF data_buf;
5124 DWORD bytesSent;
5125 int ret;
5126
5127 addr.sin_family = AF_INET;
5128 addr.sin_port = htons(139);
5129 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
5130 data_buf.len = sizeof(buf);
5131 data_buf.buf = buf;
5132
5133 if( (s = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
5134 ok(0, "socket() failed error: %d\n", WSAGetLastError());
5135 return;
5136 }
5137
5138 WSASetLastError(12345);
5139 ret = WSASendTo(INVALID_SOCKET, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
5140 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK,
5141 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
5142
5143 WSASetLastError(12345);
5144 ret = WSASendTo(s, &data_buf, 1, NULL, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL);
5145 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
5146 "WSASendTo() failed: %d/%d\n", ret, WSAGetLastError());
5147
5148 WSASetLastError(12345);
5149 if(WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL)) {
5150 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
5151 return;
5152 }
5153 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
5154 "a successful call to WSASendTo()\n");
5155 }
5156
5157 static DWORD WINAPI recv_thread(LPVOID arg)
5158 {
5159 SOCKET sock = *(SOCKET *)arg;
5160 char buffer[32];
5161 WSABUF wsa;
5162 WSAOVERLAPPED ov;
5163 DWORD flags = 0;
5164
5165 wsa.buf = buffer;
5166 wsa.len = sizeof(buffer);
5167 ov.hEvent = WSACreateEvent();
5168 WSARecv(sock, &wsa, 1, NULL, &flags, &ov, NULL);
5169
5170 WaitForSingleObject(ov.hEvent, 1000);
5171 WSACloseEvent(ov.hEvent);
5172 return 0;
5173 }
5174
5175 static void test_WSARecv(void)
5176 {
5177 SOCKET src, dest, server = INVALID_SOCKET;
5178 char buf[20];
5179 WSABUF bufs;
5180 WSAOVERLAPPED ov;
5181 DWORD bytesReturned, flags, id;
5182 struct linger ling;
5183 struct sockaddr_in addr;
5184 int iret, len;
5185 DWORD dwret;
5186 BOOL bret;
5187 HANDLE thread;
5188
5189 memset(&ov, 0, sizeof(ov));
5190
5191 tcp_socketpair(&src, &dest);
5192 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
5193 {
5194 skip("failed to create sockets\n");
5195 goto end;
5196 }
5197
5198 bufs.len = sizeof(buf);
5199 bufs.buf = buf;
5200 flags = 0;
5201
5202 ov.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5203 ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
5204 if (!ov.hEvent)
5205 goto end;
5206
5207 ling.l_onoff = 1;
5208 ling.l_linger = 0;
5209 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
5210 ok(!iret, "Failed to set linger %d\n", GetLastError());
5211
5212 iret = WSARecv(dest, &bufs, 1, NULL, &flags, &ov, NULL);
5213 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
5214
5215 iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
5216 ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
5217
5218 closesocket(src);
5219 src = INVALID_SOCKET;
5220
5221 dwret = WaitForSingleObject(ov.hEvent, 1000);
5222 ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %d + errno %d\n", dwret, GetLastError());
5223
5224 bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
5225 todo_wine ok(!bret && (GetLastError() == ERROR_NETNAME_DELETED || broken(GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */),
5226 "Did not get disconnect event: %d, error %d\n", bret, GetLastError());
5227 ok(bytesReturned == 0, "Bytes received is %d\n", bytesReturned);
5228 closesocket(dest);
5229 dest = INVALID_SOCKET;
5230
5231 src = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, 0);
5232 ok(src != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
5233 if (src == INVALID_SOCKET) goto end;
5234
5235 server = WSASocketW(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
5236 ok(server != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
5237 if (server == INVALID_SOCKET) goto end;
5238
5239 memset(&addr, 0, sizeof(addr));
5240 addr.sin_family = AF_INET;
5241 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
5242 iret = bind(server, (struct sockaddr *)&addr, sizeof(addr));
5243 if (iret) goto end;
5244
5245 len = sizeof(addr);
5246 iret = getsockname(server, (struct sockaddr *)&addr, &len);
5247 if (iret) goto end;
5248
5249 iret = listen(server, 1);
5250 if (iret) goto end;
5251
5252 iret = connect(src, (struct sockaddr *)&addr, sizeof(addr));
5253 if (iret) goto end;
5254
5255 len = sizeof(addr);
5256 dest = accept(server, (struct sockaddr *)&addr, &len);
5257 ok(dest != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError());
5258 if (dest == INVALID_SOCKET) goto end;
5259
5260 send(src, "test message", sizeof("test message"), 0);
5261 thread = CreateThread(NULL, 0, recv_thread, &dest, 0, &id);
5262 CloseHandle(thread);
5263
5264 end:
5265 if (server != INVALID_SOCKET)
5266 closesocket(server);
5267 if (dest != INVALID_SOCKET)
5268 closesocket(dest);
5269 if (src != INVALID_SOCKET)
5270 closesocket(src);
5271 if (ov.hEvent)
5272 WSACloseEvent(ov.hEvent);
5273 }
5274
5275 static void test_GetAddrInfoW(void)
5276 {
5277 static const WCHAR port[] = {'8','0',0};
5278 static const WCHAR empty[] = {0};
5279 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
5280 static const WCHAR nxdomain[] =
5281 {'n','x','d','o','m','a','i','n','.','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0};
5282 static const WCHAR zero[] = {'0',0};
5283 int ret;
5284 ADDRINFOW *result, hint;
5285
5286 if (!pGetAddrInfoW || !pFreeAddrInfoW)
5287 {
5288 win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
5289 return;
5290 }
5291 memset(&hint, 0, sizeof(ADDRINFOW));
5292
5293 result = (ADDRINFOW *)0xdeadbeef;
5294 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
5295 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
5296 ok(result == NULL, "got %p\n", result);
5297
5298 result = NULL;
5299 ret = pGetAddrInfoW(empty, NULL, NULL, &result);
5300 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5301 ok(result != NULL, "GetAddrInfoW failed\n");
5302 pFreeAddrInfoW(result);
5303
5304 result = NULL;
5305 ret = pGetAddrInfoW(NULL, zero, NULL, &result);
5306 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5307 ok(result != NULL, "GetAddrInfoW failed\n");
5308 pFreeAddrInfoW(result);
5309
5310 result = NULL;
5311 ret = pGetAddrInfoW(empty, zero, NULL, &result);
5312 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5313 ok(result != NULL, "GetAddrInfoW failed\n");
5314 pFreeAddrInfoW(result);
5315
5316 result = NULL;
5317 ret = pGetAddrInfoW(localhost, NULL, NULL, &result);
5318 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5319 pFreeAddrInfoW(result);
5320
5321 result = NULL;
5322 ret = pGetAddrInfoW(localhost, empty, NULL, &result);
5323 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5324 pFreeAddrInfoW(result);
5325
5326 result = NULL;
5327 ret = pGetAddrInfoW(localhost, zero, NULL, &result);
5328 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5329 pFreeAddrInfoW(result);
5330
5331 result = NULL;
5332 ret = pGetAddrInfoW(localhost, port, NULL, &result);
5333 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5334 pFreeAddrInfoW(result);
5335
5336 result = NULL;
5337 ret = pGetAddrInfoW(localhost, NULL, &hint, &result);
5338 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5339 pFreeAddrInfoW(result);
5340
5341 result = NULL;
5342 ret = pGetAddrInfoW(localhost, port, &hint, &result);
5343 ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
5344 pFreeAddrInfoW(result);
5345
5346 result = (ADDRINFOW *)0xdeadbeef;
5347 ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
5348 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
5349 ok(result == NULL, "got %p\n", result);
5350
5351 result = (ADDRINFOW *)0xdeadbeef;
5352 ret = pGetAddrInfoW(nxdomain, NULL, NULL, &result);
5353 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
5354 ok(result == NULL, "got %p\n", result);
5355 }
5356
5357 static void test_getaddrinfo(void)
5358 {
5359 int ret;
5360 ADDRINFOA *result, hint;
5361
5362 if (!pgetaddrinfo || !pfreeaddrinfo)
5363 {
5364 win_skip("getaddrinfo and/or freeaddrinfo not present\n");
5365 return;
5366 }
5367 memset(&hint, 0, sizeof(ADDRINFOA));
5368
5369 result = (ADDRINFOA *)0xdeadbeef;
5370 ret = pgetaddrinfo(NULL, NULL, NULL, &result);
5371 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
5372 ok(result == NULL, "got %p\n", result);
5373
5374 result = NULL;
5375 ret = pgetaddrinfo("", NULL, NULL, &result);
5376 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
5377 ok(result != NULL, "getaddrinfo failed\n");
5378 pfreeaddrinfo(result);
5379
5380 result = NULL;
5381 ret = pgetaddrinfo(NULL, "0", NULL, &result);
5382 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
5383 ok(result != NULL, "getaddrinfo failed\n");
5384 pfreeaddrinfo(result);
5385
5386 result = NULL;
5387 ret = pgetaddrinfo("", "0", NULL, &result);
5388 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
5389 ok(result != NULL, "getaddrinfo failed\n");
5390 pfreeaddrinfo(result);
5391
5392 result = NULL;
5393 ret = pgetaddrinfo("localhost", NULL, NULL, &result);
5394 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
5395 pfreeaddrinfo(result);
5396
5397 result = NULL;
5398 ret = pgetaddrinfo("localhost", "", NULL, &result);
5399 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
5400 pfreeaddrinfo(result);
5401
5402 result = NULL;
5403 ret = pgetaddrinfo("localhost", "0", NULL, &result);
5404 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
5405 pfreeaddrinfo(result);
5406
5407 result = NULL;
5408 ret = pgetaddrinfo("localhost", "80", NULL, &result);
5409 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
5410 pfreeaddrinfo(result);
5411
5412 result = NULL;
5413 ret = pgetaddrinfo("localhost", NULL, &hint, &result);
5414 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
5415 pfreeaddrinfo(result);
5416
5417 result = NULL;
5418 ret = pgetaddrinfo("localhost", "80", &hint, &result);
5419 ok(!ret, "getaddrinfo failed with %d\n", WSAGetLastError());
5420 pfreeaddrinfo(result);
5421
5422 result = (ADDRINFOA *)0xdeadbeef;
5423 ret = pgetaddrinfo("nxdomain.codeweavers.com", NULL, NULL, &result);
5424 ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
5425 ok(result == NULL, "got %p\n", result);
5426 }
5427
5428 static void test_ConnectEx(void)
5429 {
5430 SOCKET listener = INVALID_SOCKET;
5431 SOCKET acceptor = INVALID_SOCKET;
5432 SOCKET connector = INVALID_SOCKET;
5433 struct sockaddr_in address, conaddress;
5434 int addrlen;
5435 OVERLAPPED overlapped;
5436 LPFN_CONNECTEX pConnectEx;
5437 GUID connectExGuid = WSAID_CONNECTEX;
5438 DWORD bytesReturned;
5439 char buffer[1024];
5440 BOOL bret;
5441 DWORD dwret;
5442 int iret;
5443
5444 memset(&overlapped, 0, sizeof(overlapped));
5445
5446 listener = socket(AF_INET, SOCK_STREAM, 0);
5447 if (listener == INVALID_SOCKET) {
5448 skip("could not create listener socket, error %d\n", WSAGetLastError());
5449 goto end;
5450 }
5451
5452 connector = socket(AF_INET, SOCK_STREAM, 0);
5453 if (connector == INVALID_SOCKET) {
5454 skip("could not create connector socket, error %d\n", WSAGetLastError());
5455 goto end;
5456 }
5457
5458 memset(&address, 0, sizeof(address));
5459 address.sin_family = AF_INET;
5460 address.sin_addr.s_addr = inet_addr("127.0.0.1");
5461 iret = bind(listener, (struct sockaddr*)&address, sizeof(address));
5462 if (iret != 0) {
5463 skip("failed to bind, error %d\n", WSAGetLastError());
5464 goto end;
5465 }
5466
5467 addrlen = sizeof(address);
5468 iret = getsockname(listener, (struct sockaddr*)&address, &addrlen);
5469 if (iret != 0) {
5470 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
5471 goto end;
5472 }
5473
5474 if (set_blocking(listener, TRUE)) {
5475 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
5476 goto end;
5477 }
5478
5479 iret = WSAIoctl(connector, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectExGuid, sizeof(connectExGuid),
5480 &pConnectEx, sizeof(pConnectEx), &bytesReturned, NULL, NULL);
5481 if (iret) {
5482 win_skip("WSAIoctl failed to get ConnectEx with ret %d + errno %d\n", iret, WSAGetLastError());
5483 goto end;
5484 }
5485
5486 bret = pConnectEx(INVALID_SOCKET, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
5487 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "ConnectEx on invalid socket "
5488 "returned %d + errno %d\n", bret, WSAGetLastError());
5489
5490 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
5491 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "ConnectEx on a unbound socket "
5492 "returned %d + errno %d\n", bret, WSAGetLastError());
5493 if (bret == TRUE || WSAGetLastError() != WSAEINVAL)
5494 {
5495 acceptor = accept(listener, NULL, NULL);
5496 if (acceptor != INVALID_SOCKET) {
5497 closesocket(acceptor);
5498 acceptor = INVALID_SOCKET;
5499 }
5500
5501 closesocket(connector);
5502 connector = socket(AF_INET, SOCK_STREAM, 0);
5503 if (connector == INVALID_SOCKET) {
5504 skip("could not create connector socket, error %d\n", WSAGetLastError());
5505 goto end;
5506 }
5507 }
5508
5509 /* ConnectEx needs a bound socket */
5510 memset(&conaddress, 0, sizeof(conaddress));
5511 conaddress.sin_family = AF_INET;
5512 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
5513 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
5514 if (iret != 0) {
5515 skip("failed to bind, error %d\n", WSAGetLastError());
5516 goto end;
5517 }
5518
5519 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, NULL);
5520 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "ConnectEx on a NULL overlapped "
5521 "returned %d + errno %d\n", bret, WSAGetLastError());
5522
5523 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5524 if (overlapped.hEvent == NULL) {
5525 skip("could not create event object, errno = %d\n", GetLastError());
5526 goto end;
5527 }
5528
5529 iret = listen(listener, 1);
5530 if (iret != 0) {
5531 skip("listening failed, errno = %d\n", WSAGetLastError());
5532 goto end;
5533 }
5534
5535 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
5536 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
5537 "returned %d + errno %d\n", bret, WSAGetLastError());
5538 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
5539 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
5540
5541 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
5542 ok(bret, "Connecting failed, error %d\n", GetLastError());
5543 ok(bytesReturned == 0, "Bytes sent is %d\n", bytesReturned);
5544
5545 closesocket(connector);
5546 connector = socket(AF_INET, SOCK_STREAM, 0);
5547 if (connector == INVALID_SOCKET) {
5548 skip("could not create connector socket, error %d\n", WSAGetLastError());
5549 goto end;
5550 }
5551 /* ConnectEx needs a bound socket */
5552 memset(&conaddress, 0, sizeof(conaddress));
5553 conaddress.sin_family = AF_INET;
5554 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
5555 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
5556 if (iret != 0) {
5557 skip("failed to bind, error %d\n", WSAGetLastError());
5558 goto end;
5559 }
5560
5561 acceptor = accept(listener, NULL, NULL);
5562 if (acceptor != INVALID_SOCKET) {
5563 closesocket(acceptor);
5564 }
5565
5566 buffer[0] = '1';
5567 buffer[1] = '2';
5568 buffer[2] = '3';
5569 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, buffer, 3, &bytesReturned, &overlapped);
5570 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "ConnectEx failed: "
5571 "returned %d + errno %d\n", bret, WSAGetLastError());
5572 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
5573 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
5574
5575 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
5576 ok(bret, "Connecting failed, error %d\n", GetLastError());
5577 ok(bytesReturned == 3, "Bytes sent is %d\n", bytesReturned);
5578
5579 acceptor = accept(listener, NULL, NULL);
5580 ok(acceptor != INVALID_SOCKET, "could not accept socket error %d\n", WSAGetLastError());
5581
5582 bytesReturned = recv(acceptor, buffer, 3, 0);
5583 buffer[4] = 0;
5584 ok(bytesReturned == 3, "Didn't get all sent data, got only %d\n", bytesReturned);
5585 ok(buffer[0] == '1' && buffer[1] == '2' && buffer[2] == '3',
5586 "Failed to get the right data, expected '123', got '%s'\n", buffer);
5587
5588 closesocket(connector);
5589 connector = socket(AF_INET, SOCK_STREAM, 0);
5590 if (connector == INVALID_SOCKET) {
5591 skip("could not create connector socket, error %d\n", WSAGetLastError());
5592 goto end;
5593 }
5594 /* ConnectEx needs a bound socket */
5595 memset(&conaddress, 0, sizeof(conaddress));
5596 conaddress.sin_family = AF_INET;
5597 conaddress.sin_addr.s_addr = inet_addr("127.0.0.1");
5598 iret = bind(connector, (struct sockaddr*)&conaddress, sizeof(conaddress));
5599 if (iret != 0) {
5600 skip("failed to bind, error %d\n", WSAGetLastError());
5601 goto end;
5602 }
5603
5604 if (acceptor != INVALID_SOCKET) {
5605 closesocket(acceptor);
5606 acceptor = INVALID_SOCKET;
5607 }
5608
5609 /* Connect with error */
5610 closesocket(listener);
5611 listener = INVALID_SOCKET;
5612
5613 address.sin_port = htons(1);
5614
5615 bret = pConnectEx(connector, (struct sockaddr*)&address, addrlen, NULL, 0, &bytesReturned, &overlapped);
5616 ok(bret == FALSE && GetLastError(), "ConnectEx to bad destination failed: "
5617 "returned %d + errno %d\n", bret, GetLastError());
5618
5619 if (GetLastError() == ERROR_IO_PENDING)
5620 {
5621 dwret = WaitForSingleObject(overlapped.hEvent, 15000);
5622 ok(dwret == WAIT_OBJECT_0, "Waiting for connect event failed with %d + errno %d\n", dwret, GetLastError());
5623
5624 bret = GetOverlappedResult((HANDLE)connector, &overlapped, &bytesReturned, FALSE);
5625 ok(bret == FALSE && GetLastError() == ERROR_CONNECTION_REFUSED,
5626 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
5627 }
5628 else {
5629 ok(GetLastError() == WSAECONNREFUSED,
5630 "Connecting to a disconnected host returned error %d - %d\n", bret, WSAGetLastError());
5631 }
5632
5633 end:
5634 if (overlapped.hEvent)
5635 WSACloseEvent(overlapped.hEvent);
5636 if (listener != INVALID_SOCKET)
5637 closesocket(listener);
5638 if (acceptor != INVALID_SOCKET)
5639 closesocket(acceptor);
5640 if (connector != INVALID_SOCKET)
5641 closesocket(connector);
5642 }
5643
5644 static void test_AcceptEx(void)
5645 {
5646 SOCKET listener = INVALID_SOCKET;
5647 SOCKET acceptor = INVALID_SOCKET;
5648 SOCKET connector = INVALID_SOCKET;
5649 SOCKET connector2 = INVALID_SOCKET;
5650 struct sockaddr_in bindAddress, peerAddress, *readBindAddress, *readRemoteAddress;
5651 int socklen, optlen;
5652 GUID acceptExGuid = WSAID_ACCEPTEX, getAcceptExGuid = WSAID_GETACCEPTEXSOCKADDRS;
5653 LPFN_ACCEPTEX pAcceptEx = NULL;
5654 LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockaddrs = NULL;
5655 fd_set fds_accept, fds_send;
5656 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
5657 int got, conn1, i;
5658 DWORD bytesReturned, connect_time;
5659 char buffer[1024], ipbuffer[32];
5660 OVERLAPPED overlapped;
5661 int iret, localSize = sizeof(struct sockaddr_in), remoteSize = localSize;
5662 BOOL bret;
5663 DWORD dwret;
5664
5665 memset(&overlapped, 0, sizeof(overlapped));
5666
5667 listener = socket(AF_INET, SOCK_STREAM, 0);
5668 if (listener == INVALID_SOCKET) {
5669 skip("could not create listener socket, error %d\n", WSAGetLastError());
5670 goto end;
5671 }
5672
5673 acceptor = socket(AF_INET, SOCK_STREAM, 0);
5674 if (acceptor == INVALID_SOCKET) {
5675 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
5676 goto end;
5677 }
5678
5679 connector = socket(AF_INET, SOCK_STREAM, 0);
5680 if (connector == INVALID_SOCKET) {
5681 skip("could not create connector socket, error %d\n", WSAGetLastError());
5682 goto end;
5683 }
5684
5685 memset(&bindAddress, 0, sizeof(bindAddress));
5686 bindAddress.sin_family = AF_INET;
5687 bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
5688 iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
5689 if (iret != 0) {
5690 skip("failed to bind, error %d\n", WSAGetLastError());
5691 goto end;
5692 }
5693
5694 socklen = sizeof(bindAddress);
5695 iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
5696 if (iret != 0) {
5697 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
5698 goto end;
5699 }
5700
5701 if (set_blocking(listener, FALSE)) {
5702 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
5703 goto end;
5704 }
5705
5706 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
5707 &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
5708 if (iret) {
5709 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
5710 goto end;
5711 }
5712
5713 iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &getAcceptExGuid, sizeof(getAcceptExGuid),
5714 &pGetAcceptExSockaddrs, sizeof(pGetAcceptExSockaddrs), &bytesReturned, NULL, NULL);
5715 if (iret) {
5716 skip("WSAIoctl failed to get GetAcceptExSockaddrs with ret %d + errno %d\n", iret, WSAGetLastError());
5717 goto end;
5718 }
5719
5720 bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
5721 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
5722 &bytesReturned, &overlapped);
5723 ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
5724 "returned %d + errno %d\n", bret, WSAGetLastError());
5725
5726 bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
5727 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
5728 &bytesReturned, &overlapped);
5729 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on invalid accepting socket "
5730 "returned %d + errno %d\n", bret, WSAGetLastError());
5731
5732 bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
5733 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
5734 &bytesReturned, &overlapped);
5735 ok(bret == FALSE &&
5736 (WSAGetLastError() == WSAEINVAL ||
5737 broken(WSAGetLastError() == WSAEFAULT)), /* NT4 */
5738 "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
5739
5740 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
5741 &bytesReturned, &overlapped);
5742 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on too small local address size "
5743 "returned %d + errno %d\n", bret, WSAGetLastError());
5744
5745 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 15,
5746 sizeof(struct sockaddr_in) + 16, &bytesReturned, &overlapped);
5747 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on too small local address size "
5748 "returned %d + errno %d\n", bret, WSAGetLastError());
5749
5750 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
5751 &bytesReturned, &overlapped);
5752 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on too small remote address size "
5753 "returned %d + errno %d\n", bret, WSAGetLastError());
5754
5755 bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16,
5756 sizeof(struct sockaddr_in) + 15, &bytesReturned, &overlapped);
5757 ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on too small remote address size "
5758 "returned %d + errno %d\n", bret, WSAGetLastError());
5759
5760 bret = pAcceptEx(listener, acceptor, buffer, 0,
5761 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
5762 &bytesReturned, NULL);
5763 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
5764 "returned %d + errno %d\n", bret, WSAGetLastError());
5765
5766 bret = pAcceptEx(listener, acceptor, buffer, 0, 0, 0, &bytesReturned, NULL);
5767 ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
5768 "returned %d + errno %d\n", bret, WSAGetLastError());
5769
5770 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
5771 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
5772 &bytesReturned, &overlapped);
5773 todo_wine ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
5774 "returned %d + errno %d\n", bret, WSAGetLastError());
5775
5776 iret = listen(listener, 5);
5777 if (iret != 0) {
5778 skip("listening failed, errno = %d\n", WSAGetLastError());
5779 goto end;
5780 }
5781
5782 overlapped.hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
5783 if (overlapped.hEvent == NULL) {
5784 skip("could not create event object, errno = %d\n", GetLastError());
5785 goto end;
5786 }
5787
5788 bret = pAcceptEx(listener, acceptor, buffer, 0,
5789 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
5790 &bytesReturned, &overlapped);
5791 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
5792
5793 bret = pAcceptEx(listener, acceptor, buffer, 0,
5794 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
5795 &bytesReturned, &overlapped);
5796 todo_wine ok((bret == FALSE && WSAGetLastError() == WSAEINVAL) || broken(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) /* NT4 */,
5797 "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
5798 if (bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) {
5799 /* We need to cancel this call, otherwise things fail */
5800 bret = CancelIo((HANDLE) listener);
5801 ok(bret, "Failed to cancel failed test. Bailing...\n");
5802 if (!bret) return;
5803 WaitForSingleObject(overlapped.hEvent, 0);
5804
5805 bret = pAcceptEx(listener, acceptor, buffer, 0,
5806 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
5807 &bytesReturned, &overlapped);
5808 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
5809 }
5810
5811 iret = connect(acceptor, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
5812 todo_wine ok((iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL) || broken(!iret) /* NT4 */,
5813 "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
5814 if (!iret || (iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)) {
5815 /* We need to cancel this call, otherwise things fail */
5816 closesocket(acceptor);
5817 acceptor = socket(AF_INET, SOCK_STREAM, 0);
5818 if (acceptor == INVALID_SOCKET) {
5819 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
5820 goto end;
5821 }
5822
5823 bret = CancelIo((HANDLE) listener);
5824 ok(bret, "Failed to cancel failed test. Bailing...\n");
5825 if (!bret) return;
5826
5827 bret = pAcceptEx(listener, acceptor, buffer, 0,
5828 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
5829 &bytesReturned, &overlapped);
5830 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
5831 }
5832
5833 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
5834 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
5835
5836 dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
5837 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
5838
5839 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
5840 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
5841 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
5842
5843 closesocket(connector);
5844 connector = INVALID_SOCKET;
5845 closesocket(acceptor);
5846
5847 /* Test short reads */
5848
5849 acceptor = socket(AF_INET, SOCK_STREAM, 0);
5850 if (acceptor == INVALID_SOCKET) {
5851 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
5852 goto end;
5853 }
5854 connector = socket(AF_INET, SOCK_STREAM, 0);
5855 if (connector == INVALID_SOCKET) {
5856 skip("could not create connector socket, error %d\n", WSAGetLastError());
5857 goto end;
5858 }
5859 bret = pAcceptEx(listener, acceptor, buffer, 2,
5860 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
5861 &bytesReturned, &overlapped);
5862 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
5863
5864 connect_time = 0xdeadbeef;
5865 optlen = sizeof(connect_time);
5866 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
5867 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
5868 ok(connect_time == ~0u, "unexpected connect time %u\n", connect_time);
5869
5870 /* AcceptEx() still won't complete until we send data */
5871 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
5872 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
5873
5874 connect_time = 0xdeadbeef;
5875 optlen = sizeof(connect_time);
5876 iret = getsockopt(connector, SOL_SOCKET, SO_CONNECT_TIME, (char *)&connect_time, &optlen);
5877 ok(!iret, "getsockopt failed %d\n", WSAGetLastError());
5878 ok(connect_time < 0xdeadbeef, "unexpected connect time %u\n", connect_time);
5879
5880 dwret = WaitForSingleObject(overlapped.hEvent, 0);
5881 ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %d + errno %d\n", dwret, GetLastError());
5882
5883 iret = getsockname( connector, (struct sockaddr *)&peerAddress, &remoteSize);
5884 ok( !iret, "getsockname failed.\n");
5885
5886 /* AcceptEx() could complete any time now */
5887 iret = send(connector, buffer, 1, 0);
5888 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
5889
5890 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
5891 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
5892
5893 /* Check if the buffer from AcceptEx is decoded correctly */
5894 pGetAcceptExSockaddrs(buffer, 2, sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
5895 (struct sockaddr **)&readBindAddress, &localSize,
5896 (struct sockaddr **)&readRemoteAddress, &remoteSize);
5897 strcpy( ipbuffer, inet_ntoa(readBindAddress->sin_addr));
5898 ok( readBindAddress->sin_addr.s_addr == bindAddress.sin_addr.s_addr,
5899 "Local socket address is different %s != %s\n",
5900 ipbuffer, inet_ntoa(bindAddress.sin_addr));
5901 ok( readBindAddress->sin_port == bindAddress.sin_port,
5902 "Local socket port is different: %d != %d\n",
5903 readBindAddress->sin_port, bindAddress.sin_port);
5904 strcpy( ipbuffer, inet_ntoa(readRemoteAddress->sin_addr));
5905 ok( readRemoteAddress->sin_addr.s_addr == peerAddress.sin_addr.s_addr,
5906 "Remote socket address is different %s != %s\n",
5907 ipbuffer, inet_ntoa(peerAddress.sin_addr));
5908 ok( readRemoteAddress->sin_port == peerAddress.sin_port,
5909 "Remote socket port is different: %d != %d\n",
5910 readRemoteAddress->sin_port, peerAddress.sin_port);
5911
5912 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
5913 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
5914 ok(bytesReturned == 1, "bytesReturned isn't supposed to be %d\n", bytesReturned);
5915
5916 closesocket(connector);
5917 connector = INVALID_SOCKET;
5918 closesocket(acceptor);
5919
5920 /* Test CF_DEFER & AcceptEx interaction */
5921
5922 acceptor = socket(AF_INET, SOCK_STREAM, 0);
5923 if (acceptor == INVALID_SOCKET) {
5924 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
5925 goto end;
5926 }
5927 connector = socket(AF_INET, SOCK_STREAM, 0);
5928 if (connector == INVALID_SOCKET) {
5929 skip("could not create connector socket, error %d\n", WSAGetLastError());
5930 goto end;
5931 }
5932 connector2 = socket(AF_INET, SOCK_STREAM, 0);
5933 if (connector == INVALID_SOCKET) {
5934 skip("could not create connector socket, error %d\n", WSAGetLastError());
5935 goto end;
5936 }
5937
5938 if (set_blocking(connector, FALSE)) {
5939 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
5940 goto end;
5941 }
5942
5943 if (set_blocking(connector2, FALSE)) {
5944 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
5945 goto end;
5946 }
5947
5948 /* Connect socket #1 */
5949 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
5950 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
5951
5952 FD_ZERO ( &fds_accept );
5953 FD_ZERO ( &fds_send );
5954
5955 FD_SET ( listener, &fds_accept );
5956 FD_SET ( connector, &fds_send );
5957
5958 buffer[0] = '0';
5959 got = 0;
5960 conn1 = 0;
5961
5962 for (i = 0; i < 4000; ++i)
5963 {
5964 fd_set fds_openaccept = fds_accept, fds_opensend = fds_send;
5965
5966 wsa_ok ( ( select ( 0, &fds_openaccept, &fds_opensend, NULL, &timeout ) ), SOCKET_ERROR !=,
5967 "acceptex test(%d): could not select on socket, errno %d\n" );
5968
5969 /* check for incoming requests */
5970 if ( FD_ISSET ( listener, &fds_openaccept ) ) {
5971 got++;
5972 if (got == 1) {
5973 SOCKET tmp = WSAAccept(listener, NULL, NULL, (LPCONDITIONPROC) AlwaysDeferConditionFunc, 0);
5974 ok(tmp == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
5975 bret = pAcceptEx(listener, acceptor, buffer, 0,
5976 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
5977 &bytesReturned, &overlapped);
5978 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
5979 }
5980 else if (got == 2) {
5981 /* this should be socket #2 */
5982 SOCKET tmp = accept(listener, NULL, NULL);
5983 ok(tmp != INVALID_SOCKET, "accept failed %d\n", WSAGetLastError());
5984 closesocket(tmp);
5985 }
5986 else {
5987 ok(FALSE, "Got more than 2 connections?\n");
5988 }
5989 }
5990 if ( conn1 && FD_ISSET ( connector2, &fds_opensend ) ) {
5991 /* Send data on second socket, and stop */
5992 send(connector2, "2", 1, 0);
5993 FD_CLR ( connector2, &fds_send );
5994
5995 break;
5996 }
5997 if ( FD_ISSET ( connector, &fds_opensend ) ) {
5998 /* Once #1 is connected, allow #2 to connect */
5999 conn1 = 1;
6000
6001 send(connector, "1", 1, 0);
6002 FD_CLR ( connector, &fds_send );
6003
6004 iret = connect(connector2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
6005 ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6006 FD_SET ( connector2, &fds_send );
6007 }
6008 }
6009
6010 ok (got == 2 || broken(got == 1) /* NT4 */,
6011 "Did not get both connections, got %d\n", got);
6012
6013 dwret = WaitForSingleObject(overlapped.hEvent, 0);
6014 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
6015
6016 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
6017 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
6018 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
6019
6020 set_blocking(acceptor, TRUE);
6021 iret = recv( acceptor, buffer, 2, 0);
6022 ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
6023
6024 ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
6025
6026 closesocket(connector);
6027 connector = INVALID_SOCKET;
6028 closesocket(acceptor);
6029
6030 /* clean up in case of failures */
6031 while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
6032 closesocket(acceptor);
6033
6034 /* Disconnect during receive? */
6035
6036 acceptor = socket(AF_INET, SOCK_STREAM, 0);
6037 if (acceptor == INVALID_SOCKET) {
6038 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6039 goto end;
6040 }
6041 connector = socket(AF_INET, SOCK_STREAM, 0);
6042 if (connector == INVALID_SOCKET) {
6043 skip("could not create connector socket, error %d\n", WSAGetLastError());
6044 goto end;
6045 }
6046 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6047 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6048 &bytesReturned, &overlapped);
6049 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
6050
6051 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
6052 ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
6053
6054 closesocket(connector);
6055 connector = INVALID_SOCKET;
6056
6057 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
6058 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
6059
6060 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
6061 ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
6062 ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
6063
6064 closesocket(acceptor);
6065
6066 /* Test closing with pending requests */
6067
6068 acceptor = socket(AF_INET, SOCK_STREAM, 0);
6069 if (acceptor == INVALID_SOCKET) {
6070 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6071 goto end;
6072 }
6073 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6074 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6075 &bytesReturned, &overlapped);
6076 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
6077
6078 closesocket(acceptor);
6079
6080 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
6081 todo_wine ok(dwret == WAIT_OBJECT_0 || broken(dwret == WAIT_TIMEOUT) /* NT4/2000 */,
6082 "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
6083
6084 if (dwret != WAIT_TIMEOUT) {
6085 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
6086 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
6087 }
6088 else {
6089 bret = CancelIo((HANDLE) listener);
6090 ok(bret, "Failed to cancel failed test. Bailing...\n");
6091 if (!bret) return;
6092 WaitForSingleObject(overlapped.hEvent, 0);
6093 }
6094
6095 acceptor = socket(AF_INET, SOCK_STREAM, 0);
6096 if (acceptor == INVALID_SOCKET) {
6097 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6098 goto end;
6099 }
6100 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6101 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6102 &bytesReturned, &overlapped);
6103 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
6104
6105 CancelIo((HANDLE) acceptor);
6106
6107 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
6108 ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %d + errno %d\n", dwret, GetLastError());
6109
6110 closesocket(acceptor);
6111
6112 acceptor = socket(AF_INET, SOCK_STREAM, 0);
6113 if (acceptor == INVALID_SOCKET) {
6114 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6115 goto end;
6116 }
6117 bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
6118 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6119 &bytesReturned, &overlapped);
6120 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
6121
6122 closesocket(listener);
6123 listener = INVALID_SOCKET;
6124
6125 dwret = WaitForSingleObject(overlapped.hEvent, 1000);
6126 ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
6127
6128 bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
6129 ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
6130
6131 end:
6132 if (overlapped.hEvent)
6133 WSACloseEvent(overlapped.hEvent);
6134 if (listener != INVALID_SOCKET)
6135 closesocket(listener);
6136 if (acceptor != INVALID_SOCKET)
6137 closesocket(acceptor);
6138 if (connector != INVALID_SOCKET)
6139 closesocket(connector);
6140 if (connector2 != INVALID_SOCKET)
6141 closesocket(connector2);
6142 }
6143
6144 static void test_getpeername(void)
6145 {
6146 SOCKET sock;
6147 struct sockaddr_in sa, sa_out;
6148 SOCKADDR_STORAGE ss;
6149 int sa_len;
6150 const char buf[] = "hello world";
6151 int ret;
6152
6153 /* Test the parameter validation order. */
6154 ret = getpeername(INVALID_SOCKET, NULL, NULL);
6155 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
6156 ok(WSAGetLastError() == WSAENOTSOCK,
6157 "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
6158
6159 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
6160 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
6161 if (sock == INVALID_SOCKET)
6162 {
6163 skip("Socket creation failed with %d\n", WSAGetLastError());
6164 return;
6165 }
6166
6167 ret = getpeername(sock, NULL, NULL);
6168 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
6169 ok(WSAGetLastError() == WSAENOTCONN ||
6170 broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
6171 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
6172
6173 memset(&sa, 0, sizeof(sa));
6174 sa.sin_family = AF_INET;
6175 sa.sin_port = htons(139);
6176 sa.sin_addr.s_addr = inet_addr("127.0.0.1");
6177
6178 /* sendto does not change a socket's connection state. */
6179 ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
6180 ok(ret != SOCKET_ERROR,
6181 "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
6182
6183 ret = getpeername(sock, NULL, NULL);
6184 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
6185 ok(WSAGetLastError() == WSAENOTCONN ||
6186 broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
6187 "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
6188
6189 ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
6190 ok(ret == 0,
6191 "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
6192
6193 ret = getpeername(sock, NULL, NULL);
6194 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
6195 ok(WSAGetLastError() == WSAEFAULT,
6196 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6197
6198 /* Test crashes on Wine. */
6199 if (0)
6200 {
6201 ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
6202 ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
6203 ok(WSAGetLastError() == WSAEFAULT,
6204 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6205 }
6206
6207 ret = getpeername(sock, (struct sockaddr*)&sa_out, NULL);
6208 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
6209 ok(WSAGetLastError() == WSAEFAULT,
6210 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6211
6212 sa_len = 0;
6213 ret = getpeername(sock, NULL, &sa_len);
6214 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
6215 ok(WSAGetLastError() == WSAEFAULT,
6216 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6217 ok(!sa_len, "got %d\n", sa_len);
6218
6219 sa_len = 0;
6220 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
6221 ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
6222 ok(WSAGetLastError() == WSAEFAULT,
6223 "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
6224 ok(!sa_len, "got %d\n", sa_len);
6225
6226 sa_len = sizeof(ss);
6227 ret = getpeername(sock, (struct sockaddr *)&ss, &sa_len);
6228 ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
6229 ok(!memcmp(&sa, &ss, sizeof(sa)),
6230 "Expected the returned structure to be identical to the connect structure\n");
6231 ok(sa_len == sizeof(sa), "got %d\n", sa_len);
6232
6233 closesocket(sock);
6234 }
6235
6236 static void test_sioRoutingInterfaceQuery(void)
6237 {
6238 int ret;
6239 SOCKET sock;
6240 SOCKADDR_IN sin = { 0 }, sout = { 0 };
6241 DWORD bytesReturned;
6242
6243 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
6244 ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
6245 if (sock == INVALID_SOCKET)
6246 {
6247 skip("Socket creation failed with %d\n", WSAGetLastError());
6248 return;
6249 }
6250 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, NULL, 0, NULL, 0, NULL,
6251 NULL, NULL);
6252 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
6253 "expected WSAEFAULT, got %d\n", WSAGetLastError());
6254 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
6255 NULL, 0, NULL, NULL, NULL);
6256 ok(ret == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT,
6257 "expected WSAEFAULT, got %d\n", WSAGetLastError());
6258 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
6259 NULL, 0, &bytesReturned, NULL, NULL);
6260 ok(ret == SOCKET_ERROR &&
6261 (WSAGetLastError() == WSAEFAULT /* Win98 */ ||
6262 WSAGetLastError() == WSAEINVAL /* NT4 */||
6263 WSAGetLastError() == WSAEAFNOSUPPORT),
6264 "expected WSAEFAULT or WSAEINVAL or WSAEAFNOSUPPORT, got %d\n",
6265 WSAGetLastError());
6266 sin.sin_family = AF_INET;
6267 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
6268 NULL, 0, &bytesReturned, NULL, NULL);
6269 ok(ret == SOCKET_ERROR &&
6270 (WSAGetLastError() == WSAEFAULT /* Win98 */ ||
6271 WSAGetLastError() == WSAEINVAL),
6272 "expected WSAEFAULT or WSAEINVAL, got %d\n", WSAGetLastError());
6273 sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
6274 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
6275 NULL, 0, &bytesReturned, NULL, NULL);
6276 ok(ret == SOCKET_ERROR &&
6277 (WSAGetLastError() == WSAEINVAL /* NT4 */ ||
6278 WSAGetLastError() == WSAEFAULT),
6279 "expected WSAEINVAL or WSAEFAULT, got %d\n", WSAGetLastError());
6280 ret = WSAIoctl(sock, SIO_ROUTING_INTERFACE_QUERY, &sin, sizeof(sin),
6281 &sout, sizeof(sout), &bytesReturned, NULL, NULL);
6282 ok(!ret || broken(WSAGetLastError() == WSAEINVAL /* NT4 */),
6283 "WSAIoctl failed: %d\n", WSAGetLastError());
6284 if (!ret)
6285 {
6286 ok(sout.sin_family == AF_INET, "expected AF_INET, got %d\n",
6287 sout.sin_family);
6288 /* We expect the source address to be INADDR_LOOPBACK as well, but
6289 * there's no guarantee that a route to the loopback address exists,
6290 * so rather than introduce spurious test failures we do not test the
6291 * source address.
6292 */
6293 }
6294 closesocket(sock);
6295 }
6296
6297 static void test_synchronous_WSAIoctl(void)
6298 {
6299 HANDLE previous_port, io_port;
6300 WSAOVERLAPPED overlapped, *olp;
6301 SOCKET socket;
6302 ULONG on;
6303 ULONG_PTR key;
6304 DWORD num_bytes;
6305 BOOL ret;
6306 int res;
6307
6308 previous_port = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );
6309 ok( previous_port != NULL, "failed to create completion port %u\n", GetLastError() );
6310
6311 socket = WSASocketW( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED );
6312 ok( socket != INVALID_SOCKET, "failed to create socket %d\n", WSAGetLastError() );
6313
6314 io_port = CreateIoCompletionPort( (HANDLE)socket, previous_port, 0, 0 );
6315 ok( io_port != NULL, "failed to create completion port %u\n", GetLastError() );
6316
6317 on = 1;
6318 memset( &overlapped, 0, sizeof(overlapped) );
6319 res = WSAIoctl( socket, FIONBIO, &on, sizeof(on), NULL, 0, &num_bytes, &overlapped, NULL );
6320 ok( !res, "WSAIoctl failed %d\n", WSAGetLastError() );
6321
6322 ret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 10000 );
6323 ok( ret, "failed to get completion status %u\n", GetLastError() );
6324
6325 CloseHandle( io_port );
6326 closesocket( socket );
6327 CloseHandle( previous_port );
6328 }
6329
6330 #define WM_ASYNCCOMPLETE (WM_USER + 100)
6331 static HWND create_async_message_window(void)
6332 {
6333 static const char class_name[] = "ws2_32 async message window class";
6334
6335 WNDCLASSEXA wndclass;
6336 HWND hWnd;
6337
6338 wndclass.cbSize = sizeof(wndclass);
6339 wndclass.style = CS_HREDRAW | CS_VREDRAW;
6340 wndclass.lpfnWndProc = DefWindowProcA;
6341 wndclass.cbClsExtra = 0;
6342 wndclass.cbWndExtra = 0;
6343 wndclass.hInstance = GetModuleHandleA(NULL);
6344 wndclass.hIcon = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
6345 wndclass.hIconSm = LoadIconA(NULL, (LPCSTR)IDI_APPLICATION);
6346 wndclass.hCursor = LoadCursorA(NULL, (LPCSTR)IDC_ARROW);
6347 wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
6348 wndclass.lpszClassName = class_name;
6349 wndclass.lpszMenuName = NULL;
6350
6351 RegisterClassExA(&wndclass);
6352
6353 hWnd = CreateWindowA(class_name, "ws2_32 async message window", WS_OVERLAPPEDWINDOW,
6354 0, 0, 500, 500, NULL, NULL, GetModuleHandleA(NULL), NULL);
6355 if (!hWnd)
6356 {
6357 ok(0, "failed to create window: %u\n", GetLastError());
6358 return NULL;
6359 }
6360
6361 return hWnd;
6362 }
6363
6364 static void test_WSAAsyncGetServByPort(void)
6365 {
6366 HWND hwnd = create_async_message_window();
6367 HANDLE ret;
6368 char buffer[MAXGETHOSTSTRUCT];
6369
6370 if (!hwnd)
6371 return;
6372
6373 /* FIXME: The asynchronous window messages should be tested. */
6374
6375 /* Parameters are not checked when initiating the asynchronous operation. */
6376 ret = WSAAsyncGetServByPort(NULL, 0, 0, NULL, NULL, 0);
6377 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
6378
6379 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, 0, NULL, NULL, 0);
6380 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
6381
6382 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, NULL, 0);
6383 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
6384
6385 ret = WSAAsyncGetServByPort(hwnd, WM_ASYNCCOMPLETE, htons(80), NULL, buffer, MAXGETHOSTSTRUCT);
6386 ok(ret != NULL, "WSAAsyncGetServByPort returned NULL\n");
6387
6388 DestroyWindow(hwnd);
6389 }
6390
6391 static void test_WSAAsyncGetServByName(void)
6392 {
6393 HWND hwnd = create_async_message_window();
6394 HANDLE ret;
6395 char buffer[MAXGETHOSTSTRUCT];
6396
6397 if (!hwnd)
6398 return;
6399
6400 /* FIXME: The asynchronous window messages should be tested. */
6401
6402 /* Parameters are not checked when initiating the asynchronous operation. */
6403 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", NULL, NULL, 0);
6404 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
6405
6406 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "", "", buffer, MAXGETHOSTSTRUCT);
6407 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
6408
6409 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", NULL, NULL, 0);
6410 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
6411
6412 ret = WSAAsyncGetServByName(hwnd, WM_ASYNCCOMPLETE, "http", "tcp", buffer, MAXGETHOSTSTRUCT);
6413 ok(ret != NULL, "WSAAsyncGetServByName returned NULL\n");
6414
6415 DestroyWindow(hwnd);
6416 }
6417
6418 /*
6419 * Provide consistent initialization for the AcceptEx IOCP tests.
6420 */
6421 static SOCKET setup_iocp_src(struct sockaddr_in *bindAddress)
6422 {
6423 SOCKET src, ret = INVALID_SOCKET;
6424 int iret, socklen;
6425
6426 src = socket(AF_INET, SOCK_STREAM, 0);
6427 if (src == INVALID_SOCKET)
6428 {
6429 skip("could not create listener socket, error %d\n", WSAGetLastError());
6430 goto end;
6431 }
6432
6433 memset(bindAddress, 0, sizeof(*bindAddress));
6434 bindAddress->sin_family = AF_INET;
6435 bindAddress->sin_addr.s_addr = inet_addr("127.0.0.1");
6436 iret = bind(src, (struct sockaddr*)bindAddress, sizeof(*bindAddress));
6437 if (iret != 0)
6438 {
6439 skip("failed to bind, error %d\n", WSAGetLastError());
6440 goto end;
6441 }
6442
6443 socklen = sizeof(*bindAddress);
6444 iret = getsockname(src, (struct sockaddr*)bindAddress, &socklen);
6445 if (iret != 0) {
6446 skip("failed to lookup bind address, error %d\n", WSAGetLastError());
6447 goto end;
6448 }
6449
6450 if (set_blocking(src, FALSE))
6451 {
6452 skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
6453 goto end;
6454 }
6455
6456 iret = listen(src, 5);
6457 if (iret != 0)
6458 {
6459 skip("listening failed, errno = %d\n", WSAGetLastError());
6460 goto end;
6461 }
6462
6463 ret = src;
6464 end:
6465 if (src != ret && ret == INVALID_SOCKET)
6466 closesocket(src);
6467 return ret;
6468 }
6469
6470 static void test_completion_port(void)
6471 {
6472 HANDLE previous_port, io_port;
6473 WSAOVERLAPPED ov, *olp;
6474 SOCKET src, dest, dup, connector = INVALID_SOCKET;
6475 WSAPROTOCOL_INFOA info;
6476 char buf[1024];
6477 WSABUF bufs;
6478 DWORD num_bytes, flags;
6479 struct linger ling;
6480 int iret;
6481 BOOL bret;
6482 ULONG_PTR key;
6483 struct sockaddr_in bindAddress;
6484 GUID acceptExGuid = WSAID_ACCEPTEX;
6485 LPFN_ACCEPTEX pAcceptEx = NULL;
6486
6487 previous_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
6488 ok( previous_port != NULL, "Failed to create completion port %u\n", GetLastError());
6489
6490 memset(&ov, 0, sizeof(ov));
6491
6492 tcp_socketpair(&src, &dest);
6493 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
6494 {
6495 skip("failed to create sockets\n");
6496 goto end;
6497 }
6498
6499 bufs.len = sizeof(buf);
6500 bufs.buf = buf;
6501 flags = 0;
6502
6503 ling.l_onoff = 1;
6504 ling.l_linger = 0;
6505 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
6506 ok(!iret, "Failed to set linger %d\n", GetLastError());
6507
6508 io_port = CreateIoCompletionPort( (HANDLE)dest, previous_port, 125, 0 );
6509 ok(io_port != NULL, "Failed to create completion port %u\n", GetLastError());
6510
6511 SetLastError(0xdeadbeef);
6512
6513 iret = WSARecv(dest, &bufs, 1, &num_bytes, &flags, &ov, NULL);
6514 ok(iret == SOCKET_ERROR, "WSARecv returned %d\n", iret);
6515 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
6516
6517 Sleep(100);
6518
6519 closesocket(src);
6520 src = INVALID_SOCKET;
6521
6522 SetLastError(0xdeadbeef);
6523 key = 0xdeadbeef;
6524 num_bytes = 0xdeadbeef;
6525 olp = (WSAOVERLAPPED *)0xdeadbeef;
6526
6527 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
6528 todo_wine ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret);
6529 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED, "Last error was %d\n", GetLastError());
6530 ok(key == 125, "Key is %lu\n", key);
6531 ok(num_bytes == 0, "Number of bytes received is %u\n", num_bytes);
6532 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
6533
6534 SetLastError(0xdeadbeef);
6535 key = 0xdeadbeef;
6536 num_bytes = 0xdeadbeef;
6537 olp = (WSAOVERLAPPED *)0xdeadbeef;
6538
6539 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
6540 ok(bret == FALSE, "GetQueuedCompletionStatus returned %d\n", bret );
6541 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6542 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6543 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6544 ok(!olp, "Overlapped structure is at %p\n", olp);
6545
6546 if (dest != INVALID_SOCKET)
6547 closesocket(dest);
6548
6549 memset(&ov, 0, sizeof(ov));
6550
6551 tcp_socketpair(&src, &dest);
6552 if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
6553 {
6554 skip("failed to create sockets\n");
6555 goto end;
6556 }
6557
6558 bufs.len = sizeof(buf);
6559 bufs.buf = buf;
6560 flags = 0;
6561
6562 ling.l_onoff = 1;
6563 ling.l_linger = 0;
6564 iret = setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
6565 ok(!iret, "Failed to set linger %d\n", GetLastError());
6566
6567 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 125, 0);
6568 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6569
6570 set_blocking(dest, FALSE);
6571
6572 closesocket(src);
6573 src = INVALID_SOCKET;
6574
6575 Sleep(100);
6576
6577 num_bytes = 0xdeadbeef;
6578 SetLastError(0xdeadbeef);
6579
6580 iret = WSASend(dest, &bufs, 1, &num_bytes, 0, &ov, NULL);
6581 ok(iret == SOCKET_ERROR, "WSASend failed - %d\n", iret);
6582 ok(GetLastError() == WSAECONNRESET, "Last error was %d\n", GetLastError());
6583 ok(num_bytes == 0xdeadbeef, "Managed to send %d\n", num_bytes);
6584
6585 SetLastError(0xdeadbeef);
6586 key = 0xdeadbeef;
6587 num_bytes = 0xdeadbeef;
6588 olp = (WSAOVERLAPPED *)0xdeadbeef;
6589
6590 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
6591 ok(bret == FALSE, "GetQueuedCompletionStatus returned %u\n", bret );
6592 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6593 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6594 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6595 ok(!olp, "Overlapped structure is at %p\n", olp);
6596
6597 if (dest != INVALID_SOCKET)
6598 closesocket(dest);
6599
6600 dest = socket(AF_INET, SOCK_STREAM, 0);
6601 if (dest == INVALID_SOCKET)
6602 {
6603 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6604 goto end;
6605 }
6606
6607 iret = WSAIoctl(dest, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
6608 &pAcceptEx, sizeof(pAcceptEx), &num_bytes, NULL, NULL);
6609 if (iret)
6610 {
6611 skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
6612 goto end;
6613 }
6614
6615 /* Test IOCP response on socket close (IOCP created after AcceptEx) */
6616
6617 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
6618 goto end;
6619
6620 SetLastError(0xdeadbeef);
6621
6622 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
6623 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6624 &num_bytes, &ov);
6625 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
6626 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
6627
6628 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
6629 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6630
6631 closesocket(src);
6632 src = INVALID_SOCKET;
6633
6634 SetLastError(0xdeadbeef);
6635 key = 0xdeadbeef;
6636 num_bytes = 0xdeadbeef;
6637 olp = (WSAOVERLAPPED *)0xdeadbeef;
6638
6639 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
6640 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6641 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
6642 ok(key == 125, "Key is %lu\n", key);
6643 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
6644 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
6645 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
6646
6647 SetLastError(0xdeadbeef);
6648 key = 0xdeadbeef;
6649 num_bytes = 0xdeadbeef;
6650 olp = (WSAOVERLAPPED *)0xdeadbeef;
6651 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
6652 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6653 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6654 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6655 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6656 ok(!olp, "Overlapped structure is at %p\n", olp);
6657
6658 /* Test IOCP response on socket close (IOCP created before AcceptEx) */
6659
6660 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
6661 goto end;
6662
6663 SetLastError(0xdeadbeef);
6664
6665 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
6666 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6667
6668 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
6669 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6670 &num_bytes, &ov);
6671 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
6672 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
6673
6674 closesocket(src);
6675 src = INVALID_SOCKET;
6676
6677 SetLastError(0xdeadbeef);
6678 key = 0xdeadbeef;
6679 num_bytes = 0xdeadbeef;
6680 olp = (WSAOVERLAPPED *)0xdeadbeef;
6681
6682 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
6683 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6684 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
6685 ok(key == 125, "Key is %lu\n", key);
6686 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
6687 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
6688 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
6689
6690 SetLastError(0xdeadbeef);
6691 key = 0xdeadbeef;
6692 num_bytes = 0xdeadbeef;
6693 olp = (WSAOVERLAPPED *)0xdeadbeef;
6694 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
6695 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6696 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6697 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6698 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6699 ok(!olp, "Overlapped structure is at %p\n", olp);
6700
6701 /* Test IOCP with duplicated handle */
6702
6703 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
6704 goto end;
6705
6706 SetLastError(0xdeadbeef);
6707
6708 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
6709 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6710
6711 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
6712 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
6713 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
6714
6715 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
6716 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6717 &num_bytes, &ov);
6718 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
6719 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
6720
6721 SetLastError(0xdeadbeef);
6722 key = 0xdeadbeef;
6723 num_bytes = 0xdeadbeef;
6724 olp = (WSAOVERLAPPED *)0xdeadbeef;
6725 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
6726 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6727 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6728 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6729 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6730 ok(!olp, "Overlapped structure is at %p\n", olp);
6731
6732 closesocket(src);
6733 src = INVALID_SOCKET;
6734 closesocket(dup);
6735 dup = INVALID_SOCKET;
6736
6737 SetLastError(0xdeadbeef);
6738 key = 0xdeadbeef;
6739 num_bytes = 0xdeadbeef;
6740 olp = (WSAOVERLAPPED *)0xdeadbeef;
6741 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
6742 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6743 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
6744 ok(key == 125, "Key is %lu\n", key);
6745 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
6746 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
6747 ok(olp && olp->Internal == (ULONG)STATUS_CANCELLED, "Internal status is %lx\n", olp ? olp->Internal : 0);
6748
6749 SetLastError(0xdeadbeef);
6750 key = 0xdeadbeef;
6751 num_bytes = 0xdeadbeef;
6752 olp = (WSAOVERLAPPED *)0xdeadbeef;
6753 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
6754 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6755 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6756 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6757 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6758 ok(!olp, "Overlapped structure is at %p\n", olp);
6759
6760 /* Test IOCP with duplicated handle (closing duplicated handle) */
6761
6762 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
6763 goto end;
6764
6765 SetLastError(0xdeadbeef);
6766
6767 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
6768 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6769
6770 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
6771 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
6772 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
6773
6774 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
6775 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6776 &num_bytes, &ov);
6777 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
6778 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
6779
6780 closesocket(dup);
6781 dup = INVALID_SOCKET;
6782
6783 SetLastError(0xdeadbeef);
6784 key = 0xdeadbeef;
6785 num_bytes = 0xdeadbeef;
6786 olp = (WSAOVERLAPPED *)0xdeadbeef;
6787 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
6788 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6789 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6790 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6791 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6792 ok(!olp, "Overlapped structure is at %p\n", olp);
6793
6794 SetLastError(0xdeadbeef);
6795 key = 0xdeadbeef;
6796 num_bytes = 0xdeadbeef;
6797 olp = (WSAOVERLAPPED *)0xdeadbeef;
6798 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
6799 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6800 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6801 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6802 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6803 ok(!olp, "Overlapped structure is at %p\n", olp);
6804
6805 closesocket(src);
6806 src = INVALID_SOCKET;
6807
6808 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
6809 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6810 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
6811 ok(key == 125, "Key is %lu\n", key);
6812 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
6813 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
6814 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
6815
6816 SetLastError(0xdeadbeef);
6817 key = 0xdeadbeef;
6818 num_bytes = 0xdeadbeef;
6819 olp = (WSAOVERLAPPED *)0xdeadbeef;
6820 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
6821 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6822 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6823 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6824 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6825 ok(!olp, "Overlapped structure is at %p\n", olp);
6826
6827 /* Test IOCP with duplicated handle (closing original handle) */
6828
6829 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
6830 goto end;
6831
6832 SetLastError(0xdeadbeef);
6833
6834 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
6835 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6836
6837 WSADuplicateSocketA( src, GetCurrentProcessId(), &info );
6838 dup = WSASocketA(AF_INET, SOCK_STREAM, 0, &info, 0, WSA_FLAG_OVERLAPPED);
6839 ok(dup != INVALID_SOCKET, "failed to duplicate socket!\n");
6840
6841 bret = pAcceptEx(dup, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
6842 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6843 &num_bytes, &ov);
6844 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
6845 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
6846
6847 closesocket(src);
6848 src = INVALID_SOCKET;
6849
6850 SetLastError(0xdeadbeef);
6851 key = 0xdeadbeef;
6852 num_bytes = 0xdeadbeef;
6853 olp = (WSAOVERLAPPED *)0xdeadbeef;
6854 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
6855 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6856 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6857 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6858 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6859 ok(!olp, "Overlapped structure is at %p\n", olp);
6860
6861 closesocket(dup);
6862 dup = INVALID_SOCKET;
6863
6864 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
6865 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6866 ok(GetLastError() == ERROR_OPERATION_ABORTED, "Last error was %d\n", GetLastError());
6867 ok(key == 125, "Key is %lu\n", key);
6868 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
6869 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
6870 ok(olp && (olp->Internal == (ULONG)STATUS_CANCELLED), "Internal status is %lx\n", olp ? olp->Internal : 0);
6871
6872 SetLastError(0xdeadbeef);
6873 key = 0xdeadbeef;
6874 num_bytes = 0xdeadbeef;
6875 olp = (WSAOVERLAPPED *)0xdeadbeef;
6876 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
6877 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6878 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6879 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6880 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6881 ok(!olp, "Overlapped structure is at %p\n", olp);
6882
6883 /* Test IOCP without AcceptEx */
6884
6885 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
6886 goto end;
6887
6888 SetLastError(0xdeadbeef);
6889
6890 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
6891 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6892
6893 closesocket(src);
6894 src = INVALID_SOCKET;
6895
6896 SetLastError(0xdeadbeef);
6897 key = 0xdeadbeef;
6898 num_bytes = 0xdeadbeef;
6899 olp = (WSAOVERLAPPED *)0xdeadbeef;
6900 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
6901 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6902 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6903 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6904 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6905 ok(!olp, "Overlapped structure is at %p\n", olp);
6906
6907 /* */
6908
6909 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
6910 goto end;
6911
6912 connector = socket(AF_INET, SOCK_STREAM, 0);
6913 if (connector == INVALID_SOCKET) {
6914 skip("could not create connector socket, error %d\n", WSAGetLastError());
6915 goto end;
6916 }
6917
6918 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
6919 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6920
6921 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
6922 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6923
6924 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
6925 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6926 &num_bytes, &ov);
6927 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
6928 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
6929
6930 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
6931 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
6932
6933 closesocket(connector);
6934 connector = INVALID_SOCKET;
6935
6936 SetLastError(0xdeadbeef);
6937 key = 0xdeadbeef;
6938 num_bytes = 0xdeadbeef;
6939 olp = (WSAOVERLAPPED *)0xdeadbeef;
6940
6941 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
6942 ok(bret == TRUE, "failed to get completion status %u\n", bret);
6943 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
6944 ok(key == 125, "Key is %lu\n", key);
6945 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
6946 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
6947 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
6948
6949 SetLastError(0xdeadbeef);
6950 key = 0xdeadbeef;
6951 num_bytes = 0xdeadbeef;
6952 olp = (WSAOVERLAPPED *)0xdeadbeef;
6953 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
6954 ok(bret == FALSE, "failed to get completion status %u\n", bret);
6955 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
6956 ok(key == 0xdeadbeef, "Key is %lu\n", key);
6957 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
6958 ok(!olp, "Overlapped structure is at %p\n", olp);
6959
6960 if (dest != INVALID_SOCKET)
6961 closesocket(dest);
6962 if (src != INVALID_SOCKET)
6963 closesocket(dest);
6964
6965 /* */
6966
6967 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
6968 goto end;
6969
6970 dest = socket(AF_INET, SOCK_STREAM, 0);
6971 if (dest == INVALID_SOCKET)
6972 {
6973 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
6974 goto end;
6975 }
6976
6977 connector = socket(AF_INET, SOCK_STREAM, 0);
6978 if (connector == INVALID_SOCKET) {
6979 skip("could not create connector socket, error %d\n", WSAGetLastError());
6980 goto end;
6981 }
6982
6983 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
6984 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6985
6986 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
6987 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
6988
6989 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
6990 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
6991 &num_bytes, &ov);
6992 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
6993 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
6994
6995 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
6996 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
6997
6998 iret = send(connector, buf, 1, 0);
6999 ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
7000
7001 Sleep(100);
7002
7003 closesocket(dest);
7004 dest = INVALID_SOCKET;
7005
7006 SetLastError(0xdeadbeef);
7007 key = 0xdeadbeef;
7008 num_bytes = 0xdeadbeef;
7009 olp = (WSAOVERLAPPED *)0xdeadbeef;
7010
7011 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
7012 ok(bret == TRUE, "failed to get completion status %u\n", bret);
7013 ok(GetLastError() == 0xdeadbeef, "Last error was %d\n", GetLastError());
7014 ok(key == 125, "Key is %lu\n", key);
7015 ok(num_bytes == 1, "Number of bytes transferred is %u\n", num_bytes);
7016 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
7017 ok(olp && (olp->Internal == (ULONG)STATUS_SUCCESS), "Internal status is %lx\n", olp ? olp->Internal : 0);
7018
7019 SetLastError(0xdeadbeef);
7020 key = 0xdeadbeef;
7021 num_bytes = 0xdeadbeef;
7022 olp = (WSAOVERLAPPED *)0xdeadbeef;
7023 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
7024 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7025 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7026 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7027 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7028 ok(!olp, "Overlapped structure is at %p\n", olp);
7029
7030 if (src != INVALID_SOCKET)
7031 closesocket(src);
7032 if (connector != INVALID_SOCKET)
7033 closesocket(connector);
7034
7035 /* */
7036
7037 if ((src = setup_iocp_src(&bindAddress)) == INVALID_SOCKET)
7038 goto end;
7039
7040 dest = socket(AF_INET, SOCK_STREAM, 0);
7041 if (dest == INVALID_SOCKET)
7042 {
7043 skip("could not create acceptor socket, error %d\n", WSAGetLastError());
7044 goto end;
7045 }
7046
7047 connector = socket(AF_INET, SOCK_STREAM, 0);
7048 if (connector == INVALID_SOCKET) {
7049 skip("could not create connector socket, error %d\n", WSAGetLastError());
7050 goto end;
7051 }
7052
7053 io_port = CreateIoCompletionPort((HANDLE)src, previous_port, 125, 0);
7054 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
7055
7056 io_port = CreateIoCompletionPort((HANDLE)dest, previous_port, 236, 0);
7057 ok(io_port != NULL, "failed to create completion port %u\n", GetLastError());
7058
7059 bret = pAcceptEx(src, dest, buf, sizeof(buf) - 2*(sizeof(struct sockaddr_in) + 16),
7060 sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
7061 &num_bytes, &ov);
7062 ok(bret == FALSE, "AcceptEx returned %d\n", bret);
7063 ok(GetLastError() == ERROR_IO_PENDING, "Last error was %d\n", GetLastError());
7064
7065 iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
7066 ok(iret == 0, "connecting to accepting socket failed, error %d\n", GetLastError());
7067
7068 closesocket(dest);
7069 dest = INVALID_SOCKET;
7070
7071 SetLastError(0xdeadbeef);
7072 key = 0xdeadbeef;
7073 num_bytes = 0xdeadbeef;
7074 olp = (WSAOVERLAPPED *)0xdeadbeef;
7075
7076 bret = GetQueuedCompletionStatus(io_port, &num_bytes, &key, &olp, 100);
7077 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7078 todo_wine ok(GetLastError() == ERROR_NETNAME_DELETED ||
7079 GetLastError() == ERROR_OPERATION_ABORTED ||
7080 GetLastError() == ERROR_CONNECTION_ABORTED, "Last error was %d\n", GetLastError());
7081 ok(key == 125, "Key is %lu\n", key);
7082 ok(num_bytes == 0, "Number of bytes transferred is %u\n", num_bytes);
7083 ok(olp == &ov, "Overlapped structure is at %p\n", olp);
7084 todo_wine ok(olp && (olp->Internal == (ULONG)STATUS_LOCAL_DISCONNECT ||
7085 olp->Internal == (ULONG)STATUS_CANCELLED ||
7086 olp->Internal == (ULONG)STATUS_CONNECTION_ABORTED), "Internal status is %lx\n", olp ? olp->Internal : 0);
7087
7088 SetLastError(0xdeadbeef);
7089 key = 0xdeadbeef;
7090 num_bytes = 0xdeadbeef;
7091 olp = (WSAOVERLAPPED *)0xdeadbeef;
7092 bret = GetQueuedCompletionStatus( io_port, &num_bytes, &key, &olp, 200 );
7093 ok(bret == FALSE, "failed to get completion status %u\n", bret);
7094 ok(GetLastError() == WAIT_TIMEOUT, "Last error was %d\n", GetLastError());
7095 ok(key == 0xdeadbeef, "Key is %lu\n", key);
7096 ok(num_bytes == 0xdeadbeef, "Number of bytes transferred is %u\n", num_bytes);
7097 ok(!olp, "Overlapped structure is at %p\n", olp);
7098
7099
7100 end:
7101 if (dest != INVALID_SOCKET)
7102 closesocket(dest);
7103 if (src != INVALID_SOCKET)
7104 closesocket(src);
7105 if (connector != INVALID_SOCKET)
7106 closesocket(connector);
7107 CloseHandle(previous_port);
7108 }
7109
7110 static DWORD WINAPI inet_ntoa_thread_proc(void *param)
7111 {
7112 ULONG addr;
7113 const char *str;
7114 HANDLE *event = param;
7115
7116 addr = inet_addr("4.3.2.1");
7117 ok(addr == htonl(0x04030201), "expected 0x04030201, got %08x\n", addr);
7118 str = inet_ntoa(*(struct in_addr *)&addr);
7119 ok(!strcmp(str, "4.3.2.1"), "expected 4.3.2.1, got %s\n", str);
7120
7121 SetEvent(event[0]);
7122 WaitForSingleObject(event[1], 3000);
7123
7124 return 0;
7125 }
7126
7127 static void test_inet_ntoa(void)
7128 {
7129 ULONG addr;
7130 const char *str;
7131 HANDLE thread, event[2];
7132 DWORD tid;
7133
7134 addr = inet_addr("1.2.3.4");
7135 ok(addr == htonl(0x01020304), "expected 0x01020304, got %08x\n", addr);
7136 str = inet_ntoa(*(struct in_addr *)&addr);
7137 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
7138
7139 event[0] = CreateEventW(NULL, TRUE, FALSE, NULL);
7140 event[1] = CreateEventW(NULL, TRUE, FALSE, NULL);
7141
7142 thread = CreateThread(NULL, 0, inet_ntoa_thread_proc, event, 0, &tid);
7143 WaitForSingleObject(event[0], 3000);
7144
7145 ok(!strcmp(str, "1.2.3.4"), "expected 1.2.3.4, got %s\n", str);
7146
7147 SetEvent(event[1]);
7148 WaitForSingleObject(thread, 3000);
7149
7150 CloseHandle(event[0]);
7151 CloseHandle(event[1]);
7152 CloseHandle(thread);
7153 }
7154
7155 /**************** Main program ***************/
7156
7157 START_TEST( sock )
7158 {
7159 int i;
7160
7161 /* Leave these tests at the beginning. They depend on WSAStartup not having been
7162 * called, which is done by Init() below. */
7163 test_WithoutWSAStartup();
7164 test_WithWSAStartup();
7165
7166 Init();
7167
7168 test_inet_ntoa();
7169 test_set_getsockopt();
7170 test_so_reuseaddr();
7171 test_ip_pktinfo();
7172 test_extendedSocketOptions();
7173
7174 for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
7175 {
7176 trace ( " **** STARTING TEST %d ****\n", i );
7177 do_test ( &tests[i] );
7178 trace ( " **** TEST %d COMPLETE ****\n", i );
7179 }
7180
7181 test_UDP();
7182
7183 test_getservbyname();
7184 test_WSASocket();
7185 test_WSADuplicateSocket();
7186
7187 test_WSAAddressToStringA();
7188 test_WSAAddressToStringW();
7189
7190 test_WSAStringToAddressA();
7191 test_WSAStringToAddressW();
7192
7193 test_errors();
7194 test_listen();
7195 test_select();
7196 test_accept();
7197 test_getpeername();
7198 test_getsockname();
7199 test_inet_addr();
7200 test_addr_to_print();
7201 test_ioctlsocket();
7202 test_dns();
7203 test_gethostbyname_hack();
7204
7205 test_WSASendMsg();
7206 test_WSASendTo();
7207 test_WSARecv();
7208
7209 test_events(0);
7210 test_events(1);
7211
7212 test_ipv6only();
7213 test_GetAddrInfoW();
7214 test_getaddrinfo();
7215 test_AcceptEx();
7216 test_ConnectEx();
7217
7218 test_sioRoutingInterfaceQuery();
7219
7220 test_WSAAsyncGetServByPort();
7221 test_WSAAsyncGetServByName();
7222
7223 test_completion_port();
7224
7225 /* this is an io heavy test, do it at the end so the kernel doesn't start dropping packets */
7226 test_send();
7227 test_synchronous_WSAIoctl();
7228
7229 Exit();
7230 }
Windows API implementation