?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 553a83299288f61678d62ade87a3a2a5489a8ad8
[wine/hacks.git] / dlls / ws2_32 / tests / sock.c
blob5883078a97883d4566d876d9f8f5b4a633253239
1 /*
2 * Unit test suite for winsock functions
3 *
4 * Copyright 2002 Martin Wilck
5 * Copyright 2005 Thomas Kho
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23
24 #include <windef.h>
25 #include <winbase.h>
26 #include <winsock2.h>
27 #include <ws2tcpip.h>
28 #include <mswsock.h>
29 #include "wine/test.h"
30 #include <winnt.h>
31 #include <winerror.h>
32
33 #define MAX_CLIENTS 4 /* Max number of clients */
34 #define NUM_TESTS 4 /* Number of tests performed */
35 #define FIRST_CHAR 'A' /* First character in transferred pattern */
36 #define BIND_SLEEP 10 /* seconds to wait between attempts to bind() */
37 #define BIND_TRIES 6 /* Number of bind() attempts */
38 #define TEST_TIMEOUT 30 /* seconds to wait before killing child threads
39 after server initialization, if something hangs */
40
41 #define NUM_UDP_PEERS 3 /* Number of UDP sockets to create and test > 1 */
42
43 #define NUM_THREADS 3 /* Number of threads to run getservbyname */
44 #define NUM_QUERIES 250 /* Number of getservbyname queries per thread */
45
46 #define SERVERIP "127.0.0.1" /* IP to bind to */
47 #define SERVERPORT 9374 /* Port number to bind to */
48
49 #define wsa_ok(op, cond, msg) \
50 do { \
51 int tmp, err = 0; \
52 tmp = op; \
53 if ( !(cond tmp) ) err = WSAGetLastError(); \
54 ok ( cond tmp, msg, GetCurrentThreadId(), err); \
55 } while (0);
56
57
58 /**************** Structs and typedefs ***************/
59
60 typedef struct thread_info
61 {
62 HANDLE thread;
63 DWORD id;
64 } thread_info;
65
66 /* Information in the server about open client connections */
67 typedef struct sock_info
68 {
69 SOCKET s;
70 struct sockaddr_in addr;
71 struct sockaddr_in peer;
72 char *buf;
73 int n_recvd;
74 int n_sent;
75 } sock_info;
76
77 /* Test parameters for both server & client */
78 typedef struct test_params
79 {
80 int sock_type;
81 int sock_prot;
82 const char *inet_addr;
83 short inet_port;
84 int chunk_size;
85 int n_chunks;
86 int n_clients;
87 } test_params;
88
89 /* server-specific test parameters */
90 typedef struct server_params
91 {
92 test_params *general;
93 DWORD sock_flags;
94 int buflen;
95 } server_params;
96
97 /* client-specific test parameters */
98 typedef struct client_params
99 {
100 test_params *general;
101 DWORD sock_flags;
102 int buflen;
103 } client_params;
104
105 /* This type combines all information for setting up a test scenario */
106 typedef struct test_setup
107 {
108 test_params general;
109 LPVOID srv;
110 server_params srv_params;
111 LPVOID clt;
112 client_params clt_params;
113 } test_setup;
114
115 /* Thread local storage for server */
116 typedef struct server_memory
117 {
118 SOCKET s;
119 struct sockaddr_in addr;
120 sock_info sock[MAX_CLIENTS];
121 } server_memory;
122
123 /* Thread local storage for client */
124 typedef struct client_memory
125 {
126 SOCKET s;
127 struct sockaddr_in addr;
128 char *send_buf;
129 char *recv_buf;
130 } client_memory;
131
132 /* SelectReadThread thread parameters */
133 typedef struct select_thread_params
134 {
135 SOCKET s;
136 BOOL ReadKilled;
137 } select_thread_params;
138
139 /**************** Static variables ***************/
140
141 static DWORD tls; /* Thread local storage index */
142 static HANDLE thread[1+MAX_CLIENTS];
143 static DWORD thread_id[1+MAX_CLIENTS];
144 static HANDLE server_ready;
145 static HANDLE client_ready[MAX_CLIENTS];
146 static int client_id;
147
148 /**************** General utility functions ***************/
149
150 static int tcp_socketpair(SOCKET *src, SOCKET *dst)
151 {
152 SOCKET server = INVALID_SOCKET;
153 struct sockaddr_in addr;
154 int len;
155 int ret;
156
157 *src = INVALID_SOCKET;
158 *dst = INVALID_SOCKET;
159
160 *src = socket(AF_INET, SOCK_STREAM, 0);
161 if (*src == INVALID_SOCKET)
162 goto end;
163
164 server = socket(AF_INET, SOCK_STREAM, 0);
165 if (server == INVALID_SOCKET)
166 goto end;
167
168 memset(&addr, 0, sizeof(addr));
169 addr.sin_family = AF_INET;
170 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
171 ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
172 if (ret != 0)
173 goto end;
174
175 len = sizeof(addr);
176 ret = getsockname(server, (struct sockaddr*)&addr, &len);
177 if (ret != 0)
178 goto end;
179
180 ret = listen(server, 1);
181 if (ret != 0)
182 goto end;
183
184 ret = connect(*src, (struct sockaddr*)&addr, sizeof(addr));
185 if (ret != 0)
186 goto end;
187
188 len = sizeof(addr);
189 *dst = accept(server, (struct sockaddr*)&addr, &len);
190
191 end:
192 if (server != INVALID_SOCKET)
193 closesocket(server);
194 if (*src != INVALID_SOCKET && *dst != INVALID_SOCKET)
195 return 0;
196 closesocket(*src);
197 closesocket(*dst);
198 return -1;
199 }
200
201 static void set_so_opentype ( BOOL overlapped )
202 {
203 int optval = !overlapped, newval, len = sizeof (int);
204
205 ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
206 (LPVOID) &optval, sizeof (optval) ) == 0,
207 "setting SO_OPENTYPE failed\n" );
208 ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
209 (LPVOID) &newval, &len ) == 0,
210 "getting SO_OPENTYPE failed\n" );
211 ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
212 }
213
214 static int set_blocking ( SOCKET s, BOOL blocking )
215 {
216 u_long val = !blocking;
217 return ioctlsocket ( s, FIONBIO, &val );
218 }
219
220 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
221 {
222 char c, *p;
223 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
224 memset ( p, c, chunk_size );
225 }
226
227 static char* test_buffer ( char *buf, int chunk_size, int n_chunks )
228 {
229 char c, *p;
230 int i;
231 for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
232 {
233 for ( i = 0; i < chunk_size; i++ )
234 if ( p[i] != c ) return p + i;
235 }
236 return NULL;
237 }
238
239 /*
240 * This routine is called when a client / server does not expect any more data,
241 * but needs to acknowledge the closing of the connection (by reading 0 bytes).
242 */
243 static void read_zero_bytes ( SOCKET s )
244 {
245 char buf[256];
246 int tmp, n = 0;
247 while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
248 n += tmp;
249 ok ( n <= 0, "garbage data received: %d bytes\n", n );
250 }
251
252 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int sendlen )
253 {
254 char* last = buf + buflen, *p;
255 int n = 1;
256 for ( p = buf; n > 0 && p < last; p += n )
257 n = send ( s, p, min ( sendlen, last - p ), 0 );
258 wsa_ok ( n, 0 <=, "do_synchronous_send (%x): error %d\n" );
259 return p - buf;
260 }
261
262 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int recvlen )
263 {
264 char* last = buf + buflen, *p;
265 int n = 1;
266 for ( p = buf; n > 0 && p < last; p += n )
267 n = recv ( s, p, min ( recvlen, last - p ), 0 );
268 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
269 return p - buf;
270 }
271
272 static int do_synchronous_recvfrom ( SOCKET s, char *buf, int buflen,int flags,struct sockaddr *from, socklen_t *fromlen, int recvlen )
273 {
274 char* last = buf + buflen, *p;
275 int n = 1;
276 for ( p = buf; n > 0 && p < last; p += n )
277 n = recvfrom ( s, p, min ( recvlen, last - p ), 0, from, fromlen );
278 wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
279 return p - buf;
280 }
281
282 /*
283 * Call this routine right after thread startup.
284 * SO_OPENTYPE must by 0, regardless what the server did.
285 */
286 static void check_so_opentype (void)
287 {
288 int tmp = 1, len;
289 len = sizeof (tmp);
290 getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
291 ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
292 }
293
294 /**************** Server utility functions ***************/
295
296 /*
297 * Even if we have closed our server socket cleanly,
298 * the OS may mark the address "in use" for some time -
299 * this happens with native Linux apps, too.
300 */
301 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
302 {
303 int err, wsaerr = 0, n_try = BIND_TRIES;
304
305 while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
306 ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
307 n_try-- >= 0)
308 {
309 trace ( "address in use, waiting ...\n" );
310 Sleep ( 1000 * BIND_SLEEP );
311 }
312 ok ( err == 0, "failed to bind: %d\n", wsaerr );
313 }
314
315 static void server_start ( server_params *par )
316 {
317 int i;
318 test_params *gen = par->general;
319 server_memory *mem = (LPVOID) LocalAlloc ( LPTR, sizeof (server_memory));
320
321 TlsSetValue ( tls, mem );
322 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
323 NULL, 0, par->sock_flags );
324 ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
325
326 mem->addr.sin_family = AF_INET;
327 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
328 mem->addr.sin_port = htons ( gen->inet_port );
329
330 for (i = 0; i < MAX_CLIENTS; i++)
331 {
332 mem->sock[i].s = INVALID_SOCKET;
333 mem->sock[i].buf = (LPVOID) LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
334 mem->sock[i].n_recvd = 0;
335 mem->sock[i].n_sent = 0;
336 }
337
338 if ( gen->sock_type == SOCK_STREAM )
339 do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
340 }
341
342 static void server_stop (void)
343 {
344 int i;
345 server_memory *mem = TlsGetValue ( tls );
346
347 for (i = 0; i < MAX_CLIENTS; i++ )
348 {
349 LocalFree ( (HANDLE) mem->sock[i].buf );
350 if ( mem->sock[i].s != INVALID_SOCKET )
351 closesocket ( mem->sock[i].s );
352 }
353 ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
354 LocalFree ( (HANDLE) mem );
355 ExitThread ( GetCurrentThreadId () );
356 }
357
358 /**************** Client utilitiy functions ***************/
359
360 static void client_start ( client_params *par )
361 {
362 test_params *gen = par->general;
363 client_memory *mem = (LPVOID) LocalAlloc (LPTR, sizeof (client_memory));
364
365 TlsSetValue ( tls, mem );
366
367 WaitForSingleObject ( server_ready, INFINITE );
368
369 mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
370 NULL, 0, par->sock_flags );
371
372 mem->addr.sin_family = AF_INET;
373 mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
374 mem->addr.sin_port = htons ( gen->inet_port );
375
376 ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
377
378 mem->send_buf = (LPVOID) LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
379 mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
380 fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
381
382 SetEvent ( client_ready[client_id] );
383 /* Wait for the other clients to come up */
384 WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
385 }
386
387 static void client_stop (void)
388 {
389 client_memory *mem = TlsGetValue ( tls );
390 wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%x): %d\n" );
391 LocalFree ( (HANDLE) mem->send_buf );
392 LocalFree ( (HANDLE) mem );
393 ExitThread(0);
394 }
395
396 /**************** Servers ***************/
397
398 /*
399 * simple_server: A very basic server doing synchronous IO.
400 */
401 static VOID WINAPI simple_server ( server_params *par )
402 {
403 test_params *gen = par->general;
404 server_memory *mem;
405 int n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
406 id = GetCurrentThreadId();
407 char *p;
408
409 trace ( "simple_server (%x) starting\n", id );
410
411 set_so_opentype ( FALSE ); /* non-overlapped */
412 server_start ( par );
413 mem = TlsGetValue ( tls );
414
415 wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
416 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%x): listen failed: %d\n");
417
418 trace ( "simple_server (%x) ready\n", id );
419 SetEvent ( server_ready ); /* notify clients */
420
421 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
422 {
423 trace ( "simple_server (%x): waiting for client\n", id );
424
425 /* accept a single connection */
426 tmp = sizeof ( mem->sock[0].peer );
427 mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
428 wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%x): accept failed: %d\n" );
429
430 ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
431 "simple_server (%x): strange peer address\n", id );
432
433 /* Receive data & check it */
434 n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
435 ok ( n_recvd == n_expected,
436 "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
437 p = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
438 ok ( p == NULL, "simple_server (%x): test pattern error: %d\n", id, p - mem->sock[0].buf);
439
440 /* Echo data back */
441 n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
442 ok ( n_sent == n_expected,
443 "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
444
445 /* cleanup */
446 read_zero_bytes ( mem->sock[0].s );
447 wsa_ok ( closesocket ( mem->sock[0].s ), 0 ==, "simple_server (%x): closesocket error: %d\n" );
448 mem->sock[0].s = INVALID_SOCKET;
449 }
450
451 trace ( "simple_server (%x) exiting\n", id );
452 server_stop ();
453 }
454
455 /*
456 * select_server: A non-blocking server.
457 */
458 static VOID WINAPI select_server ( server_params *par )
459 {
460 test_params *gen = par->general;
461 server_memory *mem;
462 int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
463 id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
464 n_set, delta, n_ready;
465 char *p;
466 struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
467 fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
468
469 trace ( "select_server (%x) starting\n", id );
470
471 set_so_opentype ( FALSE ); /* non-overlapped */
472 server_start ( par );
473 mem = TlsGetValue ( tls );
474
475 wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
476 wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%x): listen failed: %d\n");
477
478 trace ( "select_server (%x) ready\n", id );
479 SetEvent ( server_ready ); /* notify clients */
480
481 FD_ZERO ( &fds_openrecv );
482 FD_ZERO ( &fds_recv );
483 FD_ZERO ( &fds_send );
484 FD_ZERO ( &fds_opensend );
485
486 FD_SET ( mem->s, &fds_openrecv );
487
488 while(1)
489 {
490 fds_recv = fds_openrecv;
491 fds_send = fds_opensend;
492
493 n_set = 0;
494
495 wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
496 "select_server (%x): select() failed: %d\n" );
497
498 /* check for incoming requests */
499 if ( FD_ISSET ( mem->s, &fds_recv ) ) {
500 n_set += 1;
501
502 trace ( "select_server (%x): accepting client connection\n", id );
503
504 /* accept a single connection */
505 tmp = sizeof ( mem->sock[n_connections].peer );
506 mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
507 wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%x): accept() failed: %d\n" );
508
509 ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
510 "select_server (%x): strange peer address\n", id );
511
512 /* add to list of open connections */
513 FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
514 FD_SET ( mem->sock[n_connections].s, &fds_opensend );
515
516 n_connections++;
517 }
518
519 /* handle open requests */
520
521 for ( i = 0; i < n_connections; i++ )
522 {
523 if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
524 n_set += 1;
525
526 if ( mem->sock[i].n_recvd < n_expected ) {
527 /* Receive data & check it */
528 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 );
529 ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
530 mem->sock[i].n_recvd += n_recvd;
531
532 if ( mem->sock[i].n_recvd == n_expected ) {
533 p = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
534 ok ( p == NULL, "select_server (%x): test pattern error: %d\n", id, p - mem->sock[i].buf );
535 FD_CLR ( mem->sock[i].s, &fds_openrecv );
536 }
537
538 ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
539 }
540 }
541
542 /* only echo back what we've received */
543 delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
544
545 if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
546 n_set += 1;
547
548 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
549 /* Echo data back */
550 n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
551 ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
552 mem->sock[i].n_sent += n_sent;
553
554 if ( mem->sock[i].n_sent == n_expected ) {
555 FD_CLR ( mem->sock[i].s, &fds_opensend );
556 }
557
558 ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
559 }
560 }
561 }
562
563 /* check that select returned the correct number of ready sockets */
564 ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
565
566 /* check if all clients are done */
567 if ( ( fds_opensend.fd_count == 0 )
568 && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
569 && ( n_connections == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
570 break;
571 }
572 }
573
574 for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
575 {
576 /* cleanup */
577 read_zero_bytes ( mem->sock[i].s );
578 wsa_ok ( closesocket ( mem->sock[i].s ), 0 ==, "select_server (%x): closesocket error: %d\n" );
579 mem->sock[i].s = INVALID_SOCKET;
580 }
581
582 trace ( "select_server (%x) exiting\n", id );
583 server_stop ();
584 }
585
586 /**************** Clients ***************/
587
588 /*
589 * simple_client: A very basic client doing synchronous IO.
590 */
591 static VOID WINAPI simple_client ( client_params *par )
592 {
593 test_params *gen = par->general;
594 client_memory *mem;
595 int n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
596 char *p;
597
598 id = GetCurrentThreadId();
599 trace ( "simple_client (%x): starting\n", id );
600 /* wait here because we want to call set_so_opentype before creating a socket */
601 WaitForSingleObject ( server_ready, INFINITE );
602 trace ( "simple_client (%x): server ready\n", id );
603
604 check_so_opentype ();
605 set_so_opentype ( FALSE ); /* non-overlapped */
606 client_start ( par );
607 mem = TlsGetValue ( tls );
608
609 /* Connect */
610 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
611 0 ==, "simple_client (%x): connect error: %d\n" );
612 ok ( set_blocking ( mem->s, TRUE ) == 0,
613 "simple_client (%x): failed to set blocking mode\n", id );
614 trace ( "simple_client (%x) connected\n", id );
615
616 /* send data to server */
617 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, par->buflen );
618 ok ( n_sent == n_expected,
619 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
620
621 /* shutdown send direction */
622 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
623
624 /* Receive data echoed back & check it */
625 n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, par->buflen );
626 ok ( n_recvd == n_expected,
627 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
628
629 /* check data */
630 p = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
631 ok ( p == NULL, "simple_client (%x): test pattern error: %d\n", id, p - mem->recv_buf);
632
633 /* cleanup */
634 read_zero_bytes ( mem->s );
635 trace ( "simple_client (%x) exiting\n", id );
636 client_stop ();
637 }
638
639 /*
640 * simple_mixed_client: mixing send and recvfrom
641 */
642 static VOID WINAPI simple_mixed_client ( client_params *par )
643 {
644 test_params *gen = par->general;
645 client_memory *mem;
646 int n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
647 char *p;
648 socklen_t fromLen = sizeof(mem->addr);
649 struct sockaddr test;
650
651 id = GetCurrentThreadId();
652 trace ( "simple_client (%x): starting\n", id );
653 /* wait here because we want to call set_so_opentype before creating a socket */
654 WaitForSingleObject ( server_ready, INFINITE );
655 trace ( "simple_client (%x): server ready\n", id );
656
657 check_so_opentype ();
658 set_so_opentype ( FALSE ); /* non-overlapped */
659 client_start ( par );
660 mem = TlsGetValue ( tls );
661
662 /* Connect */
663 wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
664 0 ==, "simple_client (%x): connect error: %d\n" );
665 ok ( set_blocking ( mem->s, TRUE ) == 0,
666 "simple_client (%x): failed to set blocking mode\n", id );
667 trace ( "simple_client (%x) connected\n", id );
668
669 /* send data to server */
670 n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, par->buflen );
671 ok ( n_sent == n_expected,
672 "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
673
674 /* shutdown send direction */
675 wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
676
677 /* this shouldn't change, since lpFrom, is not updated on
678 connection oriented sockets - exposed by bug 11640
679 */
680 ((struct sockaddr_in*)&test)->sin_addr.s_addr = inet_addr("0.0.0.0");
681
682 /* Receive data echoed back & check it */
683 n_recvd = do_synchronous_recvfrom ( mem->s,
684 mem->recv_buf,
685 n_expected,
686 0,
687 (struct sockaddr *)&test,
688 &fromLen,
689 par->buflen );
690 ok ( n_recvd == n_expected,
691 "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
692
693 /* check that lpFrom was not updated */
694 ok(0 ==
695 strcmp(
696 inet_ntoa(((struct sockaddr_in*)&test)->sin_addr),
697 "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
698
699 /* check data */
700 p = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
701 ok ( p == NULL, "simple_client (%x): test pattern error: %d\n", id, p - mem->recv_buf);
702
703 /* cleanup */
704 read_zero_bytes ( mem->s );
705 trace ( "simple_client (%x) exiting\n", id );
706 client_stop ();
707 }
708
709 /*
710 * event_client: An event-driven client
711 */
712 static void WINAPI event_client ( client_params *par )
713 {
714 test_params *gen = par->general;
715 client_memory *mem;
716 int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
717 tmp, err, n;
718 HANDLE event;
719 WSANETWORKEVENTS wsa_events;
720 char *send_last, *recv_last, *send_p, *recv_p;
721 long mask = FD_READ | FD_WRITE | FD_CLOSE;
722
723 trace ( "event_client (%x): starting\n", id );
724 client_start ( par );
725 trace ( "event_client (%x): server ready\n", id );
726
727 mem = TlsGetValue ( tls );
728
729 /* Prepare event notification for connect, makes socket nonblocking */
730 event = WSACreateEvent ();
731 WSAEventSelect ( mem->s, event, FD_CONNECT );
732 tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
733 if ( tmp != 0 ) {
734 err = WSAGetLastError ();
735 ok ( err == WSAEWOULDBLOCK, "event_client (%x): connect error: %d\n", id, err );
736 tmp = WaitForSingleObject ( event, INFINITE );
737 ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
738 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
739 wsa_ok ( err, 0 ==, "event_client (%x): WSAEnumNetworkEvents error: %d\n" );
740 err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
741 ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
742 if ( err ) goto out;
743 }
744
745 trace ( "event_client (%x) connected\n", id );
746
747 WSAEventSelect ( mem->s, event, mask );
748
749 recv_p = mem->recv_buf;
750 recv_last = mem->recv_buf + n_expected;
751 send_p = mem->send_buf;
752 send_last = mem->send_buf + n_expected;
753
754 while ( TRUE )
755 {
756 err = WaitForSingleObject ( event, INFINITE );
757 ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
758
759 err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
760 wsa_ok ( err, 0 ==, "event_client (%x): WSAEnumNetworkEvents error: %d\n" );
761
762 if ( wsa_events.lNetworkEvents & FD_WRITE )
763 {
764 err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
765 ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
766
767 if ( err== 0 )
768 do
769 {
770 n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
771 if ( n < 0 )
772 {
773 err = WSAGetLastError ();
774 ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
775 }
776 else
777 send_p += n;
778 }
779 while ( n >= 0 && send_p < send_last );
780
781 if ( send_p == send_last )
782 {
783 trace ( "event_client (%x): all data sent - shutdown\n", id );
784 shutdown ( mem->s, SD_SEND );
785 mask &= ~FD_WRITE;
786 WSAEventSelect ( mem->s, event, mask );
787 }
788 }
789 if ( wsa_events.lNetworkEvents & FD_READ )
790 {
791 err = wsa_events.iErrorCode[ FD_READ_BIT ];
792 ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
793 if ( err != 0 ) break;
794
795 /* First read must succeed */
796 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
797 wsa_ok ( n, 0 <=, "event_client (%x): recv error: %d\n" );
798
799 while ( n >= 0 ) {
800 recv_p += n;
801 if ( recv_p == recv_last )
802 {
803 mask &= ~FD_READ;
804 trace ( "event_client (%x): all data received\n", id );
805 WSAEventSelect ( mem->s, event, mask );
806 break;
807 }
808 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
809 if ( n < 0 && ( err = WSAGetLastError()) != WSAEWOULDBLOCK )
810 ok ( 0, "event_client (%x): read error: %d\n", id, err );
811
812 }
813 }
814 if ( wsa_events.lNetworkEvents & FD_CLOSE )
815 {
816 trace ( "event_client (%x): close event\n", id );
817 err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
818 ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
819 break;
820 }
821 }
822
823 ok ( send_p == send_last,
824 "simple_client (%x): sent less data than expected: %d of %d\n",
825 id, send_p - mem->send_buf, n_expected );
826 ok ( recv_p == recv_last,
827 "simple_client (%x): received less data than expected: %d of %d\n",
828 id, recv_p - mem->recv_buf, n_expected );
829 recv_p = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
830 ok ( recv_p == NULL, "event_client (%x): test pattern error: %d\n", id, recv_p - mem->recv_buf);
831
832 out:
833 WSACloseEvent ( event );
834 trace ( "event_client (%x) exiting\n", id );
835 client_stop ();
836 }
837
838 /**************** Main program utility functions ***************/
839
840 static void Init (void)
841 {
842 WORD ver = MAKEWORD (2, 2);
843 WSADATA data;
844
845 ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
846 tls = TlsAlloc();
847 }
848
849 static void Exit (void)
850 {
851 INT ret, err;
852 TlsFree ( tls );
853 ret = WSACleanup();
854 err = WSAGetLastError();
855 ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
856 ret = WSACleanup();
857 err = WSAGetLastError();
858 ok ( ret == SOCKET_ERROR && err == WSANOTINITIALISED,
859 "WSACleanup returned %d GetLastError is %d\n", ret, err);
860 }
861
862 static void StartServer (LPTHREAD_START_ROUTINE routine,
863 test_params *general, server_params *par)
864 {
865 par->general = general;
866 thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
867 ok ( thread[0] != NULL, "Failed to create server thread\n" );
868 }
869
870 static void StartClients (LPTHREAD_START_ROUTINE routine,
871 test_params *general, client_params *par)
872 {
873 int i;
874 par->general = general;
875 for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
876 {
877 client_id = i - 1;
878 thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
879 ok ( thread[i] != NULL, "Failed to create client thread\n" );
880 /* Make sure the client is up and running */
881 WaitForSingleObject ( client_ready[client_id], INFINITE );
882 };
883 }
884
885 static void do_test( test_setup *test )
886 {
887 DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
888 DWORD wait;
889
890 server_ready = CreateEventA ( NULL, TRUE, FALSE, NULL );
891 for (i = 0; i <= n; i++)
892 client_ready[i] = CreateEventA ( NULL, TRUE, FALSE, NULL );
893
894 StartServer ( test->srv, &test->general, &test->srv_params );
895 StartClients ( test->clt, &test->general, &test->clt_params );
896 WaitForSingleObject ( server_ready, INFINITE );
897
898 wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
899 ok ( wait <= WAIT_OBJECT_0 + n ,
900 "some threads have not completed: %x\n", wait );
901
902 if ( ! ( wait <= WAIT_OBJECT_0 + n ) )
903 {
904 for (i = 0; i <= n; i++)
905 {
906 trace ("terminating thread %08x\n", thread_id[i]);
907 if ( WaitForSingleObject ( thread[i], 0 ) != WAIT_OBJECT_0 )
908 TerminateThread ( thread [i], 0 );
909 }
910 }
911 CloseHandle ( server_ready );
912 for (i = 0; i <= n; i++)
913 CloseHandle ( client_ready[i] );
914 }
915
916 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
917 /* optname = SO_LINGER */
918 LINGER linger_testvals[] = {
919 {0,0},
920 {0,73},
921 {1,0},
922 {5,189}
923 };
924
925 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
926 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
927 bug in the linux kernel (fixed in 2.6.8) */
928 #define SOCKTIMEOUT2 997000 /* 997 seconds */
929
930 static void test_set_getsockopt(void)
931 {
932 SOCKET s;
933 int i, err, lasterr;
934 int timeout;
935 LINGER lingval;
936 int size;
937
938 s = socket(AF_INET, SOCK_STREAM, 0);
939 ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
940 if( s == INVALID_SOCKET) return;
941 /* SO_RCVTIMEO */
942 timeout = SOCKTIMEOUT1;
943 size = sizeof(timeout);
944 err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
945 if( !err)
946 err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
947 ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
948 ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
949 /* SO_SNDTIMEO */
950 timeout = SOCKTIMEOUT2; /* 54 seconds. See remark above */
951 size = sizeof(timeout);
952 err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
953 if( !err)
954 err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
955 ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
956 ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
957 /* SO_LINGER */
958 for( i = 0; i < sizeof(linger_testvals)/sizeof(LINGER);i++) {
959 size = sizeof(lingval);
960 lingval = linger_testvals[i];
961 err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, size);
962 if( !err)
963 err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, &size);
964 ok( !err, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
965 ok( !lingval.l_onoff == !linger_testvals[i].l_onoff &&
966 (lingval.l_linger == linger_testvals[i].l_linger ||
967 (!lingval.l_linger && !linger_testvals[i].l_onoff))
968 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i,
969 lingval.l_onoff, lingval.l_linger,
970 linger_testvals[i].l_onoff, linger_testvals[i].l_linger);
971 }
972 /* Test for erroneously passing a value instead of a pointer as optval */
973 size = sizeof(char);
974 err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
975 ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
976 "instead of failing.\n");
977 lasterr = WSAGetLastError();
978 ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
979 "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
980 lasterr, WSAEFAULT);
981 closesocket(s);
982 }
983
984 static void test_so_reuseaddr(void)
985 {
986 struct sockaddr_in saddr;
987 SOCKET s1,s2;
988 unsigned int rc,reuse;
989 int size;
990
991 saddr.sin_family = AF_INET;
992 saddr.sin_port = htons(9375);
993 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
994
995 s1=socket(AF_INET, SOCK_STREAM, 0);
996 ok(s1!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
997 rc = bind(s1, (struct sockaddr*)&saddr, sizeof(saddr));
998 ok(rc!=SOCKET_ERROR, "bind(s1) failed error: %d\n", WSAGetLastError());
999
1000 s2=socket(AF_INET, SOCK_STREAM, 0);
1001 ok(s2!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1002
1003 reuse=0x1234;
1004 size=sizeof(reuse);
1005 rc=getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size );
1006 ok(rc==0 && reuse==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc,reuse);
1007
1008 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1009 ok(rc==SOCKET_ERROR, "bind() succeeded\n");
1010
1011 reuse = 1;
1012 rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
1013 ok(rc==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1014
1015 todo_wine {
1016 rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1017 ok(rc==0, "bind() failed error: %d\n", WSAGetLastError());
1018 }
1019
1020 closesocket(s2);
1021 closesocket(s1);
1022 }
1023
1024 /************* Array containing the tests to run **********/
1025
1026 #define STD_STREAM_SOCKET \
1027 SOCK_STREAM, \
1028 0, \
1029 SERVERIP, \
1030 SERVERPORT
1031
1032 static test_setup tests [NUM_TESTS] =
1033 {
1034 /* Test 0: synchronous client and server */
1035 {
1036 {
1037 STD_STREAM_SOCKET,
1038 2048,
1039 16,
1040 2
1041 },
1042 simple_server,
1043 {
1044 NULL,
1045 0,
1046 64
1047 },
1048 simple_client,
1049 {
1050 NULL,
1051 0,
1052 128
1053 }
1054 },
1055 /* Test 1: event-driven client, synchronous server */
1056 {
1057 {
1058 STD_STREAM_SOCKET,
1059 2048,
1060 16,
1061 2
1062 },
1063 simple_server,
1064 {
1065 NULL,
1066 0,
1067 64
1068 },
1069 event_client,
1070 {
1071 NULL,
1072 WSA_FLAG_OVERLAPPED,
1073 128
1074 }
1075 },
1076 /* Test 2: synchronous client, non-blocking server via select() */
1077 {
1078 {
1079 STD_STREAM_SOCKET,
1080 2048,
1081 16,
1082 2
1083 },
1084 select_server,
1085 {
1086 NULL,
1087 0,
1088 64
1089 },
1090 simple_client,
1091 {
1092 NULL,
1093 0,
1094 128
1095 }
1096 },
1097 /* Test 3: synchronous mixed client and server */
1098 {
1099 {
1100 STD_STREAM_SOCKET,
1101 2048,
1102 16,
1103 2
1104 },
1105 simple_server,
1106 {
1107 NULL,
1108 0,
1109 64
1110 },
1111 simple_mixed_client,
1112 {
1113 NULL,
1114 0,
1115 128
1116 }
1117 }
1118 };
1119
1120 static void test_UDP(void)
1121 {
1122 /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
1123 possible that this test fails due to dropped packets. */
1124
1125 /* peer 0 receives data from all other peers */
1126 struct sock_info peer[NUM_UDP_PEERS];
1127 char buf[16];
1128 int ss, i, n_recv, n_sent;
1129
1130 memset (buf,0,sizeof(buf));
1131 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
1132 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
1133
1134 peer[i].addr.sin_family = AF_INET;
1135 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
1136
1137 if ( i == 0 ) {
1138 peer[i].addr.sin_port = htons ( SERVERPORT );
1139 } else {
1140 peer[i].addr.sin_port = htons ( 0 );
1141 }
1142
1143 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
1144
1145 /* test getsockname() to get peer's port */
1146 ss = sizeof ( peer[i].addr );
1147 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
1148 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
1149 }
1150
1151 /* test getsockname() */
1152 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
1153
1154 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
1155 /* send client's ip */
1156 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
1157 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
1158 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
1159 }
1160
1161 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
1162 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
1163 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
1164 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
1165 }
1166 }
1167
1168 static void WINAPI do_getservbyname( HANDLE *starttest )
1169 {
1170 struct {
1171 const char *name;
1172 const char *proto;
1173 int port;
1174 } serv[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
1175
1176 int i, j;
1177 struct servent *pserv[2];
1178
1179 ok ( WaitForSingleObject ( *starttest, TEST_TIMEOUT * 1000 ) != WAIT_TIMEOUT, "test_getservbyname: timeout waiting for start signal\n");
1180
1181 /* ensure that necessary buffer resizes are completed */
1182 for ( j = 0; j < 2; j++) {
1183 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1184 }
1185
1186 for ( i = 0; i < NUM_QUERIES / 2; i++ ) {
1187 for ( j = 0; j < 2; j++ ) {
1188 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1189 ok ( pserv[j] != NULL, "getservbyname could not retrieve information for %s: %d\n", serv[j].name, WSAGetLastError() );
1190 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) );
1191 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 );
1192 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 );
1193 }
1194
1195 ok ( pserv[0] == pserv[1], "getservbyname: winsock resized servent buffer when not necessary\n" );
1196 }
1197 }
1198
1199 static void test_getservbyname(void)
1200 {
1201 int i;
1202 HANDLE starttest, thread[NUM_THREADS];
1203 DWORD thread_id[NUM_THREADS];
1204
1205 starttest = CreateEvent ( NULL, 1, 0, "test_getservbyname_starttest" );
1206
1207 /* create threads */
1208 for ( i = 0; i < NUM_THREADS; i++ ) {
1209 thread[i] = CreateThread ( NULL, 0, (LPTHREAD_START_ROUTINE) &do_getservbyname, &starttest, 0, &thread_id[i] );
1210 }
1211
1212 /* signal threads to start */
1213 SetEvent ( starttest );
1214
1215 for ( i = 0; i < NUM_THREADS; i++) {
1216 WaitForSingleObject ( thread[i], TEST_TIMEOUT * 1000 );
1217 }
1218 }
1219
1220 static void test_WSASocket(void)
1221 {
1222 SOCKET sock = INVALID_SOCKET;
1223 WSAPROTOCOL_INFOA *pi;
1224 int providers[] = {6, 0};
1225 int ret, err;
1226 UINT pi_size;
1227
1228 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
1229 * to avoid a crash on win98.
1230 */
1231 pi_size = 0;
1232 ret = WSAEnumProtocolsA(providers, NULL, &pi_size);
1233 ok(ret == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
1234 ret);
1235 err = WSAGetLastError();
1236 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
1237 err, WSAENOBUFS);
1238
1239 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
1240 ok(pi != NULL, "Failed to allocate memory\n");
1241 if (pi == NULL) {
1242 skip("Can't continue without memory.\n");
1243 return;
1244 }
1245
1246 ret = WSAEnumProtocolsA(providers, pi, &pi_size);
1247 ok(ret != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
1248 WSAGetLastError());
1249
1250 if (ret == 0) {
1251 skip("No protocols enumerated.\n");
1252 HeapFree(GetProcessHeap(), 0, pi);
1253 return;
1254 }
1255
1256 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
1257 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
1258 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
1259 WSAGetLastError());
1260
1261 closesocket(sock);
1262 HeapFree(GetProcessHeap(), 0, pi);
1263 }
1264
1265 static void test_WSAAddressToStringA(void)
1266 {
1267 INT ret;
1268 DWORD len;
1269 int GLE;
1270 SOCKADDR_IN sockaddr;
1271 CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1272
1273 CHAR expect1[] = "0.0.0.0";
1274 CHAR expect2[] = "255.255.255.255";
1275 CHAR expect3[] = "0.0.0.0:65535";
1276 CHAR expect4[] = "255.255.255.255:65535";
1277
1278 len = 0;
1279
1280 sockaddr.sin_family = AF_INET;
1281 sockaddr.sin_port = 0;
1282 sockaddr.sin_addr.s_addr = 0;
1283
1284 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1285 GLE = WSAGetLastError();
1286 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
1287 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1288 GLE, ret );
1289
1290 len = sizeof(address);
1291
1292 sockaddr.sin_family = AF_INET;
1293 sockaddr.sin_port = 0;
1294 sockaddr.sin_addr.s_addr = 0;
1295
1296 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1297 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1298
1299 ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
1300
1301 len = sizeof(address);
1302
1303 sockaddr.sin_family = AF_INET;
1304 sockaddr.sin_port = 0;
1305 sockaddr.sin_addr.s_addr = 0xffffffff;
1306
1307 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1308 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1309
1310 ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
1311
1312 len = sizeof(address);
1313
1314 sockaddr.sin_family = AF_INET;
1315 sockaddr.sin_port = 0xffff;
1316 sockaddr.sin_addr.s_addr = 0;
1317
1318 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1319 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1320
1321 ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
1322
1323 len = sizeof(address);
1324
1325 sockaddr.sin_family = AF_INET;
1326 sockaddr.sin_port = 0xffff;
1327 sockaddr.sin_addr.s_addr = 0xffffffff;
1328
1329 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1330 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1331
1332 ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
1333 }
1334
1335 static void test_WSAAddressToStringW(void)
1336 {
1337 INT ret;
1338 DWORD len;
1339 int GLE;
1340 SOCKADDR_IN sockaddr;
1341 WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1342
1343 WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
1344 WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1345 WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
1346 WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1347 '6', '5', '5', '3', '5', 0 };
1348
1349 len = 0;
1350
1351 sockaddr.sin_family = AF_INET;
1352 sockaddr.sin_port = 0;
1353 sockaddr.sin_addr.s_addr = 0;
1354
1355 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1356 GLE = WSAGetLastError();
1357 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
1358 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1359 GLE, ret );
1360
1361 len = sizeof(address);
1362
1363 sockaddr.sin_family = AF_INET;
1364 sockaddr.sin_port = 0;
1365 sockaddr.sin_addr.s_addr = 0;
1366
1367 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1368 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1369
1370 ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
1371
1372 len = sizeof(address);
1373
1374 sockaddr.sin_family = AF_INET;
1375 sockaddr.sin_port = 0;
1376 sockaddr.sin_addr.s_addr = 0xffffffff;
1377
1378 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1379 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1380
1381 ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
1382
1383 len = sizeof(address);
1384
1385 sockaddr.sin_family = AF_INET;
1386 sockaddr.sin_port = 0xffff;
1387 sockaddr.sin_addr.s_addr = 0;
1388
1389 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1390 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1391
1392 ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
1393
1394 len = sizeof(address);
1395
1396 sockaddr.sin_family = AF_INET;
1397 sockaddr.sin_port = 0xffff;
1398 sockaddr.sin_addr.s_addr = 0xffffffff;
1399
1400 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1401 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1402
1403 ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
1404 }
1405
1406 static void test_WSAStringToAddressA(void)
1407 {
1408 INT ret, len;
1409 SOCKADDR_IN sockaddr;
1410 SOCKADDR_IN6 sockaddr6;
1411 int GLE;
1412
1413 CHAR address1[] = "0.0.0.0";
1414 CHAR address2[] = "127.127.127.127";
1415 CHAR address3[] = "255.255.255.255";
1416 CHAR address4[] = "127.127.127.127:65535";
1417 CHAR address5[] = "255.255.255.255:65535";
1418 CHAR address6[] = "::1";
1419 CHAR address7[] = "[::1]";
1420 CHAR address8[] = "[::1]:65535";
1421
1422 len = 0;
1423 sockaddr.sin_family = AF_INET;
1424
1425 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1426 ok( ret == SOCKET_ERROR, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
1427 WSAGetLastError() );
1428
1429 len = sizeof(sockaddr);
1430 sockaddr.sin_port = 0;
1431 sockaddr.sin_addr.s_addr = 0;
1432
1433 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1434 ok( !ret && sockaddr.sin_addr.s_addr == 0,
1435 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1436
1437 len = sizeof(sockaddr);
1438 sockaddr.sin_port = 0;
1439 sockaddr.sin_addr.s_addr = 0;
1440
1441 ret = WSAStringToAddressA( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1442 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
1443 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1444
1445 len = sizeof(sockaddr);
1446 sockaddr.sin_port = 0;
1447 sockaddr.sin_addr.s_addr = 0;
1448
1449 ret = WSAStringToAddressA( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1450 GLE = WSAGetLastError();
1451 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
1452 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1453 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
1454
1455 len = sizeof(sockaddr);
1456 sockaddr.sin_port = 0;
1457 sockaddr.sin_addr.s_addr = 0;
1458
1459 ret = WSAStringToAddressA( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1460 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
1461 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1462
1463 len = sizeof(sockaddr);
1464 sockaddr.sin_port = 0;
1465 sockaddr.sin_addr.s_addr = 0;
1466
1467 ret = WSAStringToAddressA( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1468 GLE = WSAGetLastError();
1469 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
1470 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1471 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
1472
1473 len = sizeof(sockaddr6);
1474 memset(&sockaddr6, 0, len);
1475 sockaddr6.sin6_family = AF_INET6;
1476
1477 ret = WSAStringToAddressA( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1478 &len );
1479 GLE = WSAGetLastError();
1480 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1481 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
1482
1483 len = sizeof(sockaddr6);
1484 memset(&sockaddr6, 0, len);
1485 sockaddr6.sin6_family = AF_INET6;
1486
1487 ret = WSAStringToAddressA( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1488 &len );
1489 GLE = WSAGetLastError();
1490 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1491 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
1492
1493 len = sizeof(sockaddr6);
1494 memset(&sockaddr6, 0, len);
1495 sockaddr6.sin6_family = AF_INET6;
1496
1497 ret = WSAStringToAddressA( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1498 &len );
1499 GLE = WSAGetLastError();
1500 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
1501 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1502 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
1503
1504 }
1505
1506 static void test_WSAStringToAddressW(void)
1507 {
1508 INT ret, len;
1509 SOCKADDR_IN sockaddr;
1510 SOCKADDR_IN6 sockaddr6;
1511 int GLE;
1512
1513 WCHAR address1[] = { '0','.','0','.','0','.','0', 0 };
1514 WCHAR address2[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
1515 WCHAR address3[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1516 WCHAR address4[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
1517 ':', '6', '5', '5', '3', '5', 0 };
1518 WCHAR address5[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1519 '6', '5', '5', '3', '5', 0 };
1520 WCHAR address6[] = {':',':','1','\0'};
1521 WCHAR address7[] = {'[',':',':','1',']','\0'};
1522 WCHAR address8[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
1523
1524 len = 0;
1525 sockaddr.sin_family = AF_INET;
1526
1527 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1528 ok( ret == SOCKET_ERROR, "WSAStringToAddressW() failed unexpectedly: %d\n",
1529 WSAGetLastError() );
1530
1531 len = sizeof(sockaddr);
1532 sockaddr.sin_port = 0;
1533 sockaddr.sin_addr.s_addr = 0;
1534
1535 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1536 ok( !ret && sockaddr.sin_addr.s_addr == 0,
1537 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1538
1539 len = sizeof(sockaddr);
1540 sockaddr.sin_port = 0;
1541 sockaddr.sin_addr.s_addr = 0;
1542
1543 ret = WSAStringToAddressW( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1544 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
1545 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1546
1547 len = sizeof(sockaddr);
1548 sockaddr.sin_port = 0;
1549 sockaddr.sin_addr.s_addr = 0;
1550
1551 ret = WSAStringToAddressW( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1552 GLE = WSAGetLastError();
1553 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
1554 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1555 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
1556
1557 len = sizeof(sockaddr);
1558 sockaddr.sin_port = 0;
1559 sockaddr.sin_addr.s_addr = 0;
1560
1561 ret = WSAStringToAddressW( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1562 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
1563 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1564
1565 len = sizeof(sockaddr);
1566 sockaddr.sin_port = 0;
1567 sockaddr.sin_addr.s_addr = 0;
1568
1569 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1570 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
1571 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1572 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
1573
1574 len = sizeof(sockaddr6);
1575 memset(&sockaddr6, 0, len);
1576 sockaddr6.sin6_family = AF_INET6;
1577
1578 ret = WSAStringToAddressW( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1579 &len );
1580 GLE = WSAGetLastError();
1581 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1582 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
1583
1584 len = sizeof(sockaddr6);
1585 memset(&sockaddr6, 0, len);
1586 sockaddr6.sin6_family = AF_INET6;
1587
1588 ret = WSAStringToAddressW( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1589 &len );
1590 GLE = WSAGetLastError();
1591 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1592 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
1593
1594 len = sizeof(sockaddr6);
1595 memset(&sockaddr6, 0, len);
1596 sockaddr6.sin6_family = AF_INET6;
1597
1598 ret = WSAStringToAddressW( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1599 &len );
1600 GLE = WSAGetLastError();
1601 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
1602 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1603 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
1604
1605 }
1606
1607 static VOID WINAPI SelectReadThread(select_thread_params *par)
1608 {
1609 fd_set readfds;
1610 int ret;
1611 struct sockaddr_in addr;
1612 struct timeval select_timeout;
1613
1614 FD_ZERO(&readfds);
1615 FD_SET(par->s, &readfds);
1616 select_timeout.tv_sec=5;
1617 select_timeout.tv_usec=0;
1618 addr.sin_family = AF_INET;
1619 addr.sin_addr.s_addr = inet_addr(SERVERIP);
1620 addr.sin_port = htons(SERVERPORT);
1621
1622 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
1623 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
1624
1625 SetEvent(server_ready);
1626 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
1627 par->ReadKilled = (ret == 1);
1628 }
1629
1630 static void test_select(void)
1631 {
1632 SOCKET fdRead, fdWrite;
1633 fd_set readfds, writefds, exceptfds;
1634 unsigned int maxfd;
1635 int ret;
1636 struct timeval select_timeout;
1637 select_thread_params thread_params;
1638 HANDLE thread_handle;
1639 DWORD id;
1640
1641 fdRead = socket(AF_INET, SOCK_STREAM, 0);
1642 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
1643 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
1644 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
1645
1646 FD_ZERO(&readfds);
1647 FD_ZERO(&writefds);
1648 FD_ZERO(&exceptfds);
1649 FD_SET(fdRead, &readfds);
1650 FD_SET(fdWrite, &writefds);
1651 FD_SET(fdRead, &exceptfds);
1652 FD_SET(fdWrite, &exceptfds);
1653 select_timeout.tv_sec=0;
1654 select_timeout.tv_usec=500;
1655
1656 maxfd = fdRead;
1657 if (fdWrite > maxfd)
1658 maxfd = fdWrite;
1659
1660 todo_wine {
1661 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
1662 ok ( (ret == 0), "select should not return any socket handles\n");
1663 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
1664 ok ( !FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
1665 }
1666
1667 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
1668 ok ( !FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
1669
1670 todo_wine {
1671 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
1672 }
1673 ret = closesocket(fdWrite);
1674 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
1675
1676 thread_params.s = fdRead;
1677 thread_params.ReadKilled = FALSE;
1678 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
1679 thread_handle = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) &SelectReadThread, &thread_params, 0, &id );
1680 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
1681
1682 WaitForSingleObject (server_ready, INFINITE);
1683 Sleep(200);
1684 ret = closesocket(fdRead);
1685 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
1686
1687 WaitForSingleObject (thread_handle, 1000);
1688 ok ( (thread_params.ReadKilled), "closesocket did not wakeup select\n");
1689
1690 }
1691
1692 static DWORD WINAPI AcceptKillThread(select_thread_params *par)
1693 {
1694 struct sockaddr_in address;
1695 int len = sizeof(address);
1696 SOCKET client_socket;
1697
1698 SetEvent(server_ready);
1699 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
1700 if (client_socket != INVALID_SOCKET)
1701 closesocket(client_socket);
1702 par->ReadKilled = (client_socket == INVALID_SOCKET);
1703 return 0;
1704 }
1705
1706 static void test_accept(void)
1707 {
1708 int ret;
1709 SOCKET server_socket = INVALID_SOCKET;
1710 struct sockaddr_in address;
1711 select_thread_params thread_params;
1712 HANDLE thread_handle = NULL;
1713 DWORD id;
1714
1715 server_socket = socket(AF_INET, SOCK_STREAM, 0);
1716 if (server_socket == INVALID_SOCKET)
1717 {
1718 trace("error creating server socket: %d\n", WSAGetLastError());
1719 goto done;
1720 }
1721
1722 memset(&address, 0, sizeof(address));
1723 address.sin_family = AF_INET;
1724 ret = bind(server_socket, (struct sockaddr*) &address, sizeof(address));
1725 if (ret != 0)
1726 {
1727 trace("error binding server socket: %d\n", WSAGetLastError());
1728 goto done;
1729 }
1730
1731 ret = listen(server_socket, 1);
1732 if (ret != 0)
1733 {
1734 trace("error making server socket listen: %d\n", WSAGetLastError());
1735 goto done;
1736 }
1737
1738 server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
1739 if (server_ready == INVALID_HANDLE_VALUE)
1740 {
1741 trace("error creating event: %d\n", GetLastError());
1742 goto done;
1743 }
1744
1745 thread_params.s = server_socket;
1746 thread_params.ReadKilled = FALSE;
1747 thread_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) AcceptKillThread,
1748 &thread_params, 0, &id);
1749 if (thread_handle == NULL)
1750 {
1751 trace("error creating thread: %d\n", GetLastError());
1752 goto done;
1753 }
1754
1755 WaitForSingleObject(server_ready, INFINITE);
1756 Sleep(200);
1757 ret = closesocket(server_socket);
1758 if (ret != 0)
1759 {
1760 trace("closesocket failed: %d\n", WSAGetLastError());
1761 goto done;
1762 }
1763
1764 WaitForSingleObject(thread_handle, 1000);
1765 ok(thread_params.ReadKilled, "closesocket did not wakeup accept\n");
1766
1767 done:
1768 if (thread_handle != NULL)
1769 CloseHandle(thread_handle);
1770 if (server_ready != INVALID_HANDLE_VALUE)
1771 CloseHandle(server_ready);
1772 if (server_socket != INVALID_SOCKET)
1773 closesocket(server_socket);
1774 }
1775
1776 static void test_extendedSocketOptions(void)
1777 {
1778 WSADATA wsa;
1779 SOCKET sock;
1780 struct sockaddr_in sa;
1781 int sa_len = sizeof(struct sockaddr_in);
1782 int optval, optlen = sizeof(int), ret;
1783 BOOL bool_opt_val;
1784 LINGER linger_val;
1785
1786 if(WSAStartup(MAKEWORD(2,0), &wsa)){
1787 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
1788 return;
1789 }
1790
1791 memset(&sa, 0, sa_len);
1792
1793 sa.sin_family = AF_INET;
1794 sa.sin_port = htons(0);
1795 sa.sin_addr.s_addr = htonl(INADDR_ANY);
1796
1797 if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) == INVALID_SOCKET) {
1798 trace("Creating the socket failed: %d\n", WSAGetLastError());
1799 WSACleanup();
1800 return;
1801 }
1802
1803 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
1804 trace("Failed to bind socket: %d\n", WSAGetLastError());
1805 closesocket(sock);
1806 WSACleanup();
1807 return;
1808 }
1809
1810 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
1811
1812 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
1813 ok((optval == 65507) || (optval == 65527),
1814 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
1815
1816 optlen = sizeof(LINGER);
1817 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
1818 todo_wine{
1819 ok(ret == SOCKET_ERROR, "getsockopt should fail for UDP sockets but return value is 0x%08x\n", ret);
1820 }
1821
1822 closesocket(sock);
1823
1824 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
1825 trace("Creating the socket failed: %d\n", WSAGetLastError());
1826 WSACleanup();
1827 return;
1828 }
1829
1830 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
1831 trace("Failed to bind socket: %d\n", WSAGetLastError());
1832 closesocket(sock);
1833 WSACleanup();
1834 return;
1835 }
1836
1837 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
1838 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
1839
1840 optlen = sizeof(BOOL);
1841 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
1842 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
1843 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
1844 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
1845 bool_opt_val, linger_val.l_onoff);
1846
1847 closesocket(sock);
1848 WSACleanup();
1849 }
1850
1851 static void test_getsockname(void)
1852 {
1853 WSADATA wsa;
1854 SOCKET sock;
1855 struct sockaddr_in sa_set, sa_get;
1856 int sa_set_len = sizeof(struct sockaddr_in);
1857 int sa_get_len = sa_set_len;
1858 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
1859
1860 if(WSAStartup(MAKEWORD(2,0), &wsa)){
1861 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
1862 return;
1863 }
1864
1865 memset(&sa_set, 0, sa_set_len);
1866
1867 sa_set.sin_family = AF_INET;
1868 sa_set.sin_port = htons(0);
1869 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
1870
1871 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
1872 trace("Creating the socket failed: %d\n", WSAGetLastError());
1873 WSACleanup();
1874 return;
1875 }
1876
1877 memcpy(&sa_get, &sa_set, sizeof(sa_set));
1878 if (getsockname(sock, (struct sockaddr*) &sa_get, &sa_get_len) == 0)
1879 ok(0, "getsockname on unbound socket should fail\n");
1880 else {
1881 ok(WSAGetLastError() == WSAEINVAL, "getsockname on unbound socket "
1882 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL);
1883 ok(memcmp(&sa_get, &sa_set, sizeof(sa_get)) == 0,
1884 "failed getsockname modified sockaddr when it shouldn't\n");
1885 }
1886
1887 if(bind(sock, (struct sockaddr *) &sa_set, sa_set_len) < 0){
1888 trace("Failed to bind socket: %d\n", WSAGetLastError());
1889 closesocket(sock);
1890 WSACleanup();
1891 return;
1892 }
1893
1894 if(getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len) != 0){
1895 trace("Failed to call getsockname: %d\n", WSAGetLastError());
1896 closesocket(sock);
1897 WSACleanup();
1898 return;
1899 }
1900
1901 ok(memcmp(sa_get.sin_zero, null_padding, 8) == 0,
1902 "getsockname did not zero the sockaddr_in structure\n");
1903
1904 closesocket(sock);
1905 WSACleanup();
1906 }
1907
1908 static void test_dns(void)
1909 {
1910 struct hostent *h;
1911
1912 h = gethostbyname("");
1913 ok(h != NULL, "gethostbyname(\"\") failed with %d\n", h_errno);
1914 }
1915
1916 /* Our winsock headers don't define gethostname because it conflicts with the
1917 * definition in unistd.h. Define it here to get rid of the warning. */
1918
1919 int WINAPI gethostname(char *name, int namelen);
1920
1921 static void test_gethostbyname_hack(void)
1922 {
1923 struct hostent *he;
1924 char name[256];
1925 static BYTE loopback[] = {127, 0, 0, 1};
1926 static BYTE magic_loopback[] = {127, 12, 34, 56};
1927 int ret;
1928
1929 ret = gethostname(name, 256);
1930 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
1931
1932 he = gethostbyname("localhost");
1933 ok(he != NULL, "gethostbyname(\"localhost\") failed: %d\n", h_errno);
1934 if(he)
1935 {
1936 if(he->h_length != 4)
1937 {
1938 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
1939 return;
1940 }
1941
1942 ok(memcmp(he->h_addr_list[0], loopback, he->h_length) == 0,
1943 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
1944 he->h_addr_list[0][0], he->h_addr_list[0][1], he->h_addr_list[0][2],
1945 he->h_addr_list[0][3]);
1946 }
1947
1948 /* No reason to test further with NULL hostname */
1949 if(name == NULL)
1950 return;
1951
1952 if(strcmp(name, "localhost") == 0)
1953 {
1954 skip("hostname seems to be \"localhost\", skipping test.\n");
1955 return;
1956 }
1957
1958 he = NULL;
1959 he = gethostbyname(name);
1960 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, h_errno);
1961 if(he)
1962 {
1963 if(he->h_length != 4)
1964 {
1965 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
1966 return;
1967 }
1968
1969 if (he->h_addr_list[0][0] == 127)
1970 {
1971 ok(memcmp(he->h_addr_list[0], magic_loopback, he->h_length) == 0,
1972 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
1973 name, he->h_addr_list[0][0], he->h_addr_list[0][1],
1974 he->h_addr_list[0][2], he->h_addr_list[0][3]);
1975 }
1976 }
1977
1978 he = NULL;
1979 he = gethostbyname("nonexistent.winehq.org");
1980 /* Don't check for the return value, as some braindead ISPs will kindly
1981 * resolve nonexistent host names to addresses of the ISP's spam pages. */
1982 }
1983
1984 static void test_inet_addr(void)
1985 {
1986 u_long addr;
1987
1988 addr = inet_addr(NULL);
1989 ok(addr == INADDR_NONE, "inet_addr succeeded unexpectedly\n");
1990 }
1991
1992 static DWORD WINAPI drain_socket_thread(LPVOID arg)
1993 {
1994 char buffer[1024];
1995 SOCKET sock = *(SOCKET*)arg;
1996 int ret;
1997
1998 while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
1999 {
2000 if (ret < 0)
2001 {
2002 if (WSAGetLastError() == WSAEWOULDBLOCK)
2003 {
2004 fd_set readset;
2005 FD_ZERO(&readset);
2006 FD_SET(sock, &readset);
2007 select(0, &readset, NULL, NULL, NULL);
2008 }
2009 else
2010 break;
2011 }
2012 }
2013 return 0;
2014 }
2015
2016 static void test_send(void)
2017 {
2018 SOCKET src = INVALID_SOCKET;
2019 SOCKET dst = INVALID_SOCKET;
2020 HANDLE hThread = NULL;
2021 const int buflen = 1024*1024;
2022 char *buffer = NULL;
2023 int ret;
2024 DWORD id;
2025
2026 if (tcp_socketpair(&src, &dst) != 0)
2027 {
2028 ok(0, "creating socket pair failed, skipping test\n");
2029 return;
2030 }
2031
2032 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
2033 if (hThread == NULL)
2034 {
2035 ok(0, "CreateThread failed, error %d\n", GetLastError());
2036 goto end;
2037 }
2038
2039 buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen);
2040 if (buffer == NULL)
2041 {
2042 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
2043 goto end;
2044 }
2045
2046 ret = send(src, buffer, buflen, 0);
2047 if (ret >= 0)
2048 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
2049 else
2050 ok(0, "send failed, error %d\n", WSAGetLastError());
2051
2052 end:
2053 if (src != INVALID_SOCKET)
2054 closesocket(src);
2055 if (dst != INVALID_SOCKET)
2056 closesocket(dst);
2057 if (hThread != NULL)
2058 CloseHandle(hThread);
2059 HeapFree(GetProcessHeap(), 0, buffer);
2060 }
2061
2062 static void test_write_events(void)
2063 {
2064 SOCKET src = INVALID_SOCKET;
2065 SOCKET dst = INVALID_SOCKET;
2066 HANDLE hThread = NULL;
2067 HANDLE hEvent = INVALID_HANDLE_VALUE;
2068 char *buffer = NULL;
2069 int bufferSize = 1024*1024;
2070 u_long one = 1;
2071 int ret;
2072 DWORD id;
2073 WSANETWORKEVENTS netEvents;
2074 DWORD dwRet;
2075
2076 if (tcp_socketpair(&src, &dst) != 0)
2077 {
2078 ok(0, "creating socket pair failed, skipping test\n");
2079 return;
2080 }
2081
2082 /* On Windows it seems when a non-blocking socket sends to a
2083 blocking socket on the same host, the send() is BLOCKING,
2084 so make both sockets non-blocking */
2085 ret = ioctlsocket(src, FIONBIO, &one);
2086 if (ret)
2087 {
2088 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
2089 goto end;
2090 }
2091 ret = ioctlsocket(dst, FIONBIO, &one);
2092 if (ret)
2093 {
2094 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
2095 goto end;
2096 }
2097
2098 buffer = HeapAlloc(GetProcessHeap(), 0, bufferSize);
2099 if (buffer == NULL)
2100 {
2101 ok(0, "could not allocate memory for test\n");
2102 goto end;
2103 }
2104
2105 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
2106 if (hThread == NULL)
2107 {
2108 ok(0, "CreateThread failed, error %d\n", GetLastError());
2109 goto end;
2110 }
2111
2112 hEvent = CreateEventA(NULL, FALSE, TRUE, NULL);
2113 if (hEvent == INVALID_HANDLE_VALUE)
2114 {
2115 ok(0, "CreateEventA failed, error %d\n", GetLastError());
2116 goto end;
2117 }
2118
2119 ret = WSAEventSelect(src, hEvent, FD_WRITE | FD_CLOSE);
2120 if (ret)
2121 {
2122 ok(0, "WSAEventSelect failed, error %d\n", ret);
2123 goto end;
2124 }
2125
2126 /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
2127 dwRet = WaitForSingleObject(hEvent, 5000);
2128 if (dwRet != WAIT_OBJECT_0)
2129 {
2130 ok(0, "Initial WaitForSingleObject failed, error %d\n", dwRet);
2131 goto end;
2132 }
2133 ret = WSAEnumNetworkEvents(src, NULL, &netEvents);
2134 if (ret)
2135 {
2136 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
2137 goto end;
2138 }
2139 if (netEvents.lNetworkEvents & FD_WRITE)
2140 {
2141 ret = send(src, "a", 1, 0);
2142 ok(ret == 1, "sending 1 byte failed, error %d\n", WSAGetLastError());
2143 if (ret != 1)
2144 goto end;
2145 }
2146 else
2147 {
2148 ok(0, "FD_WRITE not among initial events\n");
2149 goto end;
2150 }
2151
2152 /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
2153 dwRet = WaitForSingleObject(hEvent, 2000);
2154 if (dwRet == WAIT_OBJECT_0)
2155 {
2156 ok(0, "WaitForSingleObject should have timed out, but succeeded!\n");
2157 goto end;
2158 }
2159
2160 /* Now if we send a tonne of data, the socket send buffer will only take some of it,
2161 and we will get a short write, which will trigger another FD_WRITE event
2162 as soon as data is sent and more space becomes available, but not any earlier. */
2163 do
2164 {
2165 ret = send(src, buffer, bufferSize, 0);
2166 } while (ret == bufferSize);
2167 if (ret >= 0 || WSAGetLastError() == WSAEWOULDBLOCK)
2168 {
2169 dwRet = WaitForSingleObject(hEvent, 5000);
2170 ok(dwRet == WAIT_OBJECT_0, "Waiting failed with %d\n", dwRet);
2171 if (dwRet == WAIT_OBJECT_0)
2172 {
2173 ret = WSAEnumNetworkEvents(src, NULL, &netEvents);
2174 ok(ret == 0, "WSAEnumNetworkEvents failed, error %d\n", ret);
2175 if (ret == 0)
2176 goto end;
2177 ok(netEvents.lNetworkEvents & FD_WRITE,
2178 "FD_WRITE event not set as expected, events are 0x%x\n", netEvents.lNetworkEvents);
2179 }
2180 else
2181 goto end;
2182 }
2183 else
2184 {
2185 ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
2186 goto end;
2187 }
2188
2189 end:
2190 if (buffer != NULL)
2191 HeapFree(GetProcessHeap(), 0, buffer);
2192 if (src != INVALID_SOCKET)
2193 closesocket(src);
2194 if (dst != INVALID_SOCKET)
2195 closesocket(dst);
2196 if (hThread != NULL)
2197 CloseHandle(hThread);
2198 CloseHandle(hEvent);
2199 }
2200
2201 static void test_ipv6only(void)
2202 {
2203 SOCKET v4 = INVALID_SOCKET,
2204 v6 = INVALID_SOCKET;
2205 struct sockaddr_in sin4;
2206 struct sockaddr_in6 sin6;
2207 int ret;
2208
2209 memset(&sin4, 0, sizeof(sin4));
2210 sin4.sin_family = AF_INET;
2211 sin4.sin_port = htons(SERVERPORT);
2212
2213 memset(&sin6, 0, sizeof(sin6));
2214 sin6.sin6_family = AF_INET6;
2215 sin6.sin6_port = htons(SERVERPORT);
2216
2217 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
2218 if (v6 == INVALID_SOCKET) {
2219 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2220 WSAGetLastError(), WSAEAFNOSUPPORT);
2221 goto end;
2222 }
2223 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
2224 if (ret) {
2225 skip("Could not bind IPv6 address (LastError: %d).\n",
2226 WSAGetLastError());
2227 goto end;
2228 }
2229
2230 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
2231 if (v4 == INVALID_SOCKET) {
2232 skip("Could not create IPv4 socket (LastError: %d).\n",
2233 WSAGetLastError());
2234 goto end;
2235 }
2236 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
2237 ok(!ret, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
2238 WSAGetLastError(), WSAEADDRINUSE);
2239
2240 end:
2241 if (v4 != INVALID_SOCKET)
2242 closesocket(v4);
2243 if (v6 != INVALID_SOCKET)
2244 closesocket(v6);
2245 }
2246
2247 static void test_WSASendTo(void)
2248 {
2249 SOCKET s;
2250 struct sockaddr_in addr;
2251 char buf[12] = "hello world";
2252 WSABUF data_buf;
2253 DWORD bytesSent;
2254
2255 addr.sin_family = AF_INET;
2256 addr.sin_port = htons(139);
2257 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2258 data_buf.len = sizeof(buf);
2259 data_buf.buf = buf;
2260
2261 if( (s = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
2262 ok(0, "socket() failed error: %d\n", WSAGetLastError());
2263 return;
2264 }
2265
2266 WSASetLastError(12345);
2267 if(WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL)) {
2268 ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
2269 return;
2270 }
2271 ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
2272 "a successful call to WSASendTo()\n");
2273 }
2274
2275 /**************** Main program ***************/
2276
2277 START_TEST( sock )
2278 {
2279 int i;
2280 Init();
2281
2282 test_set_getsockopt();
2283 test_so_reuseaddr();
2284 test_extendedSocketOptions();
2285
2286 for (i = 0; i < NUM_TESTS; i++)
2287 {
2288 trace ( " **** STARTING TEST %d ****\n", i );
2289 do_test ( &tests[i] );
2290 trace ( " **** TEST %d COMPLETE ****\n", i );
2291 }
2292
2293 test_UDP();
2294
2295 test_getservbyname();
2296 test_WSASocket();
2297
2298 test_WSAAddressToStringA();
2299 test_WSAAddressToStringW();
2300
2301 test_WSAStringToAddressA();
2302 test_WSAStringToAddressW();
2303
2304 test_select();
2305 test_accept();
2306 test_getsockname();
2307 test_inet_addr();
2308 test_dns();
2309 test_gethostbyname_hack();
2310
2311 test_send();
2312 test_write_events();
2313
2314 test_WSASendTo();
2315
2316 test_ipv6only();
2317
2318 Exit();
2319 }
useful hacks and other patches not (yet) suitable for mainline