git.oblomov.eu Git - wine/blob - dlls/ws2_32/tests/sock.c

   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 <mswsock.h>
  28 #include "wine/test.h"
  29 #include <winnt.h>
  30 #include <winerror.h>
  31
  32 #define MAX_CLIENTS 4      /* Max number of clients */
  33 #define NUM_TESTS   3      /* Number of tests performed */
  34 #define FIRST_CHAR 'A'     /* First character in transferred pattern */
  35 #define BIND_SLEEP 10      /* seconds to wait between attempts to bind() */
  36 #define BIND_TRIES 6       /* Number of bind() attempts */
  37 #define TEST_TIMEOUT 30    /* seconds to wait before killing child threads
  38                               after server initialization, if something hangs */
  39
  40 #define NUM_UDP_PEERS 3    /* Number of UDP sockets to create and test > 1 */
  41
  42 #define NUM_THREADS 3      /* Number of threads to run getservbyname */
  43 #define NUM_QUERIES 250    /* Number of getservbyname queries per thread */
  44
  45 #define SERVERIP "127.0.0.1"   /* IP to bind to */
  46 #define SERVERPORT 9374        /* Port number to bind to */
  47
  48 #define wsa_ok(op, cond, msg) \
  49    do { \
  50         int tmp, err = 0; \
  51         tmp = op; \
  52         if ( !(cond tmp) ) err = WSAGetLastError(); \
  53         ok ( cond tmp, msg, GetCurrentThreadId(), err); \
  54    } while (0);
  55
  56
  57 /**************** Structs and typedefs ***************/
  58
  59 typedef struct thread_info
  60 {
  61     HANDLE thread;
  62     DWORD id;
  63 } thread_info;
  64
  65 /* Information in the server about open client connections */
  66 typedef struct sock_info
  67 {
  68     SOCKET                 s;
  69     struct sockaddr_in     addr;
  70     struct sockaddr_in     peer;
  71     char                  *buf;
  72     int                    n_recvd;
  73     int                    n_sent;
  74 } sock_info;
  75
  76 /* Test parameters for both server & client */
  77 typedef struct test_params
  78 {
  79     int          sock_type;
  80     int          sock_prot;
  81     const char  *inet_addr;
  82     short        inet_port;
  83     int          chunk_size;
  84     int          n_chunks;
  85     int          n_clients;
  86 } test_params;
  87
  88 /* server-specific test parameters */
  89 typedef struct server_params
  90 {
  91     test_params   *general;
  92     DWORD          sock_flags;
  93     int            buflen;
  94 } server_params;
  95
  96 /* client-specific test parameters */
  97 typedef struct client_params
  98 {
  99     test_params   *general;
 100     DWORD          sock_flags;
 101     int            buflen;
 102 } client_params;
 103
 104 /* This type combines all information for setting up a test scenario */
 105 typedef struct test_setup
 106 {
 107     test_params              general;
 108     LPVOID                   srv;
 109     server_params            srv_params;
 110     LPVOID                   clt;
 111     client_params            clt_params;
 112 } test_setup;
 113
 114 /* Thread local storage for server */
 115 typedef struct server_memory
 116 {
 117     SOCKET                  s;
 118     struct sockaddr_in      addr;
 119     sock_info               sock[MAX_CLIENTS];
 120 } server_memory;
 121
 122 /* Thread local storage for client */
 123 typedef struct client_memory
 124 {
 125     SOCKET s;
 126     struct sockaddr_in      addr;
 127     char                   *send_buf;
 128     char                   *recv_buf;
 129 } client_memory;
 130
 131 /* SelectReadThread thread parameters */
 132 typedef struct select_thread_params
 133 {
 134     SOCKET s;
 135     BOOL ReadKilled;
 136 } select_thread_params;
 137
 138 /**************** Static variables ***************/
 139
 140 static DWORD      tls;              /* Thread local storage index */
 141 static HANDLE     thread[1+MAX_CLIENTS];
 142 static DWORD      thread_id[1+MAX_CLIENTS];
 143 static HANDLE     server_ready;
 144 static HANDLE     client_ready[MAX_CLIENTS];
 145 static int        client_id;
 146
 147 /**************** General utility functions ***************/
 148
 149 static void set_so_opentype ( BOOL overlapped )
 150 {
 151     int optval = !overlapped, newval, len = sizeof (int);
 152
 153     ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
 154                       (LPVOID) &optval, sizeof (optval) ) == 0,
 155          "setting SO_OPENTYPE failed\n" );
 156     ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
 157                       (LPVOID) &newval, &len ) == 0,
 158          "getting SO_OPENTYPE failed\n" );
 159     ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
 160 }
 161
 162 static int set_blocking ( SOCKET s, BOOL blocking )
 163 {
 164     u_long val = !blocking;
 165     return ioctlsocket ( s, FIONBIO, &val );
 166 }
 167
 168 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
 169 {
 170     char c, *p;
 171     for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
 172         memset ( p, c, chunk_size );
 173 }
 174
 175 static char* test_buffer ( char *buf, int chunk_size, int n_chunks )
 176 {
 177     char c, *p;
 178     int i;
 179     for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
 180     {
 181         for ( i = 0; i < chunk_size; i++ )
 182             if ( p[i] != c ) return p + i;
 183     }
 184     return NULL;
 185 }
 186
 187 /*
 188  * This routine is called when a client / server does not expect any more data,
 189  * but needs to acknowedge the closing of the connection (by reasing 0 bytes).
 190  */
 191 static void read_zero_bytes ( SOCKET s )
 192 {
 193     char buf[256];
 194     int tmp, n = 0;
 195     while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
 196         n += tmp;
 197     ok ( n <= 0, "garbage data received: %d bytes\n", n );
 198 }
 199
 200 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int sendlen )
 201 {
 202     char* last = buf + buflen, *p;
 203     int n = 1;
 204     for ( p = buf; n > 0 && p < last; p += n )
 205         n = send ( s, p, min ( sendlen, last - p ), 0 );
 206     wsa_ok ( n, 0 <=, "do_synchronous_send (%x): error %d\n" );
 207     return p - buf;
 208 }
 209
 210 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int recvlen )
 211 {
 212     char* last = buf + buflen, *p;
 213     int n = 1;
 214     for ( p = buf; n > 0 && p < last; p += n )
 215         n = recv ( s, p, min ( recvlen, last - p ), 0 );
 216     wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
 217     return p - buf;
 218 }
 219
 220 /*
 221  *  Call this routine right after thread startup.
 222  *  SO_OPENTYPE must by 0, regardless what the server did.
 223  */
 224 static void check_so_opentype (void)
 225 {
 226     int tmp = 1, len;
 227     len = sizeof (tmp);
 228     getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
 229     ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
 230 }
 231
 232 /**************** Server utility functions ***************/
 233
 234 /*
 235  *  Even if we have closed our server socket cleanly,
 236  *  the OS may mark the address "in use" for some time -
 237  *  this happens with native Linux apps, too.
 238  */
 239 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
 240 {
 241     int err, wsaerr = 0, n_try = BIND_TRIES;
 242
 243     while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
 244             ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
 245             n_try-- >= 0)
 246     {
 247         trace ( "address in use, waiting ...\n" );
 248         Sleep ( 1000 * BIND_SLEEP );
 249     }
 250     ok ( err == 0, "failed to bind: %d\n", wsaerr );
 251 }
 252
 253 static void server_start ( server_params *par )
 254 {
 255     int i;
 256     test_params *gen = par->general;
 257     server_memory *mem = (LPVOID) LocalAlloc ( LPTR, sizeof (server_memory));
 258
 259     TlsSetValue ( tls, mem );
 260     mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
 261                           NULL, 0, par->sock_flags );
 262     ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
 263
 264     mem->addr.sin_family = AF_INET;
 265     mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
 266     mem->addr.sin_port = htons ( gen->inet_port );
 267
 268     for (i = 0; i < MAX_CLIENTS; i++)
 269     {
 270         mem->sock[i].s = INVALID_SOCKET;
 271         mem->sock[i].buf = (LPVOID) LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
 272         mem->sock[i].n_recvd = 0;
 273         mem->sock[i].n_sent = 0;
 274     }
 275
 276     if ( gen->sock_type == SOCK_STREAM )
 277         do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
 278 }
 279
 280 static void server_stop (void)
 281 {
 282     int i;
 283     server_memory *mem = TlsGetValue ( tls );
 284
 285     for (i = 0; i < MAX_CLIENTS; i++ )
 286     {
 287         LocalFree ( (HANDLE) mem->sock[i].buf );
 288         if ( mem->sock[i].s != INVALID_SOCKET )
 289             closesocket ( mem->sock[i].s );
 290     }
 291     ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
 292     LocalFree ( (HANDLE) mem );
 293     ExitThread ( GetCurrentThreadId () );
 294 }
 295
 296 /**************** Client utilitiy functions ***************/
 297
 298 static void client_start ( client_params *par )
 299 {
 300     test_params *gen = par->general;
 301     client_memory *mem = (LPVOID) LocalAlloc (LPTR, sizeof (client_memory));
 302
 303     TlsSetValue ( tls, mem );
 304
 305     WaitForSingleObject ( server_ready, INFINITE );
 306
 307     mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
 308                           NULL, 0, par->sock_flags );
 309
 310     mem->addr.sin_family = AF_INET;
 311     mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
 312     mem->addr.sin_port = htons ( gen->inet_port );
 313
 314     ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
 315
 316     mem->send_buf = (LPVOID) LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
 317     mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
 318     fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
 319
 320     SetEvent ( client_ready[client_id] );
 321     /* Wait for the other clients to come up */
 322     WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
 323 }
 324
 325 static void client_stop (void)
 326 {
 327     client_memory *mem = TlsGetValue ( tls );
 328     wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%x): %d\n" );
 329     LocalFree ( (HANDLE) mem->send_buf );
 330     LocalFree ( (HANDLE) mem );
 331     ExitThread(0);
 332 }
 333
 334 /**************** Servers ***************/
 335
 336 /*
 337  * simple_server: A very basic server doing synchronous IO.
 338  */
 339 static VOID WINAPI simple_server ( server_params *par )
 340 {
 341     test_params *gen = par->general;
 342     server_memory *mem;
 343     int n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
 344         id = GetCurrentThreadId();
 345     char *p;
 346
 347     trace ( "simple_server (%x) starting\n", id );
 348
 349     set_so_opentype ( FALSE ); /* non-overlapped */
 350     server_start ( par );
 351     mem = TlsGetValue ( tls );
 352
 353     wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
 354     wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%x): listen failed: %d\n");
 355
 356     trace ( "simple_server (%x) ready\n", id );
 357     SetEvent ( server_ready ); /* notify clients */
 358
 359     for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
 360     {
 361         trace ( "simple_server (%x): waiting for client\n", id );
 362
 363         /* accept a single connection */
 364         tmp = sizeof ( mem->sock[0].peer );
 365         mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
 366         wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%x): accept failed: %d\n" );
 367
 368         ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
 369              "simple_server (%x): strange peer address\n", id );
 370
 371         /* Receive data & check it */
 372         n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
 373         ok ( n_recvd == n_expected,
 374              "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
 375         p = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
 376         ok ( p == NULL, "simple_server (%x): test pattern error: %d\n", id, p - mem->sock[0].buf);
 377
 378         /* Echo data back */
 379         n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
 380         ok ( n_sent == n_expected,
 381              "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
 382
 383         /* cleanup */
 384         read_zero_bytes ( mem->sock[0].s );
 385         wsa_ok ( closesocket ( mem->sock[0].s ),  0 ==, "simple_server (%x): closesocket error: %d\n" );
 386         mem->sock[0].s = INVALID_SOCKET;
 387     }
 388
 389     trace ( "simple_server (%x) exiting\n", id );
 390     server_stop ();
 391 }
 392
 393 /*
 394  * select_server: A non-blocking server.
 395  */
 396 static VOID WINAPI select_server ( server_params *par )
 397 {
 398     test_params *gen = par->general;
 399     server_memory *mem;
 400     int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
 401         id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
 402         n_set, delta, n_ready;
 403     char *p;
 404     struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
 405     fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
 406
 407     trace ( "select_server (%x) starting\n", id );
 408
 409     set_so_opentype ( FALSE ); /* non-overlapped */
 410     server_start ( par );
 411     mem = TlsGetValue ( tls );
 412
 413     wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
 414     wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%x): listen failed: %d\n");
 415
 416     trace ( "select_server (%x) ready\n", id );
 417     SetEvent ( server_ready ); /* notify clients */
 418
 419     FD_ZERO ( &fds_openrecv );
 420     FD_ZERO ( &fds_recv );
 421     FD_ZERO ( &fds_send );
 422     FD_ZERO ( &fds_opensend );
 423
 424     FD_SET ( mem->s, &fds_openrecv );
 425
 426     while(1)
 427     {
 428         fds_recv = fds_openrecv;
 429         fds_send = fds_opensend;
 430
 431         n_set = 0;
 432
 433         wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
 434             "select_server (%x): select() failed: %d\n" );
 435
 436         /* check for incoming requests */
 437         if ( FD_ISSET ( mem->s, &fds_recv ) ) {
 438             n_set += 1;
 439
 440             trace ( "select_server (%x): accepting client connection\n", id );
 441
 442             /* accept a single connection */
 443             tmp = sizeof ( mem->sock[n_connections].peer );
 444             mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
 445             wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%x): accept() failed: %d\n" );
 446
 447             ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
 448                 "select_server (%x): strange peer address\n", id );
 449
 450             /* add to list of open connections */
 451             FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
 452             FD_SET ( mem->sock[n_connections].s, &fds_opensend );
 453
 454             n_connections++;
 455         }
 456
 457         /* handle open requests */
 458
 459         for ( i = 0; i < n_connections; i++ )
 460         {
 461             if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
 462                 n_set += 1;
 463
 464                 if ( mem->sock[i].n_recvd < n_expected ) {
 465                     /* Receive data & check it */
 466                     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 );
 467                     ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
 468                     mem->sock[i].n_recvd += n_recvd;
 469
 470                     if ( mem->sock[i].n_recvd == n_expected ) {
 471                         p = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
 472                         ok ( p == NULL, "select_server (%x): test pattern error: %d\n", id, p - mem->sock[i].buf );
 473                         FD_CLR ( mem->sock[i].s, &fds_openrecv );
 474                     }
 475
 476                     ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
 477                 }
 478             }
 479
 480             /* only echo back what we've received */
 481             delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
 482
 483             if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
 484                 n_set += 1;
 485
 486                 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
 487                     /* Echo data back */
 488                     n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
 489                     ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
 490                     mem->sock[i].n_sent += n_sent;
 491
 492                     if ( mem->sock[i].n_sent == n_expected ) {
 493                         FD_CLR ( mem->sock[i].s, &fds_opensend );
 494                     }
 495
 496                     ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
 497                 }
 498             }
 499         }
 500
 501         /* check that select returned the correct number of ready sockets */
 502         ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
 503
 504         /* check if all clients are done */
 505         if ( ( fds_opensend.fd_count == 0 )
 506             && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
 507             && ( n_connections  == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
 508             break;
 509         }
 510     }
 511
 512     for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
 513     {
 514         /* cleanup */
 515         read_zero_bytes ( mem->sock[i].s );
 516         wsa_ok ( closesocket ( mem->sock[i].s ),  0 ==, "select_server (%x): closesocket error: %d\n" );
 517         mem->sock[i].s = INVALID_SOCKET;
 518     }
 519
 520     trace ( "select_server (%x) exiting\n", id );
 521     server_stop ();
 522 }
 523
 524 /**************** Clients ***************/
 525
 526 /*
 527  * simple_client: A very basic client doing synchronous IO.
 528  */
 529 static VOID WINAPI simple_client ( client_params *par )
 530 {
 531     test_params *gen = par->general;
 532     client_memory *mem;
 533     int n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
 534     char *p;
 535
 536     id = GetCurrentThreadId();
 537     trace ( "simple_client (%x): starting\n", id );
 538     /* wait here because we want to call set_so_opentype before creating a socket */
 539     WaitForSingleObject ( server_ready, INFINITE );
 540     trace ( "simple_client (%x): server ready\n", id );
 541
 542     check_so_opentype ();
 543     set_so_opentype ( FALSE ); /* non-overlapped */
 544     client_start ( par );
 545     mem = TlsGetValue ( tls );
 546
 547     /* Connect */
 548     wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
 549              0 ==, "simple_client (%x): connect error: %d\n" );
 550     ok ( set_blocking ( mem->s, TRUE ) == 0,
 551          "simple_client (%x): failed to set blocking mode\n", id );
 552     trace ( "simple_client (%x) connected\n", id );
 553
 554     /* send data to server */
 555     n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, par->buflen );
 556     ok ( n_sent == n_expected,
 557          "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
 558
 559     /* shutdown send direction */
 560     wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
 561
 562     /* Receive data echoed back & check it */
 563     n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, par->buflen );
 564     ok ( n_recvd == n_expected,
 565          "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
 566
 567     /* check data */
 568     p = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
 569     ok ( p == NULL, "simple_client (%x): test pattern error: %d\n", id, p - mem->recv_buf);
 570
 571     /* cleanup */
 572     read_zero_bytes ( mem->s );
 573     trace ( "simple_client (%x) exiting\n", id );
 574     client_stop ();
 575 }
 576
 577 /*
 578  * event_client: An event-driven client
 579  */
 580 static void WINAPI event_client ( client_params *par )
 581 {
 582     test_params *gen = par->general;
 583     client_memory *mem;
 584     int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
 585         tmp, err, n;
 586     HANDLE event;
 587     WSANETWORKEVENTS wsa_events;
 588     char *send_last, *recv_last, *send_p, *recv_p;
 589     long mask = FD_READ | FD_WRITE | FD_CLOSE;
 590
 591     trace ( "event_client (%x): starting\n", id );
 592     client_start ( par );
 593     trace ( "event_client (%x): server ready\n", id );
 594
 595     mem = TlsGetValue ( tls );
 596
 597     /* Prepare event notification for connect, makes socket nonblocking */
 598     event = WSACreateEvent ();
 599     WSAEventSelect ( mem->s, event, FD_CONNECT );
 600     tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
 601     if ( tmp != 0 && ( err = WSAGetLastError () ) != WSAEWOULDBLOCK )
 602         ok ( 0, "event_client (%x): connect error: %d\n", id, err );
 603
 604     tmp = WaitForSingleObject ( event, INFINITE );
 605     ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
 606     err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
 607     wsa_ok ( err, 0 ==, "event_client (%x): WSAEnumNetworkEvents error: %d\n" );
 608
 609     err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
 610     ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
 611     if ( err ) goto out;
 612
 613     trace ( "event_client (%x) connected\n", id );
 614
 615     WSAEventSelect ( mem->s, event, mask );
 616
 617     recv_p = mem->recv_buf;
 618     recv_last = mem->recv_buf + n_expected;
 619     send_p = mem->send_buf;
 620     send_last = mem->send_buf + n_expected;
 621
 622     while ( TRUE )
 623     {
 624         err = WaitForSingleObject ( event, INFINITE );
 625         ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
 626
 627         err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
 628         wsa_ok ( err, 0 ==, "event_client (%x): WSAEnumNetworkEvents error: %d\n" );
 629
 630         if ( wsa_events.lNetworkEvents & FD_WRITE )
 631         {
 632             err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
 633             ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
 634
 635             if ( err== 0 )
 636                 do
 637                 {
 638                     n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
 639                     if ( n < 0 )
 640                     {
 641                         err = WSAGetLastError ();
 642                         ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
 643                     }
 644                     else
 645                         send_p += n;
 646                 }
 647                 while ( n >= 0 && send_p < send_last );
 648
 649             if ( send_p == send_last )
 650             {
 651                 trace ( "event_client (%x): all data sent - shutdown\n", id );
 652                 shutdown ( mem->s, SD_SEND );
 653                 mask &= ~FD_WRITE;
 654                 WSAEventSelect ( mem->s, event, mask );
 655             }
 656         }
 657         if ( wsa_events.lNetworkEvents & FD_READ )
 658         {
 659             err = wsa_events.iErrorCode[ FD_READ_BIT ];
 660             ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
 661             if ( err != 0 ) break;
 662
 663             /* First read must succeed */
 664             n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
 665             wsa_ok ( n, 0 <=, "event_client (%x): recv error: %d\n" );
 666
 667             while ( n >= 0 ) {
 668                 recv_p += n;
 669                 if ( recv_p == recv_last )
 670                 {
 671                     mask &= ~FD_READ;
 672                     trace ( "event_client (%x): all data received\n", id );
 673                     WSAEventSelect ( mem->s, event, mask );
 674                     break;
 675                 }
 676                 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
 677                 if ( n < 0 && ( err = WSAGetLastError()) != WSAEWOULDBLOCK )
 678                     ok ( 0, "event_client (%x): read error: %d\n", id, err );
 679
 680             }
 681         }
 682         if ( wsa_events.lNetworkEvents & FD_CLOSE )
 683         {
 684             trace ( "event_client (%x): close event\n", id );
 685             err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
 686             ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
 687             break;
 688         }
 689     }
 690
 691     ok ( send_p == send_last,
 692          "simple_client (%x): sent less data than expected: %d of %d\n",
 693          id, send_p - mem->send_buf, n_expected );
 694     ok ( recv_p == recv_last,
 695          "simple_client (%x): received less data than expected: %d of %d\n",
 696          id, recv_p - mem->recv_buf, n_expected );
 697     recv_p = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
 698     ok ( recv_p == NULL, "event_client (%x): test pattern error: %d\n", id, recv_p - mem->recv_buf);
 699
 700 out:
 701     WSACloseEvent ( event );
 702     trace ( "event_client (%x) exiting\n", id );
 703     client_stop ();
 704 }
 705
 706 /**************** Main program utility functions ***************/
 707
 708 static void Init (void)
 709 {
 710     WORD ver = MAKEWORD (2, 2);
 711     WSADATA data;
 712
 713     ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
 714     tls = TlsAlloc();
 715 }
 716
 717 static void Exit (void)
 718 {
 719     INT ret, err;
 720     TlsFree ( tls );
 721     ret = WSACleanup();
 722     err = WSAGetLastError();
 723     ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
 724     ret = WSACleanup();
 725     err = WSAGetLastError();
 726     ok ( ret == SOCKET_ERROR && err ==  WSANOTINITIALISED,
 727             "WSACleanup returned %d GetLastError is %d\n", ret, err);
 728 }
 729
 730 static void StartServer (LPTHREAD_START_ROUTINE routine,
 731                          test_params *general, server_params *par)
 732 {
 733     par->general = general;
 734     thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
 735     ok ( thread[0] != NULL, "Failed to create server thread\n" );
 736 }
 737
 738 static void StartClients (LPTHREAD_START_ROUTINE routine,
 739                           test_params *general, client_params *par)
 740 {
 741     int i;
 742     par->general = general;
 743     for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
 744     {
 745         client_id = i - 1;
 746         thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
 747         ok ( thread[i] != NULL, "Failed to create client thread\n" );
 748         /* Make sure the client is up and running */
 749         WaitForSingleObject ( client_ready[client_id], INFINITE );
 750     };
 751 }
 752
 753 static void do_test( test_setup *test )
 754 {
 755     DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
 756     DWORD wait;
 757
 758     server_ready = CreateEventW ( NULL, TRUE, FALSE, NULL );
 759     for (i = 0; i <= n; i++)
 760         client_ready[i] = CreateEventW ( NULL, TRUE, FALSE, NULL );
 761
 762     StartServer ( test->srv, &test->general, &test->srv_params );
 763     StartClients ( test->clt, &test->general, &test->clt_params );
 764     WaitForSingleObject ( server_ready, INFINITE );
 765
 766     wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
 767     ok ( wait >= WAIT_OBJECT_0 && wait <= WAIT_OBJECT_0 + n ,
 768          "some threads have not completed: %x\n", wait );
 769
 770     if ( ! ( wait >= WAIT_OBJECT_0 && wait <= WAIT_OBJECT_0 + n ) )
 771     {
 772         for (i = 0; i <= n; i++)
 773         {
 774             trace ("terminating thread %08x\n", thread_id[i]);
 775             if ( WaitForSingleObject ( thread[i], 0 ) != WAIT_OBJECT_0 )
 776                 TerminateThread ( thread [i], 0 );
 777         }
 778     }
 779     CloseHandle ( server_ready );
 780     for (i = 0; i <= n; i++)
 781         CloseHandle ( client_ready[i] );
 782 }
 783
 784 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
 785 /* optname = SO_LINGER */
 786 LINGER linger_testvals[] = {
 787     {0,0},
 788     {0,73},
 789     {1,0},
 790     {5,189}
 791 };
 792
 793 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
 794 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
 795                         bug in the linux kernel (fixed in 2.6.8) */
 796 #define SOCKTIMEOUT2 997000 /* 997 seconds */
 797
 798 static void test_set_getsockopt(void)
 799 {
 800     SOCKET s;
 801     int i, err;
 802     int timeout;
 803     LINGER lingval;
 804     int size;
 805
 806     s = socket(AF_INET, SOCK_STREAM, 0);
 807     ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
 808     if( s == INVALID_SOCKET) return;
 809     /* SO_RCVTIMEO */
 810     timeout = SOCKTIMEOUT1;
 811     size = sizeof(timeout);
 812     err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
 813     if( !err)
 814         err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
 815     ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
 816     ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
 817     /* SO_SNDTIMEO */
 818     timeout = SOCKTIMEOUT2; /* 54 seconds. See remark above */
 819     size = sizeof(timeout);
 820     err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
 821     if( !err)
 822         err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
 823     ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
 824     ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
 825     /* SO_LINGER */
 826     for( i = 0; i < sizeof(linger_testvals)/sizeof(LINGER);i++) {
 827         size =  sizeof(lingval);
 828         lingval = linger_testvals[i];
 829         err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, size);
 830         if( !err)
 831             err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, &size);
 832         ok( !err, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
 833         ok( !lingval.l_onoff == !linger_testvals[i].l_onoff &&
 834                 (lingval.l_linger == linger_testvals[i].l_linger ||
 835                  (!lingval.l_linger && !linger_testvals[i].l_onoff))
 836                 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i,
 837                  lingval.l_onoff, lingval.l_linger,
 838                  linger_testvals[i].l_onoff, linger_testvals[i].l_linger);
 839     }
 840     closesocket(s);
 841 }
 842
 843 static void test_so_reuseaddr(void)
 844 {
 845     struct sockaddr_in saddr;
 846     SOCKET s1,s2;
 847     unsigned int rc,reuse;
 848     int size;
 849
 850     saddr.sin_family      = AF_INET;
 851     saddr.sin_port        = htons(9375);
 852     saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
 853
 854     s1=socket(AF_INET, SOCK_STREAM, 0);
 855     ok(s1!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
 856     rc = bind(s1, (struct sockaddr*)&saddr, sizeof(saddr));
 857     ok(rc!=SOCKET_ERROR, "bind(s1) failed error: %d\n", WSAGetLastError());
 858
 859     s2=socket(AF_INET, SOCK_STREAM, 0);
 860     ok(s2!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
 861
 862     reuse=0x1234;
 863     size=sizeof(reuse);
 864     rc=getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size );
 865     ok(rc==0 && reuse==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc,reuse);
 866
 867     rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
 868     ok(rc==SOCKET_ERROR, "bind() succeeded\n");
 869
 870     reuse = 1;
 871     rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
 872     ok(rc==0, "setsockopt() failed error: %d\n", WSAGetLastError());
 873
 874     todo_wine {
 875     rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
 876     ok(rc==0, "bind() failed error: %d\n", WSAGetLastError());
 877     }
 878
 879     closesocket(s2);
 880     closesocket(s1);
 881 }
 882
 883 /************* Array containing the tests to run **********/
 884
 885 #define STD_STREAM_SOCKET \
 886             SOCK_STREAM, \
 887             0, \
 888             SERVERIP, \
 889             SERVERPORT
 890
 891 static test_setup tests [NUM_TESTS] =
 892 {
 893     /* Test 0: synchronous client and server */
 894     {
 895         {
 896             STD_STREAM_SOCKET,
 897             2048,
 898             16,
 899             2
 900         },
 901         simple_server,
 902         {
 903             NULL,
 904             0,
 905             64
 906         },
 907         simple_client,
 908         {
 909             NULL,
 910             0,
 911             128
 912         }
 913     },
 914     /* Test 1: event-driven client, synchronous server */
 915     {
 916         {
 917             STD_STREAM_SOCKET,
 918             2048,
 919             16,
 920             2
 921         },
 922         simple_server,
 923         {
 924             NULL,
 925             0,
 926             64
 927         },
 928         event_client,
 929         {
 930             NULL,
 931             WSA_FLAG_OVERLAPPED,
 932             128
 933         }
 934     },
 935     /* Test 2: synchronous client, non-blocking server via select() */
 936     {
 937         {
 938             STD_STREAM_SOCKET,
 939             2048,
 940             16,
 941             2
 942         },
 943         select_server,
 944         {
 945             NULL,
 946             0,
 947             64
 948         },
 949         simple_client,
 950         {
 951             NULL,
 952             0,
 953             128
 954         }
 955     }
 956 };
 957
 958 static void test_UDP(void)
 959 {
 960     /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
 961        possible that this test fails due to dropped packets. */
 962
 963     /* peer 0 receives data from all other peers */
 964     struct sock_info peer[NUM_UDP_PEERS];
 965     char buf[16];
 966     int ss, i, n_recv, n_sent;
 967
 968     for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
 969         ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
 970
 971         peer[i].addr.sin_family         = AF_INET;
 972         peer[i].addr.sin_addr.s_addr    = inet_addr ( SERVERIP );
 973
 974         if ( i == 0 ) {
 975             peer[i].addr.sin_port       = htons ( SERVERPORT );
 976         } else {
 977             peer[i].addr.sin_port       = htons ( 0 );
 978         }
 979
 980         do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
 981
 982         /* test getsockname() to get peer's port */
 983         ss = sizeof ( peer[i].addr );
 984         ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
 985         ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
 986     }
 987
 988     /* test getsockname() */
 989     ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
 990
 991     for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
 992         /* send client's ip */
 993         memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
 994         n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
 995         ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
 996     }
 997
 998     for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
 999         n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
1000         ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
1001         ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
1002     }
1003 }
1004
1005 static void WINAPI do_getservbyname( HANDLE *starttest )
1006 {
1007     struct {
1008         const char *name;
1009         const char *proto;
1010         int port;
1011     } serv[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
1012
1013     int i, j;
1014     struct servent *pserv[2];
1015
1016     ok ( WaitForSingleObject ( *starttest, TEST_TIMEOUT * 1000 ) != WAIT_TIMEOUT, "test_getservbyname: timeout waiting for start signal\n");
1017
1018     /* ensure that necessary buffer resizes are completed */
1019     for ( j = 0; j < 2; j++) {
1020         pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1021     }
1022
1023     for ( i = 0; i < NUM_QUERIES / 2; i++ ) {
1024         for ( j = 0; j < 2; j++ ) {
1025             pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1026             ok ( pserv[j] != NULL, "getservbyname could not retrieve information for %s: %d\n", serv[j].name, WSAGetLastError() );
1027             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) );
1028             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 );
1029             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 );
1030         }
1031
1032         ok ( pserv[0] == pserv[1], "getservbyname: winsock resized servent buffer when not necessary\n" );
1033     }
1034 }
1035
1036 static void test_getservbyname(void)
1037 {
1038     int i;
1039     HANDLE starttest, thread[NUM_THREADS];
1040     DWORD thread_id[NUM_THREADS];
1041
1042     starttest = CreateEvent ( NULL, 1, 0, "test_getservbyname_starttest" );
1043
1044     /* create threads */
1045     for ( i = 0; i < NUM_THREADS; i++ ) {
1046         thread[i] = CreateThread ( NULL, 0, (LPTHREAD_START_ROUTINE) &do_getservbyname, &starttest, 0, &thread_id[i] );
1047     }
1048
1049     /* signal threads to start */
1050     SetEvent ( starttest );
1051
1052     for ( i = 0; i < NUM_THREADS; i++) {
1053         WaitForSingleObject ( thread[i], TEST_TIMEOUT * 1000 );
1054     }
1055 }
1056
1057 static void test_WSAAddressToStringA(void)
1058 {
1059     INT ret;
1060     DWORD len;
1061     int GLE;
1062     SOCKADDR_IN sockaddr;
1063     CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1064
1065     CHAR expect1[] = "0.0.0.0";
1066     CHAR expect2[] = "255.255.255.255";
1067     CHAR expect3[] = "0.0.0.0:65535";
1068     CHAR expect4[] = "255.255.255.255:65535";
1069
1070     len = 0;
1071
1072     sockaddr.sin_family = AF_INET;
1073     sockaddr.sin_port = 0;
1074     sockaddr.sin_addr.s_addr = 0;
1075
1076     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1077     GLE = WSAGetLastError();
1078     ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
1079         "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1080         GLE, ret );
1081
1082     len = sizeof(address);
1083
1084     sockaddr.sin_family = AF_INET;
1085     sockaddr.sin_port = 0;
1086     sockaddr.sin_addr.s_addr = 0;
1087
1088     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1089     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1090
1091     ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
1092
1093     len = sizeof(address);
1094
1095     sockaddr.sin_family = AF_INET;
1096     sockaddr.sin_port = 0;
1097     sockaddr.sin_addr.s_addr = 0xffffffff;
1098
1099     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1100     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1101
1102     ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
1103
1104     len = sizeof(address);
1105
1106     sockaddr.sin_family = AF_INET;
1107     sockaddr.sin_port = 0xffff;
1108     sockaddr.sin_addr.s_addr = 0;
1109
1110     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1111     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1112
1113     ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
1114
1115     len = sizeof(address);
1116
1117     sockaddr.sin_family = AF_INET;
1118     sockaddr.sin_port = 0xffff;
1119     sockaddr.sin_addr.s_addr = 0xffffffff;
1120
1121     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1122     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1123
1124     ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
1125 }
1126
1127 static void test_WSAAddressToStringW(void)
1128 {
1129     INT ret;
1130     DWORD len;
1131     int GLE;
1132     SOCKADDR_IN sockaddr;
1133     WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1134
1135     WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
1136     WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1137     WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
1138     WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1139                         '6', '5', '5', '3', '5', 0 };
1140
1141     len = 0;
1142
1143     sockaddr.sin_family = AF_INET;
1144     sockaddr.sin_port = 0;
1145     sockaddr.sin_addr.s_addr = 0;
1146
1147     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1148     GLE = WSAGetLastError();
1149     ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
1150         "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1151         GLE, ret );
1152
1153     len = sizeof(address);
1154
1155     sockaddr.sin_family = AF_INET;
1156     sockaddr.sin_port = 0;
1157     sockaddr.sin_addr.s_addr = 0;
1158
1159     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1160     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1161
1162     ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
1163
1164     len = sizeof(address);
1165
1166     sockaddr.sin_family = AF_INET;
1167     sockaddr.sin_port = 0;
1168     sockaddr.sin_addr.s_addr = 0xffffffff;
1169
1170     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1171     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1172
1173     ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
1174
1175     len = sizeof(address);
1176
1177     sockaddr.sin_family = AF_INET;
1178     sockaddr.sin_port = 0xffff;
1179     sockaddr.sin_addr.s_addr = 0;
1180
1181     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1182     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1183
1184     ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
1185
1186     len = sizeof(address);
1187
1188     sockaddr.sin_family = AF_INET;
1189     sockaddr.sin_port = 0xffff;
1190     sockaddr.sin_addr.s_addr = 0xffffffff;
1191
1192     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1193     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1194
1195     ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
1196 }
1197
1198 static void test_WSAStringToAddressA(void)
1199 {
1200     INT ret, len;
1201     SOCKADDR_IN sockaddr;
1202     int GLE;
1203
1204     CHAR address1[] = "0.0.0.0";
1205     CHAR address2[] = "127.127.127.127";
1206     CHAR address3[] = "255.255.255.255";
1207     CHAR address4[] = "127.127.127.127:65535";
1208     CHAR address5[] = "255.255.255.255:65535";
1209
1210     len = 0;
1211     sockaddr.sin_family = AF_INET;
1212
1213     ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1214     ok( ret == SOCKET_ERROR, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
1215         WSAGetLastError() );
1216
1217     len = sizeof(sockaddr);
1218     sockaddr.sin_port = 0;
1219     sockaddr.sin_addr.s_addr = 0;
1220
1221     ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1222     ok( !ret && sockaddr.sin_addr.s_addr == 0,
1223         "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1224
1225     len = sizeof(sockaddr);
1226     sockaddr.sin_port = 0;
1227     sockaddr.sin_addr.s_addr = 0;
1228
1229     ret = WSAStringToAddressA( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1230     ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
1231         "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1232
1233     len = sizeof(sockaddr);
1234     sockaddr.sin_port = 0;
1235     sockaddr.sin_addr.s_addr = 0;
1236
1237     ret = WSAStringToAddressA( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1238     GLE = WSAGetLastError();
1239     ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
1240         (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1241         "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
1242
1243     len = sizeof(sockaddr);
1244     sockaddr.sin_port = 0;
1245     sockaddr.sin_addr.s_addr = 0;
1246
1247     ret = WSAStringToAddressA( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1248     ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
1249         "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1250
1251     len = sizeof(sockaddr);
1252     sockaddr.sin_port = 0;
1253     sockaddr.sin_addr.s_addr = 0;
1254
1255     ret = WSAStringToAddressA( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1256     GLE = WSAGetLastError();
1257     ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
1258         (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1259         "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
1260 }
1261
1262 static void test_WSAStringToAddressW(void)
1263 {
1264     INT ret, len;
1265     SOCKADDR_IN sockaddr;
1266     int GLE;
1267
1268     WCHAR address1[] = { '0','.','0','.','0','.','0', 0 };
1269     WCHAR address2[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
1270     WCHAR address3[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1271     WCHAR address4[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
1272                          ':', '6', '5', '5', '3', '5', 0 };
1273     WCHAR address5[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1274                          '6', '5', '5', '3', '5', 0 };
1275
1276     len = 0;
1277     sockaddr.sin_family = AF_INET;
1278
1279     ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1280     ok( ret == SOCKET_ERROR, "WSAStringToAddressW() failed unexpectedly: %d\n",
1281         WSAGetLastError() );
1282
1283     len = sizeof(sockaddr);
1284     sockaddr.sin_port = 0;
1285     sockaddr.sin_addr.s_addr = 0;
1286
1287     ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1288     ok( !ret && sockaddr.sin_addr.s_addr == 0,
1289         "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1290
1291     len = sizeof(sockaddr);
1292     sockaddr.sin_port = 0;
1293     sockaddr.sin_addr.s_addr = 0;
1294
1295     ret = WSAStringToAddressW( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1296     ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
1297         "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1298
1299     len = sizeof(sockaddr);
1300     sockaddr.sin_port = 0;
1301     sockaddr.sin_addr.s_addr = 0;
1302
1303     ret = WSAStringToAddressW( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1304     GLE = WSAGetLastError();
1305     ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
1306         (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1307         "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
1308
1309     len = sizeof(sockaddr);
1310     sockaddr.sin_port = 0;
1311     sockaddr.sin_addr.s_addr = 0;
1312
1313     ret = WSAStringToAddressW( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1314     ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
1315         "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1316
1317     len = sizeof(sockaddr);
1318     sockaddr.sin_port = 0;
1319     sockaddr.sin_addr.s_addr = 0;
1320
1321     ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1322     ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
1323         (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1324         "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
1325 }
1326
1327 static VOID WINAPI SelectReadThread(select_thread_params *par)
1328 {
1329     fd_set readfds;
1330     int ret;
1331     struct sockaddr_in addr;
1332     struct timeval select_timeout;
1333
1334     FD_ZERO(&readfds);
1335     FD_SET(par->s, &readfds);
1336     select_timeout.tv_sec=5;
1337     select_timeout.tv_usec=0;
1338     addr.sin_family = AF_INET;
1339     addr.sin_addr.s_addr = inet_addr(SERVERIP);
1340     addr.sin_port = htons(SERVERPORT);
1341
1342     do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
1343     wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
1344
1345     SetEvent(server_ready);
1346     ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
1347     par->ReadKilled = (ret == 1);
1348 }
1349
1350 static void test_select(void)
1351 {
1352     SOCKET fdRead, fdWrite;
1353     fd_set readfds, writefds, exceptfds;
1354     unsigned int maxfd;
1355     int ret;
1356     struct timeval select_timeout;
1357     select_thread_params thread_params;
1358     HANDLE thread_handle;
1359
1360     fdRead = socket(AF_INET, SOCK_STREAM, 0);
1361     ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
1362     fdWrite = socket(AF_INET, SOCK_STREAM, 0);
1363     ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
1364
1365     FD_ZERO(&readfds);
1366     FD_ZERO(&writefds);
1367     FD_ZERO(&exceptfds);
1368     FD_SET(fdRead, &readfds);
1369     FD_SET(fdWrite, &writefds);
1370     FD_SET(fdRead, &exceptfds);
1371     FD_SET(fdWrite, &exceptfds);
1372     select_timeout.tv_sec=0;
1373     select_timeout.tv_usec=500;
1374
1375     maxfd = fdRead;
1376     if (fdWrite > maxfd)
1377         maxfd = fdWrite;
1378
1379     todo_wine {
1380     ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
1381     ok ( (ret == 0), "select should not return any socket handles\n");
1382     ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
1383     ok ( !FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
1384     }
1385
1386     ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
1387     ok ( !FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
1388
1389     todo_wine {
1390     ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
1391     }
1392     ret = closesocket(fdWrite);
1393     ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
1394
1395     thread_params.s = fdRead;
1396     thread_params.ReadKilled = FALSE;
1397     server_ready = CreateEventW(NULL, TRUE, FALSE, NULL);
1398     thread_handle = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) &SelectReadThread, &thread_params, 0, NULL );
1399     ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
1400
1401     WaitForSingleObject (server_ready, INFINITE);
1402     Sleep(200);
1403     ret = closesocket(fdRead);
1404     ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
1405
1406     WaitForSingleObject (thread_handle, 1000);
1407     ok ( (thread_params.ReadKilled), "closesocket did not wakeup select\n");
1408
1409 }
1410
1411 static DWORD WINAPI AcceptKillThread(select_thread_params *par)
1412 {
1413     struct sockaddr_in address;
1414     int len = sizeof(address);
1415     SOCKET client_socket;
1416
1417     SetEvent(server_ready);
1418     client_socket = accept(par->s, (struct sockaddr*) &address, &len);
1419     if (client_socket != INVALID_SOCKET)
1420         closesocket(client_socket);
1421     par->ReadKilled = (client_socket == INVALID_SOCKET);
1422     return 0;
1423 }
1424
1425 static void test_accept(void)
1426 {
1427     int ret;
1428     SOCKET server_socket = INVALID_SOCKET;
1429     struct sockaddr_in address;
1430     select_thread_params thread_params;
1431     HANDLE thread_handle = NULL;
1432
1433     server_socket = socket(AF_INET, SOCK_STREAM, 0);
1434     if (server_socket == INVALID_SOCKET)
1435     {
1436         trace("error creating server socket: %d\n", WSAGetLastError());
1437         goto done;
1438     }
1439
1440     memset(&address, 0, sizeof(address));
1441     address.sin_family = AF_INET;
1442     ret = bind(server_socket, (struct sockaddr*) &address, sizeof(address));
1443     if (ret != 0)
1444     {
1445         trace("error binding server socket: %d\n", WSAGetLastError());
1446         goto done;
1447     }
1448
1449     ret = listen(server_socket, 1);
1450     if (ret != 0)
1451     {
1452         trace("error making server socket listen: %d\n", WSAGetLastError());
1453         goto done;
1454     }
1455
1456     server_ready = CreateEventW(NULL, TRUE, FALSE, NULL);
1457     if (server_ready == INVALID_HANDLE_VALUE)
1458     {
1459         trace("error creating event: %d\n", GetLastError());
1460         goto done;
1461     }
1462
1463     thread_params.s = server_socket;
1464     thread_params.ReadKilled = FALSE;
1465     thread_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) AcceptKillThread,
1466         &thread_params, 0, NULL);
1467     if (thread_handle == NULL)
1468     {
1469         trace("error creating thread: %d\n", GetLastError());
1470         goto done;
1471     }
1472
1473     WaitForSingleObject(server_ready, INFINITE);
1474     Sleep(200);
1475     ret = closesocket(server_socket);
1476     if (ret != 0)
1477     {
1478         trace("closesocket failed: %d\n", WSAGetLastError());
1479         goto done;
1480     }
1481
1482     WaitForSingleObject(thread_handle, 1000);
1483     ok(thread_params.ReadKilled, "closesocket did not wakeup accept\n");
1484
1485 done:
1486     if (thread_handle != NULL)
1487         CloseHandle(thread_handle);
1488     if (server_ready != INVALID_HANDLE_VALUE)
1489         CloseHandle(server_ready);
1490     if (server_socket != INVALID_SOCKET)
1491         closesocket(server_socket);
1492 }
1493
1494 static void test_extendedSocketOptions(void)
1495 {
1496     WSADATA wsa;
1497     SOCKET sock;
1498     struct sockaddr_in sa;
1499     int sa_len = sizeof(struct sockaddr_in);
1500     int optval, optlen = sizeof(int), ret;
1501     BOOL bool_opt_val;
1502     LINGER linger_val;
1503
1504     if(WSAStartup(MAKEWORD(2,0), &wsa)){
1505         trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
1506         return;
1507     }
1508
1509     memset(&sa, 0, sa_len);
1510
1511     sa.sin_family = AF_INET;
1512     sa.sin_port = htons(0);
1513     sa.sin_addr.s_addr = htonl(INADDR_ANY);
1514
1515     if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) < 0){
1516         trace("Creating the socket failed: %d\n", WSAGetLastError());
1517         WSACleanup();
1518         return;
1519     }
1520
1521     if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
1522         trace("Failed to bind socket: %d\n", WSAGetLastError());
1523         closesocket(sock);
1524         WSACleanup();
1525         return;
1526     }
1527
1528     ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
1529
1530     ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
1531     ok(optval == 65507, "SO_MAX_MSG_SIZE reported %d, expected 65507\n", optval);
1532
1533     optlen = sizeof(LINGER);
1534     ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
1535     todo_wine{
1536     ok(ret == SOCKET_ERROR, "getsockopt should fail for UDP sockets but return value is 0x%08x\n", ret);
1537     }
1538
1539     closesocket(sock);
1540
1541     if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) < 0){
1542         trace("Creating the socket failed: %d\n", WSAGetLastError());
1543         WSACleanup();
1544         return;
1545     }
1546
1547     if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
1548         trace("Failed to bind socket: %d\n", WSAGetLastError());
1549         closesocket(sock);
1550         WSACleanup();
1551         return;
1552     }
1553
1554     ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
1555     ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
1556
1557     optlen = sizeof(BOOL);
1558     ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
1559     ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
1560     ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
1561             "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
1562             bool_opt_val, linger_val.l_onoff);
1563
1564     closesocket(sock);
1565     WSACleanup();
1566 }
1567
1568 static void test_getsockname(void)
1569 {
1570     WSADATA wsa;
1571     SOCKET sock;
1572     struct sockaddr_in sa_set, sa_get;
1573     int sa_set_len = sizeof(struct sockaddr_in);
1574     int sa_get_len = sa_set_len;
1575     static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
1576
1577     if(WSAStartup(MAKEWORD(2,0), &wsa)){
1578         trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
1579         return;
1580     }
1581
1582     memset(&sa_set, 0, sa_set_len);
1583
1584     sa_set.sin_family = AF_INET;
1585     sa_set.sin_port = htons(0);
1586     sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
1587
1588     if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) < 0){
1589         trace("Creating the socket failed: %d\n", WSAGetLastError());
1590         WSACleanup();
1591         return;
1592     }
1593
1594     if(bind(sock, (struct sockaddr *) &sa_set, sa_set_len) < 0){
1595         trace("Failed to bind socket: %d\n", WSAGetLastError());
1596         closesocket(sock);
1597         WSACleanup();
1598         return;
1599     }
1600
1601     if(getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len) != 0){
1602         trace("Failed to call getsockname: %d\n", WSAGetLastError());
1603         closesocket(sock);
1604         WSACleanup();
1605         return;
1606     }
1607
1608     ok(memcmp(sa_get.sin_zero, null_padding, 8) == 0,
1609             "getsockname did not zero the sockaddr_in structure\n");
1610
1611     closesocket(sock);
1612     WSACleanup();
1613 }
1614
1615 static void test_inet_addr(void)
1616 {
1617     u_long addr;
1618
1619     addr = inet_addr(NULL);
1620     ok(addr == INADDR_NONE, "inet_addr succeeded unexpectedly\n");
1621 }
1622
1623 static DWORD WINAPI drain_socket_thread(LPVOID arg)
1624 {
1625     char buffer[1024];
1626     SOCKET sock = *(SOCKET*)arg;
1627
1628     while (recv(sock, buffer, sizeof(buffer), 0) > 0)
1629         ;
1630     return 0;
1631 }
1632
1633 static void test_send(void)
1634 {
1635     SOCKET src = INVALID_SOCKET;
1636     SOCKET server = INVALID_SOCKET;
1637     SOCKET dst = INVALID_SOCKET;
1638     HANDLE hThread = NULL;
1639     struct sockaddr_in addr;
1640     int len;
1641     const int buflen = 1024*1024;
1642     char *buffer = NULL;
1643     int ret;
1644
1645     src = socket(AF_INET, SOCK_STREAM, 0);
1646     if (src == INVALID_SOCKET)
1647     {
1648         ok(0, "socket failed, error %d\n", WSAGetLastError());
1649         goto end;
1650     }
1651
1652     server = socket(AF_INET, SOCK_STREAM, 0);
1653     if (server == INVALID_SOCKET)
1654     {
1655         ok(0, "socket failed, error %d\n", WSAGetLastError());
1656         goto end;
1657     }
1658
1659     memset(&addr, 0, sizeof(addr));
1660     addr.sin_family = AF_INET;
1661     addr.sin_addr.s_addr = inet_addr("127.0.0.1");
1662     ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
1663     if (ret != 0)
1664     {
1665         ok(0, "bind failed, error %d\n", WSAGetLastError());
1666         goto end;
1667     }
1668
1669     len = sizeof(addr);
1670     ret = getsockname(server, (struct sockaddr*)&addr, &len);
1671     if (ret != 0)
1672     {
1673         ok(0, "getsockname failed, error %d\n", WSAGetLastError());
1674         goto end;
1675     }
1676
1677     ret = listen(server, 1);
1678     if (ret != 0)
1679     {
1680         ok(0, "listen failed, error %d\n", WSAGetLastError());
1681         goto end;
1682     }
1683
1684     ret = connect(src, (struct sockaddr*)&addr, sizeof(addr));
1685     if (ret != 0)
1686     {
1687         ok(0, "connect failed, error %d\n", WSAGetLastError());
1688         goto end;
1689     }
1690
1691     len = sizeof(addr);
1692     dst = accept(server, (struct sockaddr*)&addr, &len);
1693     if (dst == INVALID_SOCKET)
1694     {
1695         ok(0, "accept failed, error %d\n", WSAGetLastError());
1696         goto end;
1697     }
1698
1699     hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, NULL);
1700     if (hThread == NULL)
1701     {
1702         ok(0, "CreateThread failed, error %d\n", GetLastError());
1703         goto end;
1704     }
1705
1706     buffer = HeapAlloc(GetProcessHeap(), 0, buflen);
1707     if (buffer == NULL)
1708     {
1709         ok(0, "HeapAlloc failed, error %d\n", GetLastError());
1710         goto end;
1711     }
1712
1713     ret = send(src, buffer, buflen, 0);
1714     if (ret >= 0)
1715         ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
1716     else
1717         ok(0, "send failed, error %d\n", WSAGetLastError());
1718
1719 end:
1720     if (src != INVALID_SOCKET)
1721         closesocket(src);
1722     if (server != INVALID_SOCKET)
1723         closesocket(server);
1724     if (dst != INVALID_SOCKET)
1725         closesocket(dst);
1726     if (hThread != NULL)
1727         CloseHandle(hThread);
1728     if (buffer != NULL)
1729         HeapFree(GetProcessHeap(), 0, buffer);
1730 }
1731
1732 /**************** Main program  ***************/
1733
1734 START_TEST( sock )
1735 {
1736     int i;
1737     Init();
1738
1739     test_set_getsockopt();
1740     test_so_reuseaddr();
1741     test_extendedSocketOptions();
1742
1743     for (i = 0; i < NUM_TESTS; i++)
1744     {
1745         trace ( " **** STARTING TEST %d ****\n", i );
1746         do_test (  &tests[i] );
1747         trace ( " **** TEST %d COMPLETE ****\n", i );
1748     }
1749
1750     test_UDP();
1751
1752     test_getservbyname();
1753
1754     test_WSAAddressToStringA();
1755     test_WSAAddressToStringW();
1756
1757     test_WSAStringToAddressA();
1758     test_WSAStringToAddressW();
1759
1760     test_select();
1761     test_accept();
1762     test_getsockname();
1763     test_inet_addr();
1764
1765     test_send();
1766
1767     Exit();
1768 }