?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ws2_32: Ignore lpFrom for connected sockets.
[wine/multimedia.git] / dlls / ws2_32 / tests / sock.c
blob2e0ee2897dd08b7e27ba0feae52eae8b74d8dd59
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 = CreateEventW ( NULL, TRUE, FALSE, NULL );
891 for (i = 0; i <= n; i++)
892 client_ready[i] = CreateEventW ( 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 for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
1131 ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
1132
1133 peer[i].addr.sin_family = AF_INET;
1134 peer[i].addr.sin_addr.s_addr = inet_addr ( SERVERIP );
1135
1136 if ( i == 0 ) {
1137 peer[i].addr.sin_port = htons ( SERVERPORT );
1138 } else {
1139 peer[i].addr.sin_port = htons ( 0 );
1140 }
1141
1142 do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
1143
1144 /* test getsockname() to get peer's port */
1145 ss = sizeof ( peer[i].addr );
1146 ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
1147 ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
1148 }
1149
1150 /* test getsockname() */
1151 ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
1152
1153 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
1154 /* send client's ip */
1155 memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
1156 n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
1157 ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
1158 }
1159
1160 for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
1161 n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
1162 ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
1163 ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
1164 }
1165 }
1166
1167 static void WINAPI do_getservbyname( HANDLE *starttest )
1168 {
1169 struct {
1170 const char *name;
1171 const char *proto;
1172 int port;
1173 } serv[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
1174
1175 int i, j;
1176 struct servent *pserv[2];
1177
1178 ok ( WaitForSingleObject ( *starttest, TEST_TIMEOUT * 1000 ) != WAIT_TIMEOUT, "test_getservbyname: timeout waiting for start signal\n");
1179
1180 /* ensure that necessary buffer resizes are completed */
1181 for ( j = 0; j < 2; j++) {
1182 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1183 }
1184
1185 for ( i = 0; i < NUM_QUERIES / 2; i++ ) {
1186 for ( j = 0; j < 2; j++ ) {
1187 pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1188 ok ( pserv[j] != NULL, "getservbyname could not retrieve information for %s: %d\n", serv[j].name, WSAGetLastError() );
1189 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) );
1190 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 );
1191 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 );
1192 }
1193
1194 ok ( pserv[0] == pserv[1], "getservbyname: winsock resized servent buffer when not necessary\n" );
1195 }
1196 }
1197
1198 static void test_getservbyname(void)
1199 {
1200 int i;
1201 HANDLE starttest, thread[NUM_THREADS];
1202 DWORD thread_id[NUM_THREADS];
1203
1204 starttest = CreateEvent ( NULL, 1, 0, "test_getservbyname_starttest" );
1205
1206 /* create threads */
1207 for ( i = 0; i < NUM_THREADS; i++ ) {
1208 thread[i] = CreateThread ( NULL, 0, (LPTHREAD_START_ROUTINE) &do_getservbyname, &starttest, 0, &thread_id[i] );
1209 }
1210
1211 /* signal threads to start */
1212 SetEvent ( starttest );
1213
1214 for ( i = 0; i < NUM_THREADS; i++) {
1215 WaitForSingleObject ( thread[i], TEST_TIMEOUT * 1000 );
1216 }
1217 }
1218
1219 static void test_WSASocket(void)
1220 {
1221 SOCKET sock = INVALID_SOCKET;
1222 WSAPROTOCOL_INFOA *pi;
1223 int providers[] = {6, 0};
1224 int ret, err;
1225 UINT pi_size;
1226
1227 /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
1228 * to avoid a crash on win98.
1229 */
1230 pi_size = 0;
1231 ret = WSAEnumProtocolsA(providers, NULL, &pi_size);
1232 ok(ret == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
1233 ret);
1234 err = WSAGetLastError();
1235 ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
1236 err, WSAENOBUFS);
1237
1238 pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
1239 ok(pi != NULL, "Failed to allocate memory\n");
1240 if (pi == NULL) {
1241 skip("Can't continue without memory.\n");
1242 return;
1243 }
1244
1245 ret = WSAEnumProtocolsA(providers, pi, &pi_size);
1246 ok(ret != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
1247 WSAGetLastError());
1248
1249 if (ret == 0) {
1250 skip("No protocols enumerated.\n");
1251 HeapFree(GetProcessHeap(), 0, pi);
1252 return;
1253 }
1254
1255 sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
1256 FROM_PROTOCOL_INFO, &pi[0], 0, 0);
1257 ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
1258 WSAGetLastError());
1259
1260 closesocket(sock);
1261 HeapFree(GetProcessHeap(), 0, pi);
1262 }
1263
1264 static void test_WSAAddressToStringA(void)
1265 {
1266 INT ret;
1267 DWORD len;
1268 int GLE;
1269 SOCKADDR_IN sockaddr;
1270 CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1271
1272 CHAR expect1[] = "0.0.0.0";
1273 CHAR expect2[] = "255.255.255.255";
1274 CHAR expect3[] = "0.0.0.0:65535";
1275 CHAR expect4[] = "255.255.255.255:65535";
1276
1277 len = 0;
1278
1279 sockaddr.sin_family = AF_INET;
1280 sockaddr.sin_port = 0;
1281 sockaddr.sin_addr.s_addr = 0;
1282
1283 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1284 GLE = WSAGetLastError();
1285 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
1286 "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1287 GLE, ret );
1288
1289 len = sizeof(address);
1290
1291 sockaddr.sin_family = AF_INET;
1292 sockaddr.sin_port = 0;
1293 sockaddr.sin_addr.s_addr = 0;
1294
1295 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1296 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1297
1298 ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
1299
1300 len = sizeof(address);
1301
1302 sockaddr.sin_family = AF_INET;
1303 sockaddr.sin_port = 0;
1304 sockaddr.sin_addr.s_addr = 0xffffffff;
1305
1306 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1307 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1308
1309 ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
1310
1311 len = sizeof(address);
1312
1313 sockaddr.sin_family = AF_INET;
1314 sockaddr.sin_port = 0xffff;
1315 sockaddr.sin_addr.s_addr = 0;
1316
1317 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1318 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1319
1320 ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
1321
1322 len = sizeof(address);
1323
1324 sockaddr.sin_family = AF_INET;
1325 sockaddr.sin_port = 0xffff;
1326 sockaddr.sin_addr.s_addr = 0xffffffff;
1327
1328 ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1329 ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1330
1331 ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
1332 }
1333
1334 static void test_WSAAddressToStringW(void)
1335 {
1336 INT ret;
1337 DWORD len;
1338 int GLE;
1339 SOCKADDR_IN sockaddr;
1340 WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1341
1342 WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
1343 WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1344 WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
1345 WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1346 '6', '5', '5', '3', '5', 0 };
1347
1348 len = 0;
1349
1350 sockaddr.sin_family = AF_INET;
1351 sockaddr.sin_port = 0;
1352 sockaddr.sin_addr.s_addr = 0;
1353
1354 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1355 GLE = WSAGetLastError();
1356 ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
1357 "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1358 GLE, ret );
1359
1360 len = sizeof(address);
1361
1362 sockaddr.sin_family = AF_INET;
1363 sockaddr.sin_port = 0;
1364 sockaddr.sin_addr.s_addr = 0;
1365
1366 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1367 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1368
1369 ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
1370
1371 len = sizeof(address);
1372
1373 sockaddr.sin_family = AF_INET;
1374 sockaddr.sin_port = 0;
1375 sockaddr.sin_addr.s_addr = 0xffffffff;
1376
1377 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1378 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1379
1380 ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
1381
1382 len = sizeof(address);
1383
1384 sockaddr.sin_family = AF_INET;
1385 sockaddr.sin_port = 0xffff;
1386 sockaddr.sin_addr.s_addr = 0;
1387
1388 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1389 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1390
1391 ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
1392
1393 len = sizeof(address);
1394
1395 sockaddr.sin_family = AF_INET;
1396 sockaddr.sin_port = 0xffff;
1397 sockaddr.sin_addr.s_addr = 0xffffffff;
1398
1399 ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1400 ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1401
1402 ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
1403 }
1404
1405 static void test_WSAStringToAddressA(void)
1406 {
1407 INT ret, len;
1408 SOCKADDR_IN sockaddr;
1409 SOCKADDR_IN6 sockaddr6;
1410 int GLE;
1411
1412 CHAR address1[] = "0.0.0.0";
1413 CHAR address2[] = "127.127.127.127";
1414 CHAR address3[] = "255.255.255.255";
1415 CHAR address4[] = "127.127.127.127:65535";
1416 CHAR address5[] = "255.255.255.255:65535";
1417 CHAR address6[] = "::1";
1418 CHAR address7[] = "[::1]";
1419 CHAR address8[] = "[::1]:65535";
1420
1421 len = 0;
1422 sockaddr.sin_family = AF_INET;
1423
1424 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1425 ok( ret == SOCKET_ERROR, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
1426 WSAGetLastError() );
1427
1428 len = sizeof(sockaddr);
1429 sockaddr.sin_port = 0;
1430 sockaddr.sin_addr.s_addr = 0;
1431
1432 ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1433 ok( !ret && sockaddr.sin_addr.s_addr == 0,
1434 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1435
1436 len = sizeof(sockaddr);
1437 sockaddr.sin_port = 0;
1438 sockaddr.sin_addr.s_addr = 0;
1439
1440 ret = WSAStringToAddressA( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1441 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
1442 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1443
1444 len = sizeof(sockaddr);
1445 sockaddr.sin_port = 0;
1446 sockaddr.sin_addr.s_addr = 0;
1447
1448 ret = WSAStringToAddressA( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1449 GLE = WSAGetLastError();
1450 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
1451 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1452 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
1453
1454 len = sizeof(sockaddr);
1455 sockaddr.sin_port = 0;
1456 sockaddr.sin_addr.s_addr = 0;
1457
1458 ret = WSAStringToAddressA( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1459 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
1460 "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1461
1462 len = sizeof(sockaddr);
1463 sockaddr.sin_port = 0;
1464 sockaddr.sin_addr.s_addr = 0;
1465
1466 ret = WSAStringToAddressA( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1467 GLE = WSAGetLastError();
1468 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
1469 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1470 "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
1471
1472 len = sizeof(sockaddr6);
1473 memset(&sockaddr6, 0, len);
1474 sockaddr6.sin6_family = AF_INET6;
1475
1476 ret = WSAStringToAddressA( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1477 &len );
1478 GLE = WSAGetLastError();
1479 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1480 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
1481
1482 len = sizeof(sockaddr6);
1483 memset(&sockaddr6, 0, len);
1484 sockaddr6.sin6_family = AF_INET6;
1485
1486 ret = WSAStringToAddressA( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1487 &len );
1488 GLE = WSAGetLastError();
1489 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1490 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
1491
1492 len = sizeof(sockaddr6);
1493 memset(&sockaddr6, 0, len);
1494 sockaddr6.sin6_family = AF_INET6;
1495
1496 ret = WSAStringToAddressA( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1497 &len );
1498 GLE = WSAGetLastError();
1499 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
1500 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1501 "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
1502
1503 }
1504
1505 static void test_WSAStringToAddressW(void)
1506 {
1507 INT ret, len;
1508 SOCKADDR_IN sockaddr;
1509 SOCKADDR_IN6 sockaddr6;
1510 int GLE;
1511
1512 WCHAR address1[] = { '0','.','0','.','0','.','0', 0 };
1513 WCHAR address2[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
1514 WCHAR address3[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1515 WCHAR address4[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
1516 ':', '6', '5', '5', '3', '5', 0 };
1517 WCHAR address5[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1518 '6', '5', '5', '3', '5', 0 };
1519 WCHAR address6[] = {':',':','1','\0'};
1520 WCHAR address7[] = {'[',':',':','1',']','\0'};
1521 WCHAR address8[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
1522
1523 len = 0;
1524 sockaddr.sin_family = AF_INET;
1525
1526 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1527 ok( ret == SOCKET_ERROR, "WSAStringToAddressW() failed unexpectedly: %d\n",
1528 WSAGetLastError() );
1529
1530 len = sizeof(sockaddr);
1531 sockaddr.sin_port = 0;
1532 sockaddr.sin_addr.s_addr = 0;
1533
1534 ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1535 ok( !ret && sockaddr.sin_addr.s_addr == 0,
1536 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1537
1538 len = sizeof(sockaddr);
1539 sockaddr.sin_port = 0;
1540 sockaddr.sin_addr.s_addr = 0;
1541
1542 ret = WSAStringToAddressW( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1543 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
1544 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1545
1546 len = sizeof(sockaddr);
1547 sockaddr.sin_port = 0;
1548 sockaddr.sin_addr.s_addr = 0;
1549
1550 ret = WSAStringToAddressW( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1551 GLE = WSAGetLastError();
1552 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
1553 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1554 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
1555
1556 len = sizeof(sockaddr);
1557 sockaddr.sin_port = 0;
1558 sockaddr.sin_addr.s_addr = 0;
1559
1560 ret = WSAStringToAddressW( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1561 ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
1562 "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1563
1564 len = sizeof(sockaddr);
1565 sockaddr.sin_port = 0;
1566 sockaddr.sin_addr.s_addr = 0;
1567
1568 ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1569 ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
1570 (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1571 "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
1572
1573 len = sizeof(sockaddr6);
1574 memset(&sockaddr6, 0, len);
1575 sockaddr6.sin6_family = AF_INET6;
1576
1577 ret = WSAStringToAddressW( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1578 &len );
1579 GLE = WSAGetLastError();
1580 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1581 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
1582
1583 len = sizeof(sockaddr6);
1584 memset(&sockaddr6, 0, len);
1585 sockaddr6.sin6_family = AF_INET6;
1586
1587 ret = WSAStringToAddressW( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1588 &len );
1589 GLE = WSAGetLastError();
1590 ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1591 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
1592
1593 len = sizeof(sockaddr6);
1594 memset(&sockaddr6, 0, len);
1595 sockaddr6.sin6_family = AF_INET6;
1596
1597 ret = WSAStringToAddressW( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1598 &len );
1599 GLE = WSAGetLastError();
1600 ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
1601 (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1602 "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
1603
1604 }
1605
1606 static VOID WINAPI SelectReadThread(select_thread_params *par)
1607 {
1608 fd_set readfds;
1609 int ret;
1610 struct sockaddr_in addr;
1611 struct timeval select_timeout;
1612
1613 FD_ZERO(&readfds);
1614 FD_SET(par->s, &readfds);
1615 select_timeout.tv_sec=5;
1616 select_timeout.tv_usec=0;
1617 addr.sin_family = AF_INET;
1618 addr.sin_addr.s_addr = inet_addr(SERVERIP);
1619 addr.sin_port = htons(SERVERPORT);
1620
1621 do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
1622 wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
1623
1624 SetEvent(server_ready);
1625 ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
1626 par->ReadKilled = (ret == 1);
1627 }
1628
1629 static void test_select(void)
1630 {
1631 SOCKET fdRead, fdWrite;
1632 fd_set readfds, writefds, exceptfds;
1633 unsigned int maxfd;
1634 int ret;
1635 struct timeval select_timeout;
1636 select_thread_params thread_params;
1637 HANDLE thread_handle;
1638 DWORD id;
1639
1640 fdRead = socket(AF_INET, SOCK_STREAM, 0);
1641 ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
1642 fdWrite = socket(AF_INET, SOCK_STREAM, 0);
1643 ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
1644
1645 FD_ZERO(&readfds);
1646 FD_ZERO(&writefds);
1647 FD_ZERO(&exceptfds);
1648 FD_SET(fdRead, &readfds);
1649 FD_SET(fdWrite, &writefds);
1650 FD_SET(fdRead, &exceptfds);
1651 FD_SET(fdWrite, &exceptfds);
1652 select_timeout.tv_sec=0;
1653 select_timeout.tv_usec=500;
1654
1655 maxfd = fdRead;
1656 if (fdWrite > maxfd)
1657 maxfd = fdWrite;
1658
1659 todo_wine {
1660 ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
1661 ok ( (ret == 0), "select should not return any socket handles\n");
1662 ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
1663 ok ( !FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
1664 }
1665
1666 ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
1667 ok ( !FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
1668
1669 todo_wine {
1670 ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
1671 }
1672 ret = closesocket(fdWrite);
1673 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
1674
1675 thread_params.s = fdRead;
1676 thread_params.ReadKilled = FALSE;
1677 server_ready = CreateEventW(NULL, TRUE, FALSE, NULL);
1678 thread_handle = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) &SelectReadThread, &thread_params, 0, &id );
1679 ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
1680
1681 WaitForSingleObject (server_ready, INFINITE);
1682 Sleep(200);
1683 ret = closesocket(fdRead);
1684 ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
1685
1686 WaitForSingleObject (thread_handle, 1000);
1687 ok ( (thread_params.ReadKilled), "closesocket did not wakeup select\n");
1688
1689 }
1690
1691 static DWORD WINAPI AcceptKillThread(select_thread_params *par)
1692 {
1693 struct sockaddr_in address;
1694 int len = sizeof(address);
1695 SOCKET client_socket;
1696
1697 SetEvent(server_ready);
1698 client_socket = accept(par->s, (struct sockaddr*) &address, &len);
1699 if (client_socket != INVALID_SOCKET)
1700 closesocket(client_socket);
1701 par->ReadKilled = (client_socket == INVALID_SOCKET);
1702 return 0;
1703 }
1704
1705 static void test_accept(void)
1706 {
1707 int ret;
1708 SOCKET server_socket = INVALID_SOCKET;
1709 struct sockaddr_in address;
1710 select_thread_params thread_params;
1711 HANDLE thread_handle = NULL;
1712 DWORD id;
1713
1714 server_socket = socket(AF_INET, SOCK_STREAM, 0);
1715 if (server_socket == INVALID_SOCKET)
1716 {
1717 trace("error creating server socket: %d\n", WSAGetLastError());
1718 goto done;
1719 }
1720
1721 memset(&address, 0, sizeof(address));
1722 address.sin_family = AF_INET;
1723 ret = bind(server_socket, (struct sockaddr*) &address, sizeof(address));
1724 if (ret != 0)
1725 {
1726 trace("error binding server socket: %d\n", WSAGetLastError());
1727 goto done;
1728 }
1729
1730 ret = listen(server_socket, 1);
1731 if (ret != 0)
1732 {
1733 trace("error making server socket listen: %d\n", WSAGetLastError());
1734 goto done;
1735 }
1736
1737 server_ready = CreateEventW(NULL, TRUE, FALSE, NULL);
1738 if (server_ready == INVALID_HANDLE_VALUE)
1739 {
1740 trace("error creating event: %d\n", GetLastError());
1741 goto done;
1742 }
1743
1744 thread_params.s = server_socket;
1745 thread_params.ReadKilled = FALSE;
1746 thread_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) AcceptKillThread,
1747 &thread_params, 0, &id);
1748 if (thread_handle == NULL)
1749 {
1750 trace("error creating thread: %d\n", GetLastError());
1751 goto done;
1752 }
1753
1754 WaitForSingleObject(server_ready, INFINITE);
1755 Sleep(200);
1756 ret = closesocket(server_socket);
1757 if (ret != 0)
1758 {
1759 trace("closesocket failed: %d\n", WSAGetLastError());
1760 goto done;
1761 }
1762
1763 WaitForSingleObject(thread_handle, 1000);
1764 ok(thread_params.ReadKilled, "closesocket did not wakeup accept\n");
1765
1766 done:
1767 if (thread_handle != NULL)
1768 CloseHandle(thread_handle);
1769 if (server_ready != INVALID_HANDLE_VALUE)
1770 CloseHandle(server_ready);
1771 if (server_socket != INVALID_SOCKET)
1772 closesocket(server_socket);
1773 }
1774
1775 static void test_extendedSocketOptions(void)
1776 {
1777 WSADATA wsa;
1778 SOCKET sock;
1779 struct sockaddr_in sa;
1780 int sa_len = sizeof(struct sockaddr_in);
1781 int optval, optlen = sizeof(int), ret;
1782 BOOL bool_opt_val;
1783 LINGER linger_val;
1784
1785 if(WSAStartup(MAKEWORD(2,0), &wsa)){
1786 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
1787 return;
1788 }
1789
1790 memset(&sa, 0, sa_len);
1791
1792 sa.sin_family = AF_INET;
1793 sa.sin_port = htons(0);
1794 sa.sin_addr.s_addr = htonl(INADDR_ANY);
1795
1796 if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) == INVALID_SOCKET) {
1797 trace("Creating the socket failed: %d\n", WSAGetLastError());
1798 WSACleanup();
1799 return;
1800 }
1801
1802 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
1803 trace("Failed to bind socket: %d\n", WSAGetLastError());
1804 closesocket(sock);
1805 WSACleanup();
1806 return;
1807 }
1808
1809 ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
1810
1811 ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
1812 ok((optval == 65507) || (optval == 65527),
1813 "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
1814
1815 optlen = sizeof(LINGER);
1816 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
1817 todo_wine{
1818 ok(ret == SOCKET_ERROR, "getsockopt should fail for UDP sockets but return value is 0x%08x\n", ret);
1819 }
1820
1821 closesocket(sock);
1822
1823 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
1824 trace("Creating the socket failed: %d\n", WSAGetLastError());
1825 WSACleanup();
1826 return;
1827 }
1828
1829 if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
1830 trace("Failed to bind socket: %d\n", WSAGetLastError());
1831 closesocket(sock);
1832 WSACleanup();
1833 return;
1834 }
1835
1836 ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
1837 ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
1838
1839 optlen = sizeof(BOOL);
1840 ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
1841 ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
1842 ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
1843 "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
1844 bool_opt_val, linger_val.l_onoff);
1845
1846 closesocket(sock);
1847 WSACleanup();
1848 }
1849
1850 static void test_getsockname(void)
1851 {
1852 WSADATA wsa;
1853 SOCKET sock;
1854 struct sockaddr_in sa_set, sa_get;
1855 int sa_set_len = sizeof(struct sockaddr_in);
1856 int sa_get_len = sa_set_len;
1857 static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
1858
1859 if(WSAStartup(MAKEWORD(2,0), &wsa)){
1860 trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
1861 return;
1862 }
1863
1864 memset(&sa_set, 0, sa_set_len);
1865
1866 sa_set.sin_family = AF_INET;
1867 sa_set.sin_port = htons(0);
1868 sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
1869
1870 if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
1871 trace("Creating the socket failed: %d\n", WSAGetLastError());
1872 WSACleanup();
1873 return;
1874 }
1875
1876 memcpy(&sa_get, &sa_set, sizeof(sa_set));
1877 if (getsockname(sock, (struct sockaddr*) &sa_get, &sa_get_len) == 0)
1878 ok(0, "getsockname on unbound socket should fail\n");
1879 else {
1880 ok(WSAGetLastError() == WSAEINVAL, "getsockname on unbound socket "
1881 "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL);
1882 ok(memcmp(&sa_get, &sa_set, sizeof(sa_get)) == 0,
1883 "failed getsockname modified sockaddr when it shouldn't\n");
1884 }
1885
1886 if(bind(sock, (struct sockaddr *) &sa_set, sa_set_len) < 0){
1887 trace("Failed to bind socket: %d\n", WSAGetLastError());
1888 closesocket(sock);
1889 WSACleanup();
1890 return;
1891 }
1892
1893 if(getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len) != 0){
1894 trace("Failed to call getsockname: %d\n", WSAGetLastError());
1895 closesocket(sock);
1896 WSACleanup();
1897 return;
1898 }
1899
1900 ok(memcmp(sa_get.sin_zero, null_padding, 8) == 0,
1901 "getsockname did not zero the sockaddr_in structure\n");
1902
1903 closesocket(sock);
1904 WSACleanup();
1905 }
1906
1907 static void test_dns(void)
1908 {
1909 struct hostent *h;
1910
1911 h = gethostbyname("");
1912 ok(h != NULL, "gethostbyname(\"\") failed with %d\n", h_errno);
1913 }
1914
1915 /* Our winsock headers don't define gethostname because it conflicts with the
1916 * definition in unistd.h. Define it here to get rid of the warning. */
1917
1918 int WINAPI gethostname(char *name, int namelen);
1919
1920 static void test_gethostbyname_hack(void)
1921 {
1922 struct hostent *he;
1923 char name[256];
1924 static BYTE loopback[] = {127, 0, 0, 1};
1925 static BYTE magic_loopback[] = {127, 12, 34, 56};
1926 int ret;
1927
1928 ret = gethostname(name, 256);
1929 ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
1930
1931 he = gethostbyname("localhost");
1932 ok(he != NULL, "gethostbyname(\"localhost\") failed: %d\n", h_errno);
1933 if(he)
1934 {
1935 if(he->h_length != 4)
1936 {
1937 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
1938 return;
1939 }
1940
1941 ok(memcmp(he->h_addr_list[0], loopback, he->h_length) == 0,
1942 "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
1943 he->h_addr_list[0][0], he->h_addr_list[0][1], he->h_addr_list[0][2],
1944 he->h_addr_list[0][3]);
1945 }
1946
1947 /* No reason to test further with NULL hostname */
1948 if(name == NULL)
1949 return;
1950
1951 if(strcmp(name, "localhost") == 0)
1952 {
1953 skip("hostname seems to be \"localhost\", skipping test.\n");
1954 return;
1955 }
1956
1957 he = NULL;
1958 he = gethostbyname(name);
1959 ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, h_errno);
1960 if(he)
1961 {
1962 if(he->h_length != 4)
1963 {
1964 skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
1965 return;
1966 }
1967
1968 if (he->h_addr_list[0][0] == 127)
1969 {
1970 ok(memcmp(he->h_addr_list[0], magic_loopback, he->h_length) == 0,
1971 "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
1972 name, he->h_addr_list[0][0], he->h_addr_list[0][1],
1973 he->h_addr_list[0][2], he->h_addr_list[0][3]);
1974 }
1975 }
1976
1977 he = NULL;
1978 he = gethostbyname("nonexistent.winehq.org");
1979 /* Don't check for the return value, as some braindead ISPs will kindly
1980 * resolve nonexistent host names to addresses of the ISP's spam pages. */
1981 }
1982
1983 static void test_inet_addr(void)
1984 {
1985 u_long addr;
1986
1987 addr = inet_addr(NULL);
1988 ok(addr == INADDR_NONE, "inet_addr succeeded unexpectedly\n");
1989 }
1990
1991 static DWORD WINAPI drain_socket_thread(LPVOID arg)
1992 {
1993 char buffer[1024];
1994 SOCKET sock = *(SOCKET*)arg;
1995
1996 while (recv(sock, buffer, sizeof(buffer), 0) > 0)
1997 ;
1998 return 0;
1999 }
2000
2001 static void test_send(void)
2002 {
2003 SOCKET src = INVALID_SOCKET;
2004 SOCKET dst = INVALID_SOCKET;
2005 HANDLE hThread = NULL;
2006 const int buflen = 1024*1024;
2007 char *buffer = NULL;
2008 int ret;
2009 DWORD id;
2010
2011 if (tcp_socketpair(&src, &dst) != 0)
2012 {
2013 ok(0, "creating socket pair failed, skipping test\n");
2014 return;
2015 }
2016
2017 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
2018 if (hThread == NULL)
2019 {
2020 ok(0, "CreateThread failed, error %d\n", GetLastError());
2021 goto end;
2022 }
2023
2024 buffer = HeapAlloc(GetProcessHeap(), 0, buflen);
2025 if (buffer == NULL)
2026 {
2027 ok(0, "HeapAlloc failed, error %d\n", GetLastError());
2028 goto end;
2029 }
2030
2031 ret = send(src, buffer, buflen, 0);
2032 if (ret >= 0)
2033 ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
2034 else
2035 ok(0, "send failed, error %d\n", WSAGetLastError());
2036
2037 end:
2038 if (src != INVALID_SOCKET)
2039 closesocket(src);
2040 if (dst != INVALID_SOCKET)
2041 closesocket(dst);
2042 if (hThread != NULL)
2043 CloseHandle(hThread);
2044 HeapFree(GetProcessHeap(), 0, buffer);
2045 }
2046
2047 static void test_write_events(void)
2048 {
2049 SOCKET src = INVALID_SOCKET;
2050 SOCKET dst = INVALID_SOCKET;
2051 HANDLE hThread = NULL;
2052 HANDLE hEvent = INVALID_HANDLE_VALUE;
2053 int len;
2054 u_long one = 1;
2055 int ret;
2056 DWORD id;
2057
2058 if (tcp_socketpair(&src, &dst) != 0)
2059 {
2060 ok(0, "creating socket pair failed, skipping test\n");
2061 return;
2062 }
2063
2064 hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
2065 if (hThread == NULL)
2066 {
2067 ok(0, "CreateThread failed, error %d\n", GetLastError());
2068 goto end;
2069 }
2070
2071 hEvent = CreateEventW(NULL, FALSE, TRUE, NULL);
2072 if (hEvent == INVALID_HANDLE_VALUE)
2073 {
2074 ok(0, "CreateEventW failed, error %d\n", GetLastError());
2075 goto end;
2076 }
2077
2078 ret = ioctlsocket(src, FIONBIO, &one);
2079 if (ret)
2080 {
2081 ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
2082 goto end;
2083 }
2084
2085 ret = WSAEventSelect(src, hEvent, FD_WRITE | FD_CLOSE);
2086 if (ret)
2087 {
2088 ok(0, "WSAEventSelect failed, error %d\n", ret);
2089 goto end;
2090 }
2091
2092 for (len = 100; len > 0; --len)
2093 {
2094 WSANETWORKEVENTS netEvents;
2095 DWORD dwRet = WaitForSingleObject(hEvent, 5000);
2096 if (dwRet != WAIT_OBJECT_0)
2097 {
2098 ok(0, "WaitForSingleObject failed, error %d\n", dwRet);
2099 goto end;
2100 }
2101
2102 ret = WSAEnumNetworkEvents(src, NULL, &netEvents);
2103 if (ret)
2104 {
2105 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
2106 goto end;
2107 }
2108
2109 if (netEvents.lNetworkEvents & FD_WRITE)
2110 {
2111 ret = send(src, "a", 1, 0);
2112 if (ret < 0 && WSAGetLastError() != WSAEWOULDBLOCK)
2113 {
2114 ok(0, "send failed, error %d\n", WSAGetLastError());
2115 goto end;
2116 }
2117 }
2118
2119 if (netEvents.lNetworkEvents & FD_CLOSE)
2120 {
2121 ok(0, "unexpected close\n");
2122 goto end;
2123 }
2124 }
2125
2126 end:
2127 if (src != INVALID_SOCKET)
2128 closesocket(src);
2129 if (dst != INVALID_SOCKET)
2130 closesocket(dst);
2131 if (hThread != NULL)
2132 CloseHandle(hThread);
2133 CloseHandle(hEvent);
2134 }
2135
2136 static void test_ipv6only(void)
2137 {
2138 SOCKET v4 = INVALID_SOCKET,
2139 v6 = INVALID_SOCKET;
2140 struct sockaddr_in sin4;
2141 struct sockaddr_in6 sin6;
2142 int ret;
2143
2144 memset(&sin4, 0, sizeof(sin4));
2145 sin4.sin_family = AF_INET;
2146 sin4.sin_port = htons(SERVERPORT);
2147
2148 memset(&sin6, 0, sizeof(sin6));
2149 sin6.sin6_family = AF_INET6;
2150 sin6.sin6_port = htons(SERVERPORT);
2151
2152 v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
2153 if (v6 == INVALID_SOCKET) {
2154 skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
2155 WSAGetLastError(), WSAEAFNOSUPPORT);
2156 goto end;
2157 }
2158 ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
2159 if (ret) {
2160 skip("Could not bind IPv6 address (LastError: %d).\n",
2161 WSAGetLastError());
2162 goto end;
2163 }
2164
2165 v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
2166 if (v4 == INVALID_SOCKET) {
2167 skip("Could not create IPv4 socket (LastError: %d).\n",
2168 WSAGetLastError());
2169 goto end;
2170 }
2171 ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
2172 ok(!ret, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
2173 WSAGetLastError(), WSAEADDRINUSE);
2174
2175 end:
2176 if (v4 != INVALID_SOCKET)
2177 closesocket(v4);
2178 if (v6 != INVALID_SOCKET)
2179 closesocket(v6);
2180 }
2181
2182 /**************** Main program ***************/
2183
2184 START_TEST( sock )
2185 {
2186 int i;
2187 Init();
2188
2189 test_set_getsockopt();
2190 test_so_reuseaddr();
2191 test_extendedSocketOptions();
2192
2193 for (i = 0; i < NUM_TESTS; i++)
2194 {
2195 trace ( " **** STARTING TEST %d ****\n", i );
2196 do_test ( &tests[i] );
2197 trace ( " **** TEST %d COMPLETE ****\n", i );
2198 }
2199
2200 test_UDP();
2201
2202 test_getservbyname();
2203 test_WSASocket();
2204
2205 test_WSAAddressToStringA();
2206 test_WSAAddressToStringW();
2207
2208 test_WSAStringToAddressA();
2209 test_WSAStringToAddressW();
2210
2211 test_select();
2212 test_accept();
2213 test_getsockname();
2214 test_inet_addr();
2215 test_dns();
2216 test_gethostbyname_hack();
2217
2218 test_send();
2219 test_write_events();
2220
2221 test_ipv6only();
2222
2223 Exit();
2224 }
Maarten's multimedia branch