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  * Copyright 2008 Jeff Zaroyko
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdarg.h>
  25
  26 #include "ntstatus.h"
  27 #define WIN32_NO_STATUS
  28 #include <windef.h>
  29 #include <winbase.h>
  30 #include <winsock2.h>
  31 #include <ws2tcpip.h>
  32 #include <mswsock.h>
  33 #include "wine/test.h"
  34 #include <winnt.h>
  35 #include <winerror.h>
  36 #include <winuser.h>
  37
  38 #define MAX_CLIENTS 4      /* Max number of clients */
  39 #define NUM_TESTS   4      /* Number of tests performed */
  40 #define FIRST_CHAR 'A'     /* First character in transferred pattern */
  41 #define BIND_SLEEP 10      /* seconds to wait between attempts to bind() */
  42 #define BIND_TRIES 6       /* Number of bind() attempts */
  43 #define TEST_TIMEOUT 30    /* seconds to wait before killing child threads
  44                               after server initialization, if something hangs */
  45
  46 #define NUM_UDP_PEERS 3    /* Number of UDP sockets to create and test > 1 */
  47
  48 #define NUM_THREADS 3      /* Number of threads to run getservbyname */
  49 #define NUM_QUERIES 250    /* Number of getservbyname queries per thread */
  50
  51 #define SERVERIP "127.0.0.1"   /* IP to bind to */
  52 #define SERVERPORT 9374        /* Port number to bind to */
  53
  54 #define wsa_ok(op, cond, msg) \
  55    do { \
  56         int tmp, err = 0; \
  57         tmp = op; \
  58         if ( !(cond tmp) ) err = WSAGetLastError(); \
  59         ok ( cond tmp, msg, GetCurrentThreadId(), err); \
  60    } while (0);
  61
  62 /* Function pointers */
  63 static void   (WINAPI  *pFreeAddrInfoW)(PADDRINFOW) = 0;
  64 static int    (WINAPI  *pGetAddrInfoW)(LPCWSTR,LPCWSTR,const ADDRINFOW *,PADDRINFOW *) = 0;
  65 static PCSTR  (WINAPI  *pInetNtop)(INT,LPVOID,LPSTR,ULONG) = 0;
  66
  67 /**************** Structs and typedefs ***************/
  68
  69 typedef struct thread_info
  70 {
  71     HANDLE thread;
  72     DWORD id;
  73 } thread_info;
  74
  75 /* Information in the server about open client connections */
  76 typedef struct sock_info
  77 {
  78     SOCKET                 s;
  79     struct sockaddr_in     addr;
  80     struct sockaddr_in     peer;
  81     char                  *buf;
  82     int                    n_recvd;
  83     int                    n_sent;
  84 } sock_info;
  85
  86 /* Test parameters for both server & client */
  87 typedef struct test_params
  88 {
  89     int          sock_type;
  90     int          sock_prot;
  91     const char  *inet_addr;
  92     short        inet_port;
  93     int          chunk_size;
  94     int          n_chunks;
  95     int          n_clients;
  96 } test_params;
  97
  98 /* server-specific test parameters */
  99 typedef struct server_params
 100 {
 101     test_params   *general;
 102     DWORD          sock_flags;
 103     int            buflen;
 104 } server_params;
 105
 106 /* client-specific test parameters */
 107 typedef struct client_params
 108 {
 109     test_params   *general;
 110     DWORD          sock_flags;
 111     int            buflen;
 112 } client_params;
 113
 114 /* This type combines all information for setting up a test scenario */
 115 typedef struct test_setup
 116 {
 117     test_params              general;
 118     LPVOID                   srv;
 119     server_params            srv_params;
 120     LPVOID                   clt;
 121     client_params            clt_params;
 122 } test_setup;
 123
 124 /* Thread local storage for server */
 125 typedef struct server_memory
 126 {
 127     SOCKET                  s;
 128     struct sockaddr_in      addr;
 129     sock_info               sock[MAX_CLIENTS];
 130 } server_memory;
 131
 132 /* Thread local storage for client */
 133 typedef struct client_memory
 134 {
 135     SOCKET s;
 136     struct sockaddr_in      addr;
 137     char                   *send_buf;
 138     char                   *recv_buf;
 139 } client_memory;
 140
 141 /* SelectReadThread thread parameters */
 142 typedef struct select_thread_params
 143 {
 144     SOCKET s;
 145     BOOL ReadKilled;
 146 } select_thread_params;
 147
 148 /**************** Static variables ***************/
 149
 150 static DWORD      tls;              /* Thread local storage index */
 151 static HANDLE     thread[1+MAX_CLIENTS];
 152 static DWORD      thread_id[1+MAX_CLIENTS];
 153 static HANDLE     server_ready;
 154 static HANDLE     client_ready[MAX_CLIENTS];
 155 static int        client_id;
 156
 157 /**************** General utility functions ***************/
 158
 159 static int tcp_socketpair(SOCKET *src, SOCKET *dst)
 160 {
 161     SOCKET server = INVALID_SOCKET;
 162     struct sockaddr_in addr;
 163     int len;
 164     int ret;
 165
 166     *src = INVALID_SOCKET;
 167     *dst = INVALID_SOCKET;
 168
 169     *src = socket(AF_INET, SOCK_STREAM, 0);
 170     if (*src == INVALID_SOCKET)
 171         goto end;
 172
 173     server = socket(AF_INET, SOCK_STREAM, 0);
 174     if (server == INVALID_SOCKET)
 175         goto end;
 176
 177     memset(&addr, 0, sizeof(addr));
 178     addr.sin_family = AF_INET;
 179     addr.sin_addr.s_addr = inet_addr("127.0.0.1");
 180     ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
 181     if (ret != 0)
 182         goto end;
 183
 184     len = sizeof(addr);
 185     ret = getsockname(server, (struct sockaddr*)&addr, &len);
 186     if (ret != 0)
 187         goto end;
 188
 189     ret = listen(server, 1);
 190     if (ret != 0)
 191         goto end;
 192
 193     ret = connect(*src, (struct sockaddr*)&addr, sizeof(addr));
 194     if (ret != 0)
 195         goto end;
 196
 197     len = sizeof(addr);
 198     *dst = accept(server, (struct sockaddr*)&addr, &len);
 199
 200 end:
 201     if (server != INVALID_SOCKET)
 202         closesocket(server);
 203     if (*src != INVALID_SOCKET && *dst != INVALID_SOCKET)
 204         return 0;
 205     closesocket(*src);
 206     closesocket(*dst);
 207     return -1;
 208 }
 209
 210 static void set_so_opentype ( BOOL overlapped )
 211 {
 212     int optval = !overlapped, newval, len = sizeof (int);
 213
 214     ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
 215                       (LPVOID) &optval, sizeof (optval) ) == 0,
 216          "setting SO_OPENTYPE failed\n" );
 217     ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
 218                       (LPVOID) &newval, &len ) == 0,
 219          "getting SO_OPENTYPE failed\n" );
 220     ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
 221 }
 222
 223 static int set_blocking ( SOCKET s, BOOL blocking )
 224 {
 225     u_long val = !blocking;
 226     return ioctlsocket ( s, FIONBIO, &val );
 227 }
 228
 229 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
 230 {
 231     char c, *p;
 232     for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
 233         memset ( p, c, chunk_size );
 234 }
 235
 236 static int test_buffer ( char *buf, int chunk_size, int n_chunks )
 237 {
 238     char c, *p;
 239     int i;
 240     for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
 241     {
 242         for ( i = 0; i < chunk_size; i++ )
 243             if ( p[i] != c ) return i;
 244     }
 245     return -1;
 246 }
 247
 248 /*
 249  * This routine is called when a client / server does not expect any more data,
 250  * but needs to acknowledge the closing of the connection (by reading 0 bytes).
 251  */
 252 static void read_zero_bytes ( SOCKET s )
 253 {
 254     char buf[256];
 255     int tmp, n = 0;
 256     while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
 257         n += tmp;
 258     ok ( n <= 0, "garbage data received: %d bytes\n", n );
 259 }
 260
 261 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int sendlen )
 262 {
 263     char* last = buf + buflen, *p;
 264     int n = 1;
 265     for ( p = buf; n > 0 && p < last; p += n )
 266         n = send ( s, p, min ( sendlen, last - p ), 0 );
 267     wsa_ok ( n, 0 <=, "do_synchronous_send (%x): error %d\n" );
 268     return p - buf;
 269 }
 270
 271 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int recvlen )
 272 {
 273     char* last = buf + buflen, *p;
 274     int n = 1;
 275     for ( p = buf; n > 0 && p < last; p += n )
 276         n = recv ( s, p, min ( recvlen, last - p ), 0 );
 277     wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
 278     return p - buf;
 279 }
 280
 281 static int do_synchronous_recvfrom ( SOCKET s, char *buf, int buflen,int flags,struct sockaddr *from, int *fromlen, int recvlen )
 282 {
 283     char* last = buf + buflen, *p;
 284     int n = 1;
 285     for ( p = buf; n > 0 && p < last; p += n )
 286       n = recvfrom ( s, p, min ( recvlen, last - p ), 0, from, fromlen );
 287     wsa_ok ( n, 0 <=, "do_synchronous_recv (%x): error %d:\n" );
 288     return p - buf;
 289 }
 290
 291 /*
 292  *  Call this routine right after thread startup.
 293  *  SO_OPENTYPE must by 0, regardless what the server did.
 294  */
 295 static void check_so_opentype (void)
 296 {
 297     int tmp = 1, len;
 298     len = sizeof (tmp);
 299     getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
 300     ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
 301 }
 302
 303 /**************** Server utility functions ***************/
 304
 305 /*
 306  *  Even if we have closed our server socket cleanly,
 307  *  the OS may mark the address "in use" for some time -
 308  *  this happens with native Linux apps, too.
 309  */
 310 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
 311 {
 312     int err, wsaerr = 0, n_try = BIND_TRIES;
 313
 314     while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
 315             ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
 316             n_try-- >= 0)
 317     {
 318         trace ( "address in use, waiting ...\n" );
 319         Sleep ( 1000 * BIND_SLEEP );
 320     }
 321     ok ( err == 0, "failed to bind: %d\n", wsaerr );
 322 }
 323
 324 static void server_start ( server_params *par )
 325 {
 326     int i;
 327     test_params *gen = par->general;
 328     server_memory *mem = LocalAlloc ( LPTR, sizeof ( server_memory ) );
 329
 330     TlsSetValue ( tls, mem );
 331     mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
 332                           NULL, 0, par->sock_flags );
 333     ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
 334
 335     mem->addr.sin_family = AF_INET;
 336     mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
 337     mem->addr.sin_port = htons ( gen->inet_port );
 338
 339     for (i = 0; i < MAX_CLIENTS; i++)
 340     {
 341         mem->sock[i].s = INVALID_SOCKET;
 342         mem->sock[i].buf = LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
 343         mem->sock[i].n_recvd = 0;
 344         mem->sock[i].n_sent = 0;
 345     }
 346
 347     if ( gen->sock_type == SOCK_STREAM )
 348         do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
 349 }
 350
 351 static void server_stop (void)
 352 {
 353     int i;
 354     server_memory *mem = TlsGetValue ( tls );
 355
 356     for (i = 0; i < MAX_CLIENTS; i++ )
 357     {
 358         LocalFree ( mem->sock[i].buf );
 359         if ( mem->sock[i].s != INVALID_SOCKET )
 360             closesocket ( mem->sock[i].s );
 361     }
 362     ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
 363     LocalFree ( mem );
 364     ExitThread ( GetCurrentThreadId () );
 365 }
 366
 367 /**************** Client utilitiy functions ***************/
 368
 369 static void client_start ( client_params *par )
 370 {
 371     test_params *gen = par->general;
 372     client_memory *mem = LocalAlloc (LPTR, sizeof (client_memory));
 373
 374     TlsSetValue ( tls, mem );
 375
 376     WaitForSingleObject ( server_ready, INFINITE );
 377
 378     mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
 379                           NULL, 0, par->sock_flags );
 380
 381     mem->addr.sin_family = AF_INET;
 382     mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
 383     mem->addr.sin_port = htons ( gen->inet_port );
 384
 385     ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
 386
 387     mem->send_buf = LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
 388     mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
 389     fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
 390
 391     SetEvent ( client_ready[client_id] );
 392     /* Wait for the other clients to come up */
 393     WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
 394 }
 395
 396 static void client_stop (void)
 397 {
 398     client_memory *mem = TlsGetValue ( tls );
 399     wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%x): %d\n" );
 400     LocalFree ( mem->send_buf );
 401     LocalFree ( mem );
 402     ExitThread(0);
 403 }
 404
 405 /**************** Servers ***************/
 406
 407 /*
 408  * simple_server: A very basic server doing synchronous IO.
 409  */
 410 static VOID WINAPI simple_server ( server_params *par )
 411 {
 412     test_params *gen = par->general;
 413     server_memory *mem;
 414     int pos, n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
 415         id = GetCurrentThreadId();
 416
 417     trace ( "simple_server (%x) starting\n", id );
 418
 419     set_so_opentype ( FALSE ); /* non-overlapped */
 420     server_start ( par );
 421     mem = TlsGetValue ( tls );
 422
 423     wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%x): failed to set blocking mode: %d\n");
 424     wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%x): listen failed: %d\n");
 425
 426     trace ( "simple_server (%x) ready\n", id );
 427     SetEvent ( server_ready ); /* notify clients */
 428
 429     for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
 430     {
 431         trace ( "simple_server (%x): waiting for client\n", id );
 432
 433         /* accept a single connection */
 434         tmp = sizeof ( mem->sock[0].peer );
 435         mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
 436         wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%x): accept failed: %d\n" );
 437
 438         ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
 439              "simple_server (%x): strange peer address\n", id );
 440
 441         /* Receive data & check it */
 442         n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
 443         ok ( n_recvd == n_expected,
 444              "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
 445         pos = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
 446         ok ( pos == -1, "simple_server (%x): test pattern error: %d\n", id, pos);
 447
 448         /* Echo data back */
 449         n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
 450         ok ( n_sent == n_expected,
 451              "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
 452
 453         /* cleanup */
 454         read_zero_bytes ( mem->sock[0].s );
 455         wsa_ok ( closesocket ( mem->sock[0].s ),  0 ==, "simple_server (%x): closesocket error: %d\n" );
 456         mem->sock[0].s = INVALID_SOCKET;
 457     }
 458
 459     trace ( "simple_server (%x) exiting\n", id );
 460     server_stop ();
 461 }
 462
 463 /*
 464  * select_server: A non-blocking server.
 465  */
 466 static VOID WINAPI select_server ( server_params *par )
 467 {
 468     test_params *gen = par->general;
 469     server_memory *mem;
 470     int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
 471         id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
 472         n_set, delta, n_ready;
 473     struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
 474     fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
 475
 476     trace ( "select_server (%x) starting\n", id );
 477
 478     set_so_opentype ( FALSE ); /* non-overlapped */
 479     server_start ( par );
 480     mem = TlsGetValue ( tls );
 481
 482     wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%x): failed to set blocking mode: %d\n");
 483     wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%x): listen failed: %d\n");
 484
 485     trace ( "select_server (%x) ready\n", id );
 486     SetEvent ( server_ready ); /* notify clients */
 487
 488     FD_ZERO ( &fds_openrecv );
 489     FD_ZERO ( &fds_recv );
 490     FD_ZERO ( &fds_send );
 491     FD_ZERO ( &fds_opensend );
 492
 493     FD_SET ( mem->s, &fds_openrecv );
 494
 495     while(1)
 496     {
 497         fds_recv = fds_openrecv;
 498         fds_send = fds_opensend;
 499
 500         n_set = 0;
 501
 502         wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
 503             "select_server (%x): select() failed: %d\n" );
 504
 505         /* check for incoming requests */
 506         if ( FD_ISSET ( mem->s, &fds_recv ) ) {
 507             n_set += 1;
 508
 509             trace ( "select_server (%x): accepting client connection\n", id );
 510
 511             /* accept a single connection */
 512             tmp = sizeof ( mem->sock[n_connections].peer );
 513             mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
 514             wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%x): accept() failed: %d\n" );
 515
 516             ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
 517                 "select_server (%x): strange peer address\n", id );
 518
 519             /* add to list of open connections */
 520             FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
 521             FD_SET ( mem->sock[n_connections].s, &fds_opensend );
 522
 523             n_connections++;
 524         }
 525
 526         /* handle open requests */
 527
 528         for ( i = 0; i < n_connections; i++ )
 529         {
 530             if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
 531                 n_set += 1;
 532
 533                 if ( mem->sock[i].n_recvd < n_expected ) {
 534                     /* Receive data & check it */
 535                     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 );
 536                     ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
 537                     mem->sock[i].n_recvd += n_recvd;
 538
 539                     if ( mem->sock[i].n_recvd == n_expected ) {
 540                         int pos = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
 541                         ok ( pos == -1, "select_server (%x): test pattern error: %d\n", id, pos );
 542                         FD_CLR ( mem->sock[i].s, &fds_openrecv );
 543                     }
 544
 545                     ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
 546                 }
 547             }
 548
 549             /* only echo back what we've received */
 550             delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
 551
 552             if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
 553                 n_set += 1;
 554
 555                 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
 556                     /* Echo data back */
 557                     n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
 558                     ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
 559                     mem->sock[i].n_sent += n_sent;
 560
 561                     if ( mem->sock[i].n_sent == n_expected ) {
 562                         FD_CLR ( mem->sock[i].s, &fds_opensend );
 563                     }
 564
 565                     ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
 566                 }
 567             }
 568         }
 569
 570         /* check that select returned the correct number of ready sockets */
 571         ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
 572
 573         /* check if all clients are done */
 574         if ( ( fds_opensend.fd_count == 0 )
 575             && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
 576             && ( n_connections  == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
 577             break;
 578         }
 579     }
 580
 581     for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
 582     {
 583         /* cleanup */
 584         read_zero_bytes ( mem->sock[i].s );
 585         wsa_ok ( closesocket ( mem->sock[i].s ),  0 ==, "select_server (%x): closesocket error: %d\n" );
 586         mem->sock[i].s = INVALID_SOCKET;
 587     }
 588
 589     trace ( "select_server (%x) exiting\n", id );
 590     server_stop ();
 591 }
 592
 593 /**************** Clients ***************/
 594
 595 /*
 596  * simple_client: A very basic client doing synchronous IO.
 597  */
 598 static VOID WINAPI simple_client ( client_params *par )
 599 {
 600     test_params *gen = par->general;
 601     client_memory *mem;
 602     int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
 603
 604     id = GetCurrentThreadId();
 605     trace ( "simple_client (%x): starting\n", id );
 606     /* wait here because we want to call set_so_opentype before creating a socket */
 607     WaitForSingleObject ( server_ready, INFINITE );
 608     trace ( "simple_client (%x): server ready\n", id );
 609
 610     check_so_opentype ();
 611     set_so_opentype ( FALSE ); /* non-overlapped */
 612     client_start ( par );
 613     mem = TlsGetValue ( tls );
 614
 615     /* Connect */
 616     wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
 617              0 ==, "simple_client (%x): connect error: %d\n" );
 618     ok ( set_blocking ( mem->s, TRUE ) == 0,
 619          "simple_client (%x): failed to set blocking mode\n", id );
 620     trace ( "simple_client (%x) connected\n", id );
 621
 622     /* send data to server */
 623     n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, par->buflen );
 624     ok ( n_sent == n_expected,
 625          "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
 626
 627     /* shutdown send direction */
 628     wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
 629
 630     /* Receive data echoed back & check it */
 631     n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, par->buflen );
 632     ok ( n_recvd == n_expected,
 633          "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
 634
 635     /* check data */
 636     pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
 637     ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
 638
 639     /* cleanup */
 640     read_zero_bytes ( mem->s );
 641     trace ( "simple_client (%x) exiting\n", id );
 642     client_stop ();
 643 }
 644
 645 /*
 646  * simple_mixed_client: mixing send and recvfrom
 647  */
 648 static VOID WINAPI simple_mixed_client ( client_params *par )
 649 {
 650     test_params *gen = par->general;
 651     client_memory *mem;
 652     int pos, n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
 653     int fromLen = sizeof(mem->addr);
 654     struct sockaddr test;
 655
 656     id = GetCurrentThreadId();
 657     trace ( "simple_client (%x): starting\n", id );
 658     /* wait here because we want to call set_so_opentype before creating a socket */
 659     WaitForSingleObject ( server_ready, INFINITE );
 660     trace ( "simple_client (%x): server ready\n", id );
 661
 662     check_so_opentype ();
 663     set_so_opentype ( FALSE ); /* non-overlapped */
 664     client_start ( par );
 665     mem = TlsGetValue ( tls );
 666
 667     /* Connect */
 668     wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
 669              0 ==, "simple_client (%x): connect error: %d\n" );
 670     ok ( set_blocking ( mem->s, TRUE ) == 0,
 671          "simple_client (%x): failed to set blocking mode\n", id );
 672     trace ( "simple_client (%x) connected\n", id );
 673
 674     /* send data to server */
 675     n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, par->buflen );
 676     ok ( n_sent == n_expected,
 677          "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
 678
 679     /* shutdown send direction */
 680     wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%x): shutdown failed: %d\n" );
 681
 682     /* this shouldn't change, since lpFrom, is not updated on
 683        connection oriented sockets - exposed by bug 11640
 684     */
 685     ((struct sockaddr_in*)&test)->sin_addr.s_addr = inet_addr("0.0.0.0");
 686
 687     /* Receive data echoed back & check it */
 688     n_recvd = do_synchronous_recvfrom ( mem->s,
 689                                         mem->recv_buf,
 690                                         n_expected,
 691                                         0,
 692                                         (struct sockaddr *)&test,
 693                                         &fromLen,
 694                                         par->buflen );
 695     ok ( n_recvd == n_expected,
 696          "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
 697
 698     /* check that lpFrom was not updated */
 699     ok(0 ==
 700        strcmp(
 701               inet_ntoa(((struct sockaddr_in*)&test)->sin_addr),
 702               "0.0.0.0"), "lpFrom shouldn't be updated on connection oriented sockets\n");
 703
 704     /* check data */
 705     pos = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
 706     ok ( pos == -1, "simple_client (%x): test pattern error: %d\n", id, pos);
 707
 708     /* cleanup */
 709     read_zero_bytes ( mem->s );
 710     trace ( "simple_client (%x) exiting\n", id );
 711     client_stop ();
 712 }
 713
 714 /*
 715  * event_client: An event-driven client
 716  */
 717 static void WINAPI event_client ( client_params *par )
 718 {
 719     test_params *gen = par->general;
 720     client_memory *mem;
 721     int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
 722         tmp, err, n;
 723     HANDLE event;
 724     WSANETWORKEVENTS wsa_events;
 725     char *send_last, *recv_last, *send_p, *recv_p;
 726     LONG mask = FD_READ | FD_WRITE | FD_CLOSE;
 727
 728     trace ( "event_client (%x): starting\n", id );
 729     client_start ( par );
 730     trace ( "event_client (%x): server ready\n", id );
 731
 732     mem = TlsGetValue ( tls );
 733
 734     /* Prepare event notification for connect, makes socket nonblocking */
 735     event = WSACreateEvent ();
 736     WSAEventSelect ( mem->s, event, FD_CONNECT );
 737     tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
 738     if ( tmp != 0 ) {
 739         err = WSAGetLastError ();
 740         ok ( err == WSAEWOULDBLOCK, "event_client (%x): connect error: %d\n", id, err );
 741         tmp = WaitForSingleObject ( event, INFINITE );
 742         ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
 743         err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
 744         wsa_ok ( err, 0 ==, "event_client (%x): WSAEnumNetworkEvents error: %d\n" );
 745         err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
 746         ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
 747         if ( err ) goto out;
 748     }
 749
 750     trace ( "event_client (%x) connected\n", id );
 751
 752     WSAEventSelect ( mem->s, event, mask );
 753
 754     recv_p = mem->recv_buf;
 755     recv_last = mem->recv_buf + n_expected;
 756     send_p = mem->send_buf;
 757     send_last = mem->send_buf + n_expected;
 758
 759     while ( TRUE )
 760     {
 761         err = WaitForSingleObject ( event, INFINITE );
 762         ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
 763
 764         err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
 765         wsa_ok ( err, 0 ==, "event_client (%x): WSAEnumNetworkEvents error: %d\n" );
 766
 767         if ( wsa_events.lNetworkEvents & FD_WRITE )
 768         {
 769             err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
 770             ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
 771
 772             if ( err== 0 )
 773                 do
 774                 {
 775                     n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
 776                     if ( n < 0 )
 777                     {
 778                         err = WSAGetLastError ();
 779                         ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
 780                     }
 781                     else
 782                         send_p += n;
 783                 }
 784                 while ( n >= 0 && send_p < send_last );
 785
 786             if ( send_p == send_last )
 787             {
 788                 trace ( "event_client (%x): all data sent - shutdown\n", id );
 789                 shutdown ( mem->s, SD_SEND );
 790                 mask &= ~FD_WRITE;
 791                 WSAEventSelect ( mem->s, event, mask );
 792             }
 793         }
 794         if ( wsa_events.lNetworkEvents & FD_READ )
 795         {
 796             err = wsa_events.iErrorCode[ FD_READ_BIT ];
 797             ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
 798             if ( err != 0 ) break;
 799
 800             /* First read must succeed */
 801             n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
 802             wsa_ok ( n, 0 <=, "event_client (%x): recv error: %d\n" );
 803
 804             while ( n >= 0 ) {
 805                 recv_p += n;
 806                 if ( recv_p == recv_last )
 807                 {
 808                     mask &= ~FD_READ;
 809                     trace ( "event_client (%x): all data received\n", id );
 810                     WSAEventSelect ( mem->s, event, mask );
 811                     break;
 812                 }
 813                 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
 814                 if ( n < 0 && ( err = WSAGetLastError()) != WSAEWOULDBLOCK )
 815                     ok ( 0, "event_client (%x): read error: %d\n", id, err );
 816
 817             }
 818         }
 819         if ( wsa_events.lNetworkEvents & FD_CLOSE )
 820         {
 821             trace ( "event_client (%x): close event\n", id );
 822             err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
 823             ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
 824             break;
 825         }
 826     }
 827
 828     n = send_p - mem->send_buf;
 829     ok ( send_p == send_last,
 830          "simple_client (%x): sent less data than expected: %d of %d\n", id, n, n_expected );
 831     n = recv_p - mem->recv_buf;
 832     ok ( recv_p == recv_last,
 833          "simple_client (%x): received less data than expected: %d of %d\n", id, n, n_expected );
 834     n = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
 835     ok ( n == -1, "event_client (%x): test pattern error: %d\n", id, n);
 836
 837 out:
 838     WSACloseEvent ( event );
 839     trace ( "event_client (%x) exiting\n", id );
 840     client_stop ();
 841 }
 842
 843 /* Tests for WSAStartup */
 844
 845 /* This should fail. WSAStartup should be called before any network function is used. */
 846 static void test_WithoutWSAStartup(void)
 847 {
 848     LPVOID ptr;
 849
 850     WSASetLastError(0xdeadbeef);
 851     ptr = gethostbyname("localhost");
 852
 853     todo_wine ok(ptr == NULL, "gethostbyname() succeeded unexpectedly: %d\n", WSAGetLastError());
 854     todo_wine ok(WSAGetLastError() == WSANOTINITIALISED, "gethostbyname() failed with unexpected error: %d\n",
 855                 WSAGetLastError());
 856 }
 857
 858 static void test_WithWSAStartup(void)
 859 {
 860     WSADATA data;
 861     WORD version = MAKEWORD( 2, 2 );
 862     INT res;
 863     LPVOID ptr;
 864
 865     res = WSAStartup( version, &data );
 866     ok(res == 0, "WSAStartup() failed unexpectedly: %d\n", res);
 867
 868     ptr = gethostbyname("localhost");
 869     ok(ptr != NULL, "gethostbyname() failed unexpectedly: %d\n", WSAGetLastError());
 870
 871     WSACleanup();
 872 }
 873
 874 /**************** Main program utility functions ***************/
 875
 876 static void Init (void)
 877 {
 878     WORD ver = MAKEWORD (2, 2);
 879     WSADATA data;
 880     HMODULE hws2_32 = GetModuleHandle("ws2_32.dll");
 881
 882     pFreeAddrInfoW = (void *)GetProcAddress(hws2_32, "FreeAddrInfoW");
 883     pGetAddrInfoW = (void *)GetProcAddress(hws2_32, "GetAddrInfoW");
 884     pInetNtop = (void *)GetProcAddress(hws2_32, "inet_ntop");
 885
 886     ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
 887     tls = TlsAlloc();
 888 }
 889
 890 static void Exit (void)
 891 {
 892     INT ret, err;
 893     TlsFree ( tls );
 894     ret = WSACleanup();
 895     err = WSAGetLastError();
 896     ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
 897     ret = WSACleanup();
 898     err = WSAGetLastError();
 899     ok ( (ret == SOCKET_ERROR && err ==  WSANOTINITIALISED) ||
 900          broken(ret == 0),  /* WinME */
 901             "WSACleanup returned %d GetLastError is %d\n", ret, err);
 902 }
 903
 904 static void StartServer (LPTHREAD_START_ROUTINE routine,
 905                          test_params *general, server_params *par)
 906 {
 907     par->general = general;
 908     thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
 909     ok ( thread[0] != NULL, "Failed to create server thread\n" );
 910 }
 911
 912 static void StartClients (LPTHREAD_START_ROUTINE routine,
 913                           test_params *general, client_params *par)
 914 {
 915     int i;
 916     par->general = general;
 917     for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
 918     {
 919         client_id = i - 1;
 920         thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
 921         ok ( thread[i] != NULL, "Failed to create client thread\n" );
 922         /* Make sure the client is up and running */
 923         WaitForSingleObject ( client_ready[client_id], INFINITE );
 924     };
 925 }
 926
 927 static void do_test( test_setup *test )
 928 {
 929     DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
 930     DWORD wait;
 931
 932     server_ready = CreateEventA ( NULL, TRUE, FALSE, NULL );
 933     for (i = 0; i <= n; i++)
 934         client_ready[i] = CreateEventA ( NULL, TRUE, FALSE, NULL );
 935
 936     StartServer ( test->srv, &test->general, &test->srv_params );
 937     StartClients ( test->clt, &test->general, &test->clt_params );
 938     WaitForSingleObject ( server_ready, INFINITE );
 939
 940     wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
 941     ok ( wait <= WAIT_OBJECT_0 + n ,
 942          "some threads have not completed: %x\n", wait );
 943
 944     if ( ! ( wait <= WAIT_OBJECT_0 + n ) )
 945     {
 946         for (i = 0; i <= n; i++)
 947         {
 948             trace ("terminating thread %08x\n", thread_id[i]);
 949             if ( WaitForSingleObject ( thread[i], 0 ) != WAIT_OBJECT_0 )
 950                 TerminateThread ( thread [i], 0 );
 951         }
 952     }
 953     CloseHandle ( server_ready );
 954     for (i = 0; i <= n; i++)
 955         CloseHandle ( client_ready[i] );
 956 }
 957
 958 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
 959 /* optname = SO_LINGER */
 960 LINGER linger_testvals[] = {
 961     {0,0},
 962     {0,73},
 963     {1,0},
 964     {5,189}
 965 };
 966
 967 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
 968 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
 969                         bug in the linux kernel (fixed in 2.6.8) */
 970 #define SOCKTIMEOUT2 997000 /* 997 seconds */
 971
 972 static void test_set_getsockopt(void)
 973 {
 974     SOCKET s;
 975     int i, err, lasterr;
 976     int timeout;
 977     LINGER lingval;
 978     int size;
 979
 980     s = socket(AF_INET, SOCK_STREAM, 0);
 981     ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
 982     if( s == INVALID_SOCKET) return;
 983     /* SO_RCVTIMEO */
 984     timeout = SOCKTIMEOUT1;
 985     size = sizeof(timeout);
 986     err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
 987     if( !err)
 988         err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
 989     ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
 990     ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
 991
 992     timeout = 0;
 993     size = sizeof(timeout);
 994     err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
 995     if( !err)
 996         err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
 997     ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
 998     ok( timeout == 0, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
 999
1000     /* SO_SNDTIMEO */
1001     timeout = SOCKTIMEOUT2; /* 997 seconds. See remark above */
1002     size = sizeof(timeout);
1003     err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
1004     if( !err)
1005         err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
1006     ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
1007     ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
1008     /* SO_LINGER */
1009     for( i = 0; i < sizeof(linger_testvals)/sizeof(LINGER);i++) {
1010         size =  sizeof(lingval);
1011         lingval = linger_testvals[i];
1012         err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, size);
1013         if( !err)
1014             err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, &size);
1015         ok( !err, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
1016         ok( !lingval.l_onoff == !linger_testvals[i].l_onoff &&
1017                 (lingval.l_linger == linger_testvals[i].l_linger ||
1018                  (!lingval.l_linger && !linger_testvals[i].l_onoff))
1019                 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i,
1020                  lingval.l_onoff, lingval.l_linger,
1021                  linger_testvals[i].l_onoff, linger_testvals[i].l_linger);
1022     }
1023     /* Test for erroneously passing a value instead of a pointer as optval */
1024     size = sizeof(char);
1025     err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size);
1026     ok(err == SOCKET_ERROR, "setsockopt with optval being a value passed "
1027                             "instead of failing.\n");
1028     lasterr = WSAGetLastError();
1029     ok(lasterr == WSAEFAULT, "setsockopt with optval being a value "
1030                              "returned 0x%08x, not WSAEFAULT(0x%08x)\n",
1031                              lasterr, WSAEFAULT);
1032
1033     /* SO_RCVTIMEO with invalid values for level */
1034     size = sizeof(timeout);
1035     timeout = SOCKTIMEOUT1;
1036     SetLastError(0xdeadbeef);
1037     err = setsockopt(s, 0xffffffff, SO_RCVTIMEO, (char *) &timeout, size);
1038     ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1039         "got %d with %d (expected SOCKET_ERROR with WSAEINVAL\n",
1040         err, WSAGetLastError());
1041
1042     timeout = SOCKTIMEOUT1;
1043     SetLastError(0xdeadbeef);
1044     err = setsockopt(s, 0x00008000, SO_RCVTIMEO, (char *) &timeout, size);
1045     ok( (err == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
1046         "got %d with %d (expected SOCKET_ERROR with WSAEINVAL\n",
1047         err, WSAGetLastError());
1048
1049     closesocket(s);
1050 }
1051
1052 static void test_so_reuseaddr(void)
1053 {
1054     struct sockaddr_in saddr;
1055     SOCKET s1,s2;
1056     unsigned int rc,reuse;
1057     int size;
1058
1059     saddr.sin_family      = AF_INET;
1060     saddr.sin_port        = htons(9375);
1061     saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1062
1063     s1=socket(AF_INET, SOCK_STREAM, 0);
1064     ok(s1!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1065     rc = bind(s1, (struct sockaddr*)&saddr, sizeof(saddr));
1066     ok(rc!=SOCKET_ERROR, "bind(s1) failed error: %d\n", WSAGetLastError());
1067
1068     s2=socket(AF_INET, SOCK_STREAM, 0);
1069     ok(s2!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
1070
1071     reuse=0x1234;
1072     size=sizeof(reuse);
1073     rc=getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size );
1074     ok(rc==0 && reuse==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc,reuse);
1075
1076     rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1077     ok(rc==SOCKET_ERROR, "bind() succeeded\n");
1078
1079     reuse = 1;
1080     rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
1081     ok(rc==0, "setsockopt() failed error: %d\n", WSAGetLastError());
1082
1083     /* On Win2k3 and above, all SO_REUSEADDR seems to do is to allow binding to
1084      * a port immediately after closing another socket on that port, so
1085      * basically following the BSD socket semantics here. */
1086     closesocket(s1);
1087     rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
1088     ok(rc==0, "bind() failed error: %d\n", WSAGetLastError());
1089
1090     closesocket(s2);
1091 }
1092
1093 /************* Array containing the tests to run **********/
1094
1095 #define STD_STREAM_SOCKET \
1096             SOCK_STREAM, \
1097             0, \
1098             SERVERIP, \
1099             SERVERPORT
1100
1101 static test_setup tests [NUM_TESTS] =
1102 {
1103     /* Test 0: synchronous client and server */
1104     {
1105         {
1106             STD_STREAM_SOCKET,
1107             2048,
1108             16,
1109             2
1110         },
1111         simple_server,
1112         {
1113             NULL,
1114             0,
1115             64
1116         },
1117         simple_client,
1118         {
1119             NULL,
1120             0,
1121             128
1122         }
1123     },
1124     /* Test 1: event-driven client, synchronous server */
1125     {
1126         {
1127             STD_STREAM_SOCKET,
1128             2048,
1129             16,
1130             2
1131         },
1132         simple_server,
1133         {
1134             NULL,
1135             0,
1136             64
1137         },
1138         event_client,
1139         {
1140             NULL,
1141             WSA_FLAG_OVERLAPPED,
1142             128
1143         }
1144     },
1145     /* Test 2: synchronous client, non-blocking server via select() */
1146     {
1147         {
1148             STD_STREAM_SOCKET,
1149             2048,
1150             16,
1151             2
1152         },
1153         select_server,
1154         {
1155             NULL,
1156             0,
1157             64
1158         },
1159         simple_client,
1160         {
1161             NULL,
1162             0,
1163             128
1164         }
1165     },
1166         /* Test 3: synchronous mixed client and server */
1167     {
1168         {
1169             STD_STREAM_SOCKET,
1170             2048,
1171             16,
1172             2
1173         },
1174         simple_server,
1175         {
1176             NULL,
1177             0,
1178             64
1179         },
1180         simple_mixed_client,
1181         {
1182             NULL,
1183             0,
1184             128
1185         }
1186     }
1187 };
1188
1189 static void test_UDP(void)
1190 {
1191     /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
1192        possible that this test fails due to dropped packets. */
1193
1194     /* peer 0 receives data from all other peers */
1195     struct sock_info peer[NUM_UDP_PEERS];
1196     char buf[16];
1197     int ss, i, n_recv, n_sent;
1198
1199     memset (buf,0,sizeof(buf));
1200     for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
1201         ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
1202
1203         peer[i].addr.sin_family         = AF_INET;
1204         peer[i].addr.sin_addr.s_addr    = inet_addr ( SERVERIP );
1205
1206         if ( i == 0 ) {
1207             peer[i].addr.sin_port       = htons ( SERVERPORT );
1208         } else {
1209             peer[i].addr.sin_port       = htons ( 0 );
1210         }
1211
1212         do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
1213
1214         /* test getsockname() to get peer's port */
1215         ss = sizeof ( peer[i].addr );
1216         ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
1217         ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
1218     }
1219
1220     /* test getsockname() */
1221     ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
1222
1223     for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
1224         /* send client's ip */
1225         memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
1226         n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
1227         ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
1228     }
1229
1230     for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
1231         n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
1232         ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
1233         ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
1234     }
1235 }
1236
1237 static void WINAPI do_getservbyname( HANDLE *starttest )
1238 {
1239     struct {
1240         const char *name;
1241         const char *proto;
1242         int port;
1243     } serv[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
1244
1245     int i, j;
1246     struct servent *pserv[2];
1247
1248     ok ( WaitForSingleObject ( *starttest, TEST_TIMEOUT * 1000 ) != WAIT_TIMEOUT, "test_getservbyname: timeout waiting for start signal\n");
1249
1250     /* ensure that necessary buffer resizes are completed */
1251     for ( j = 0; j < 2; j++) {
1252         pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1253     }
1254
1255     for ( i = 0; i < NUM_QUERIES / 2; i++ ) {
1256         for ( j = 0; j < 2; j++ ) {
1257             pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1258             ok ( pserv[j] != NULL, "getservbyname could not retrieve information for %s: %d\n", serv[j].name, WSAGetLastError() );
1259             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) );
1260             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 );
1261             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 );
1262         }
1263
1264         ok ( pserv[0] == pserv[1], "getservbyname: winsock resized servent buffer when not necessary\n" );
1265     }
1266 }
1267
1268 static void test_getservbyname(void)
1269 {
1270     int i;
1271     HANDLE starttest, thread[NUM_THREADS];
1272     DWORD thread_id[NUM_THREADS];
1273
1274     starttest = CreateEvent ( NULL, 1, 0, "test_getservbyname_starttest" );
1275
1276     /* create threads */
1277     for ( i = 0; i < NUM_THREADS; i++ ) {
1278         thread[i] = CreateThread ( NULL, 0, (LPTHREAD_START_ROUTINE) &do_getservbyname, &starttest, 0, &thread_id[i] );
1279     }
1280
1281     /* signal threads to start */
1282     SetEvent ( starttest );
1283
1284     for ( i = 0; i < NUM_THREADS; i++) {
1285         WaitForSingleObject ( thread[i], TEST_TIMEOUT * 1000 );
1286     }
1287 }
1288
1289 static void test_WSASocket(void)
1290 {
1291     SOCKET sock = INVALID_SOCKET;
1292     WSAPROTOCOL_INFOA *pi;
1293     int providers[] = {6, 0};
1294     int ret, err;
1295     UINT pi_size;
1296
1297     /* Set pi_size explicitly to a value below 2*sizeof(WSAPROTOCOL_INFOA)
1298      * to avoid a crash on win98.
1299      */
1300     pi_size = 0;
1301     ret = WSAEnumProtocolsA(providers, NULL, &pi_size);
1302     ok(ret == SOCKET_ERROR, "WSAEnumProtocolsA({6,0}, NULL, 0) returned %d\n",
1303             ret);
1304     err = WSAGetLastError();
1305     ok(err == WSAENOBUFS, "WSAEnumProtocolsA error is %d, not WSAENOBUFS(%d)\n",
1306             err, WSAENOBUFS);
1307
1308     pi = HeapAlloc(GetProcessHeap(), 0, pi_size);
1309     ok(pi != NULL, "Failed to allocate memory\n");
1310     if (pi == NULL) {
1311         skip("Can't continue without memory.\n");
1312         return;
1313     }
1314
1315     ret = WSAEnumProtocolsA(providers, pi, &pi_size);
1316     ok(ret != SOCKET_ERROR, "WSAEnumProtocolsA failed, last error is %d\n",
1317             WSAGetLastError());
1318
1319     if (ret == 0) {
1320         skip("No protocols enumerated.\n");
1321         HeapFree(GetProcessHeap(), 0, pi);
1322         return;
1323     }
1324
1325     sock = WSASocketA(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
1326                       FROM_PROTOCOL_INFO, &pi[0], 0, 0);
1327     ok(sock != INVALID_SOCKET, "Failed to create socket: %d\n",
1328             WSAGetLastError());
1329
1330     closesocket(sock);
1331     HeapFree(GetProcessHeap(), 0, pi);
1332 }
1333
1334 static void test_WSAAddressToStringA(void)
1335 {
1336     SOCKET v6 = INVALID_SOCKET;
1337     INT ret;
1338     DWORD len;
1339     int GLE;
1340     SOCKADDR_IN sockaddr;
1341     CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1342
1343     CHAR expect1[] = "0.0.0.0";
1344     CHAR expect2[] = "255.255.255.255";
1345     CHAR expect3[] = "0.0.0.0:65535";
1346     CHAR expect4[] = "255.255.255.255:65535";
1347
1348     SOCKADDR_IN6 sockaddr6;
1349     CHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
1350
1351     CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1352     CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1353     CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
1354
1355     CHAR expect6_1[] = "::1";
1356     CHAR expect6_2[] = "20ab::1";
1357     CHAR expect6_3[] = "[20ab::2001]:33274";
1358     CHAR expect6_3_2[] = "[20ab::2001%4660]:33274";
1359     CHAR expect6_3_3[] = "20ab::2001%4660";
1360
1361     len = 0;
1362
1363     sockaddr.sin_family = AF_INET;
1364     sockaddr.sin_port = 0;
1365     sockaddr.sin_addr.s_addr = 0;
1366
1367     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1368     GLE = WSAGetLastError();
1369     ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
1370         "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1371         GLE, ret );
1372
1373     len = sizeof(address);
1374
1375     sockaddr.sin_family = AF_INET;
1376     sockaddr.sin_port = 0;
1377     sockaddr.sin_addr.s_addr = 0;
1378
1379     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1380     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1381
1382     ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
1383     ok( len == sizeof( expect1 ), "Got size %d\n", len);
1384
1385     len = sizeof(address);
1386
1387     sockaddr.sin_family = AF_INET;
1388     sockaddr.sin_port = 0;
1389     sockaddr.sin_addr.s_addr = 0xffffffff;
1390
1391     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1392     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1393
1394     ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
1395
1396     len = sizeof(address);
1397
1398     sockaddr.sin_family = AF_INET;
1399     sockaddr.sin_port = 0xffff;
1400     sockaddr.sin_addr.s_addr = 0;
1401
1402     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1403     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1404
1405     ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
1406
1407     len = sizeof(address);
1408
1409     sockaddr.sin_family = AF_INET;
1410     sockaddr.sin_port = 0xffff;
1411     sockaddr.sin_addr.s_addr = 0xffffffff;
1412
1413     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1414     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1415
1416     ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
1417     ok( len == sizeof( expect4 ), "Got size %d\n", len);
1418
1419     /*check to see it IPv6 is available */
1420     v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
1421     if (v6 == INVALID_SOCKET) {
1422         skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
1423             WSAGetLastError(), WSAEAFNOSUPPORT);
1424         goto end;
1425     }
1426     /* Test a short IPv6 address */
1427     len = sizeof(address6);
1428
1429     sockaddr6.sin6_family = AF_INET6;
1430     sockaddr6.sin6_port = 0x0000;
1431     sockaddr6.sin6_scope_id = 0;
1432     memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
1433
1434     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1435     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1436     ok( !strcmp( address6, expect6_1 ), "Expected: %s, got: %s\n", expect6_1, address6 );
1437     ok( len == sizeof(expect6_1), "Got size %d\n", len);
1438
1439     /* Test a longer IPv6 address */
1440     len = sizeof(address6);
1441
1442     sockaddr6.sin6_family = AF_INET6;
1443     sockaddr6.sin6_port = 0x0000;
1444     sockaddr6.sin6_scope_id = 0;
1445     memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
1446
1447     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1448     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1449     ok( !strcmp( address6, expect6_2 ), "Expected: %s, got: %s\n", expect6_2, address6 );
1450     ok( len == sizeof(expect6_2), "Got size %d\n", len);
1451
1452     /* Test IPv6 address and port number */
1453     len = sizeof(address6);
1454
1455     sockaddr6.sin6_family = AF_INET6;
1456     sockaddr6.sin6_port = 0xfa81;
1457     sockaddr6.sin6_scope_id = 0;
1458     memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
1459
1460     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1461     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1462     ok( !strcmp( address6, expect6_3 ), "Expected: %s, got: %s\n", expect6_3, address6 );
1463     ok( len == sizeof(expect6_3), "Got size %d\n", len);
1464
1465     /* Test IPv6 address, port number and scope_id */
1466     len = sizeof(address6);
1467
1468     sockaddr6.sin6_family = AF_INET6;
1469     sockaddr6.sin6_port = 0xfa81;
1470     sockaddr6.sin6_scope_id = 0x1234;
1471     memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
1472
1473     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1474     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1475     ok( !strcmp( address6, expect6_3_2 ), "Expected: %s, got: %s\n", expect6_3_2, address6 );
1476     ok( len == sizeof(expect6_3_2), "Got size %d\n", len);
1477
1478     /* Test IPv6 address and scope_id */
1479     len = sizeof(address6);
1480
1481     sockaddr6.sin6_family = AF_INET6;
1482     sockaddr6.sin6_port = 0x0000;
1483     sockaddr6.sin6_scope_id = 0x1234;
1484     memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
1485
1486     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1487     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1488     ok( !strcmp( address6, expect6_3_3 ), "Expected: %s, got: %s\n", expect6_3_3, address6 );
1489     ok( len == sizeof(expect6_3_3), "Got size %d\n", len);
1490
1491 end:
1492     if (v6 != INVALID_SOCKET)
1493         closesocket(v6);
1494 }
1495
1496 static void test_WSAAddressToStringW(void)
1497 {
1498     SOCKET v6 = INVALID_SOCKET;
1499     INT ret;
1500     DWORD len;
1501     int GLE;
1502     SOCKADDR_IN sockaddr;
1503     WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1504
1505     WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
1506     WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1507     WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
1508     WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1509                         '6', '5', '5', '3', '5', 0 };
1510
1511     SOCKADDR_IN6 sockaddr6;
1512     WCHAR address6[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
1513
1514     CHAR addr6_1[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1515     CHAR addr6_2[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01};
1516     CHAR addr6_3[] = {0x20,0xab,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x01};
1517
1518     WCHAR expect6_1[] = {':',':','1',0};
1519     WCHAR expect6_2[] = {'2','0','a','b',':',':','1',0};
1520     WCHAR expect6_3[] = {'[','2','0','a','b',':',':','2','0','0','1',']',':','3','3','2','7','4',0};
1521     WCHAR expect6_3_2[] = {'[','2','0','a','b',':',':','2','0','0','1','%','4','6','6','0',']',':','3','3','2','7','4',0};
1522     WCHAR expect6_3_3[] = {'2','0','a','b',':',':','2','0','0','1','%','6','5','5','3','4',0};
1523
1524     len = 0;
1525
1526     sockaddr.sin_family = AF_INET;
1527     sockaddr.sin_port = 0;
1528     sockaddr.sin_addr.s_addr = 0;
1529
1530     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1531     GLE = WSAGetLastError();
1532     ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
1533         "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1534         GLE, ret );
1535
1536     len = sizeof(address);
1537
1538     sockaddr.sin_family = AF_INET;
1539     sockaddr.sin_port = 0;
1540     sockaddr.sin_addr.s_addr = 0;
1541
1542     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1543     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1544
1545     ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
1546     ok( len == sizeof( expect1 )/sizeof( WCHAR ), "Got size %d\n", len);
1547
1548     len = sizeof(address);
1549
1550     sockaddr.sin_family = AF_INET;
1551     sockaddr.sin_port = 0;
1552     sockaddr.sin_addr.s_addr = 0xffffffff;
1553
1554     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1555     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1556
1557     ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
1558
1559     len = sizeof(address);
1560
1561     sockaddr.sin_family = AF_INET;
1562     sockaddr.sin_port = 0xffff;
1563     sockaddr.sin_addr.s_addr = 0;
1564
1565     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1566     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1567
1568     ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
1569
1570     len = sizeof(address);
1571
1572     sockaddr.sin_family = AF_INET;
1573     sockaddr.sin_port = 0xffff;
1574     sockaddr.sin_addr.s_addr = 0xffffffff;
1575
1576     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1577     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1578
1579     ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
1580     ok( len == sizeof( expect4 )/sizeof( WCHAR ), "Got %d\n", len);
1581
1582     /*check to see it IPv6 is available */
1583     v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
1584     if (v6 == INVALID_SOCKET) {
1585         skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
1586             WSAGetLastError(), WSAEAFNOSUPPORT);
1587         goto end;
1588     }
1589
1590     /* Test a short IPv6 address */
1591     len = sizeof(address6)/sizeof(WCHAR);
1592
1593     sockaddr6.sin6_family = AF_INET6;
1594     sockaddr6.sin6_port = 0x0000;
1595     sockaddr6.sin6_scope_id = 0;
1596     memcpy (sockaddr6.sin6_addr.s6_addr, addr6_1, sizeof(addr6_1));
1597
1598     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1599     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1600     ok( !lstrcmpW( address6, expect6_1 ), "Wrong string returned\n" );
1601     ok( len == sizeof(expect6_1)/sizeof(WCHAR), "Got %d\n", len);
1602
1603     /* Test a longer IPv6 address */
1604     len = sizeof(address6)/sizeof(WCHAR);
1605
1606     sockaddr6.sin6_family = AF_INET6;
1607     sockaddr6.sin6_port = 0x0000;
1608     sockaddr6.sin6_scope_id = 0;
1609     memcpy (sockaddr6.sin6_addr.s6_addr, addr6_2, sizeof(addr6_2));
1610
1611     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1612     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1613
1614     ok( !lstrcmpW( address6, expect6_2 ), "Wrong string returned\n" );
1615     ok( len == sizeof(expect6_2)/sizeof(WCHAR), "Got %d\n", len);
1616
1617     /* Test IPv6 address and port number */
1618     len = sizeof(address6)/sizeof(WCHAR);
1619
1620     sockaddr6.sin6_family = AF_INET6;
1621     sockaddr6.sin6_port = 0xfa81;
1622     sockaddr6.sin6_scope_id = 0;
1623     memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
1624
1625     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1626     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1627     ok( !lstrcmpW( address6, expect6_3 ), "Wrong string returned\n" );
1628     ok( len == sizeof(expect6_3)/sizeof(WCHAR), "Got %d\n", len);
1629
1630     /* Test IPv6 address, port number and scope_id */
1631     len = sizeof(address6)/sizeof(WCHAR);
1632
1633     sockaddr6.sin6_family = AF_INET6;
1634     sockaddr6.sin6_port = 0xfa81;
1635     sockaddr6.sin6_scope_id = 0x1234;
1636     memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
1637
1638     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1639     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1640     ok( !lstrcmpW( address6, expect6_3_2 ), "Wrong string returned\n" );
1641     ok( len == sizeof(expect6_3_2)/sizeof(WCHAR), "Got %d\n", len);
1642
1643     /* Test IPv6 address and scope_id */
1644     len = sizeof(address6)/sizeof(WCHAR);
1645
1646     sockaddr6.sin6_family = AF_INET6;
1647     sockaddr6.sin6_port = 0x0000;
1648     sockaddr6.sin6_scope_id = 0xfffe;
1649     memcpy (sockaddr6.sin6_addr.s6_addr, addr6_3, sizeof(addr6_3));
1650
1651     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr6, sizeof(sockaddr6), NULL, address6, &len );
1652     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %d\n", WSAGetLastError() );
1653     ok( !lstrcmpW( address6, expect6_3_3 ), "Wrong string returned\n" );
1654     ok( len == sizeof(expect6_3_3)/sizeof(WCHAR), "Got %d\n", len);
1655
1656 end:
1657     if (v6 != INVALID_SOCKET)
1658         closesocket(v6);
1659 }
1660
1661 static void test_WSAStringToAddressA(void)
1662 {
1663     INT ret, len;
1664     SOCKADDR_IN sockaddr;
1665     SOCKADDR_IN6 sockaddr6;
1666     int GLE;
1667
1668     CHAR address1[] = "0.0.0.0";
1669     CHAR address2[] = "127.127.127.127";
1670     CHAR address3[] = "255.255.255.255";
1671     CHAR address4[] = "127.127.127.127:65535";
1672     CHAR address5[] = "255.255.255.255:65535";
1673     CHAR address6[] = "::1";
1674     CHAR address7[] = "[::1]";
1675     CHAR address8[] = "[::1]:65535";
1676
1677     len = 0;
1678     sockaddr.sin_family = AF_INET;
1679
1680     ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1681     ok( ret == SOCKET_ERROR, "WSAStringToAddressA() succeeded unexpectedly: %d\n",
1682         WSAGetLastError() );
1683
1684     len = sizeof(sockaddr);
1685     sockaddr.sin_port = 0;
1686     sockaddr.sin_addr.s_addr = 0;
1687
1688     ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1689     ok( !ret && sockaddr.sin_addr.s_addr == 0,
1690         "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1691
1692     len = sizeof(sockaddr);
1693     sockaddr.sin_port = 0;
1694     sockaddr.sin_addr.s_addr = 0;
1695
1696     ret = WSAStringToAddressA( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1697     ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
1698         "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1699
1700     len = sizeof(sockaddr);
1701     sockaddr.sin_port = 0;
1702     sockaddr.sin_addr.s_addr = 0;
1703
1704     ret = WSAStringToAddressA( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1705     GLE = WSAGetLastError();
1706     ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
1707         (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1708         "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
1709
1710     len = sizeof(sockaddr);
1711     sockaddr.sin_port = 0;
1712     sockaddr.sin_addr.s_addr = 0;
1713
1714     ret = WSAStringToAddressA( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1715     ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
1716         "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1717
1718     len = sizeof(sockaddr);
1719     sockaddr.sin_port = 0;
1720     sockaddr.sin_addr.s_addr = 0;
1721
1722     ret = WSAStringToAddressA( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1723     GLE = WSAGetLastError();
1724     ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
1725         (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1726         "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
1727
1728     len = sizeof(sockaddr6);
1729     memset(&sockaddr6, 0, len);
1730     sockaddr6.sin6_family = AF_INET6;
1731
1732     ret = WSAStringToAddressA( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1733             &len );
1734     GLE = WSAGetLastError();
1735     ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1736         "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
1737
1738     len = sizeof(sockaddr6);
1739     memset(&sockaddr6, 0, len);
1740     sockaddr6.sin6_family = AF_INET6;
1741
1742     ret = WSAStringToAddressA( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1743             &len );
1744     GLE = WSAGetLastError();
1745     ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1746         "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
1747
1748     len = sizeof(sockaddr6);
1749     memset(&sockaddr6, 0, len);
1750     sockaddr6.sin6_family = AF_INET6;
1751
1752     ret = WSAStringToAddressA( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1753             &len );
1754     GLE = WSAGetLastError();
1755     ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
1756         (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1757         "WSAStringToAddressA() failed for IPv6 address: %d\n", GLE);
1758
1759 }
1760
1761 static void test_WSAStringToAddressW(void)
1762 {
1763     INT ret, len;
1764     SOCKADDR_IN sockaddr;
1765     SOCKADDR_IN6 sockaddr6;
1766     int GLE;
1767
1768     WCHAR address1[] = { '0','.','0','.','0','.','0', 0 };
1769     WCHAR address2[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
1770     WCHAR address3[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1771     WCHAR address4[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
1772                          ':', '6', '5', '5', '3', '5', 0 };
1773     WCHAR address5[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1774                          '6', '5', '5', '3', '5', 0 };
1775     WCHAR address6[] = {':',':','1','\0'};
1776     WCHAR address7[] = {'[',':',':','1',']','\0'};
1777     WCHAR address8[] = {'[',':',':','1',']',':','6','5','5','3','5','\0'};
1778
1779     len = 0;
1780     sockaddr.sin_family = AF_INET;
1781
1782     ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1783     ok( ret == SOCKET_ERROR, "WSAStringToAddressW() failed unexpectedly: %d\n",
1784         WSAGetLastError() );
1785
1786     len = sizeof(sockaddr);
1787     sockaddr.sin_port = 0;
1788     sockaddr.sin_addr.s_addr = 0;
1789
1790     ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1791     ok( !ret && sockaddr.sin_addr.s_addr == 0,
1792         "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1793
1794     len = sizeof(sockaddr);
1795     sockaddr.sin_port = 0;
1796     sockaddr.sin_addr.s_addr = 0;
1797
1798     ret = WSAStringToAddressW( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1799     ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
1800         "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1801
1802     len = sizeof(sockaddr);
1803     sockaddr.sin_port = 0;
1804     sockaddr.sin_addr.s_addr = 0;
1805
1806     ret = WSAStringToAddressW( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1807     GLE = WSAGetLastError();
1808     ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
1809         (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1810         "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
1811
1812     len = sizeof(sockaddr);
1813     sockaddr.sin_port = 0;
1814     sockaddr.sin_addr.s_addr = 0;
1815
1816     ret = WSAStringToAddressW( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1817     ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
1818         "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1819
1820     len = sizeof(sockaddr);
1821     sockaddr.sin_port = 0;
1822     sockaddr.sin_addr.s_addr = 0;
1823
1824     ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1825     ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
1826         (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1827         "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
1828
1829     len = sizeof(sockaddr6);
1830     memset(&sockaddr6, 0, len);
1831     sockaddr6.sin6_family = AF_INET6;
1832
1833     ret = WSAStringToAddressW( address6, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1834             &len );
1835     GLE = WSAGetLastError();
1836     ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1837         "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
1838
1839     len = sizeof(sockaddr6);
1840     memset(&sockaddr6, 0, len);
1841     sockaddr6.sin6_family = AF_INET6;
1842
1843     ret = WSAStringToAddressW( address7, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1844             &len );
1845     GLE = WSAGetLastError();
1846     ok( ret == 0 || (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1847         "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
1848
1849     len = sizeof(sockaddr6);
1850     memset(&sockaddr6, 0, len);
1851     sockaddr6.sin6_family = AF_INET6;
1852
1853     ret = WSAStringToAddressW( address8, AF_INET6, NULL, (SOCKADDR*)&sockaddr6,
1854             &len );
1855     GLE = WSAGetLastError();
1856     ok( (ret == 0 && sockaddr6.sin6_port == 0xffff) ||
1857         (ret == SOCKET_ERROR && GLE == WSAEINVAL),
1858         "WSAStringToAddressW() failed for IPv6 address: %d\n", GLE);
1859
1860 }
1861
1862 static VOID WINAPI SelectReadThread(select_thread_params *par)
1863 {
1864     fd_set readfds;
1865     int ret;
1866     struct sockaddr_in addr;
1867     struct timeval select_timeout;
1868
1869     FD_ZERO(&readfds);
1870     FD_SET(par->s, &readfds);
1871     select_timeout.tv_sec=5;
1872     select_timeout.tv_usec=0;
1873     addr.sin_family = AF_INET;
1874     addr.sin_addr.s_addr = inet_addr(SERVERIP);
1875     addr.sin_port = htons(SERVERPORT);
1876
1877     do_bind(par->s, (struct sockaddr *)&addr, sizeof(addr));
1878     wsa_ok(listen(par->s, SOMAXCONN ), 0 ==, "SelectReadThread (%x): listen failed: %d\n");
1879
1880     SetEvent(server_ready);
1881     ret = select(par->s+1, &readfds, NULL, NULL, &select_timeout);
1882     par->ReadKilled = (ret == 1);
1883 }
1884
1885 static void test_select(void)
1886 {
1887     SOCKET fdRead, fdWrite;
1888     fd_set readfds, writefds, exceptfds;
1889     unsigned int maxfd;
1890     int ret;
1891     struct timeval select_timeout;
1892     select_thread_params thread_params;
1893     HANDLE thread_handle;
1894     DWORD id;
1895
1896     fdRead = socket(AF_INET, SOCK_STREAM, 0);
1897     ok( (fdRead != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
1898     fdWrite = socket(AF_INET, SOCK_STREAM, 0);
1899     ok( (fdWrite != INVALID_SOCKET), "socket failed unexpectedly: %d\n", WSAGetLastError() );
1900
1901     FD_ZERO(&readfds);
1902     FD_ZERO(&writefds);
1903     FD_ZERO(&exceptfds);
1904     FD_SET(fdRead, &readfds);
1905     FD_SET(fdWrite, &writefds);
1906     FD_SET(fdRead, &exceptfds);
1907     FD_SET(fdWrite, &exceptfds);
1908     select_timeout.tv_sec=0;
1909     select_timeout.tv_usec=500;
1910
1911     maxfd = fdRead;
1912     if (fdWrite > maxfd)
1913         maxfd = fdWrite;
1914
1915     todo_wine {
1916     ret = select(maxfd+1, &readfds, &writefds, &exceptfds, &select_timeout);
1917     ok ( (ret == 0), "select should not return any socket handles\n");
1918     ok ( !FD_ISSET(fdRead, &readfds), "FD should not be set\n");
1919     ok ( !FD_ISSET(fdWrite, &writefds), "FD should not be set\n");
1920     }
1921
1922     ok ( !FD_ISSET(fdRead, &exceptfds), "FD should not be set\n");
1923     ok ( !FD_ISSET(fdWrite, &exceptfds), "FD should not be set\n");
1924
1925     todo_wine {
1926     ok ((listen(fdWrite, SOMAXCONN) == SOCKET_ERROR), "listen did not fail\n");
1927     }
1928     ret = closesocket(fdWrite);
1929     ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
1930
1931     thread_params.s = fdRead;
1932     thread_params.ReadKilled = FALSE;
1933     server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
1934     thread_handle = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) &SelectReadThread, &thread_params, 0, &id );
1935     ok ( (thread_handle != NULL), "CreateThread failed unexpectedly: %d\n", GetLastError());
1936
1937     WaitForSingleObject (server_ready, INFINITE);
1938     Sleep(200);
1939     ret = closesocket(fdRead);
1940     ok ( (ret == 0), "closesocket failed unexpectedly: %d\n", ret);
1941
1942     WaitForSingleObject (thread_handle, 1000);
1943     ok ( (thread_params.ReadKilled) ||
1944          broken(thread_params.ReadKilled == 0), /*Win98*/
1945             "closesocket did not wakeup select\n");
1946
1947 }
1948
1949 static DWORD WINAPI AcceptKillThread(select_thread_params *par)
1950 {
1951     struct sockaddr_in address;
1952     int len = sizeof(address);
1953     SOCKET client_socket;
1954
1955     SetEvent(server_ready);
1956     client_socket = accept(par->s, (struct sockaddr*) &address, &len);
1957     if (client_socket != INVALID_SOCKET)
1958         closesocket(client_socket);
1959     par->ReadKilled = (client_socket == INVALID_SOCKET);
1960     return 0;
1961 }
1962
1963
1964 static int CALLBACK AlwaysDeferConditionFunc(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
1965                                              LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
1966                                              GROUP FAR * g, DWORD_PTR dwCallbackData)
1967 {
1968     return CF_DEFER;
1969 }
1970
1971 static void test_accept(void)
1972 {
1973     int ret;
1974     SOCKET server_socket = INVALID_SOCKET, accepted = INVALID_SOCKET, connector = INVALID_SOCKET;
1975     struct sockaddr_in address;
1976     int socklen;
1977     select_thread_params thread_params;
1978     HANDLE thread_handle = NULL;
1979     DWORD id;
1980
1981     server_socket = socket(AF_INET, SOCK_STREAM, 0);
1982     if (server_socket == INVALID_SOCKET)
1983     {
1984         trace("error creating server socket: %d\n", WSAGetLastError());
1985         goto done;
1986     }
1987
1988     memset(&address, 0, sizeof(address));
1989     address.sin_addr.s_addr = inet_addr("127.0.0.1");
1990     address.sin_family = AF_INET;
1991     ret = bind(server_socket, (struct sockaddr*) &address, sizeof(address));
1992     if (ret != 0)
1993     {
1994         trace("error binding server socket: %d\n", WSAGetLastError());
1995         goto done;
1996     }
1997
1998     socklen = sizeof(address);
1999     ret = getsockname(server_socket, (struct sockaddr*)&address, &socklen);
2000     if (ret != 0) {
2001         skip("failed to lookup bind address, error %d\n", WSAGetLastError());
2002         goto done;
2003     }
2004
2005     ret = listen(server_socket, 5);
2006     if (ret != 0)
2007     {
2008         trace("error making server socket listen: %d\n", WSAGetLastError());
2009         goto done;
2010     }
2011
2012     trace("Blocking accept next\n");
2013
2014     connector = socket(AF_INET, SOCK_STREAM, 0);
2015     ok(connector != INVALID_SOCKET, "Failed to create connector socket, error %d\n", WSAGetLastError());
2016
2017     ret = connect(connector, (struct sockaddr*)&address, sizeof(address));
2018     ok(ret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
2019
2020     accepted = WSAAccept(server_socket, NULL, NULL, (LPCONDITIONPROC) AlwaysDeferConditionFunc, 0);
2021     ok(accepted == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
2022
2023     accepted = accept(server_socket, NULL, 0);
2024     ok(accepted != INVALID_SOCKET, "Failed to accept deferred connection, error %d\n", WSAGetLastError());
2025
2026     server_ready = CreateEventA(NULL, TRUE, FALSE, NULL);
2027     if (server_ready == INVALID_HANDLE_VALUE)
2028     {
2029         trace("error creating event: %d\n", GetLastError());
2030         goto done;
2031     }
2032
2033     thread_params.s = server_socket;
2034     thread_params.ReadKilled = FALSE;
2035     thread_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) AcceptKillThread,
2036         &thread_params, 0, &id);
2037     if (thread_handle == NULL)
2038     {
2039         trace("error creating thread: %d\n", GetLastError());
2040         goto done;
2041     }
2042
2043     WaitForSingleObject(server_ready, INFINITE);
2044     Sleep(200);
2045     ret = closesocket(server_socket);
2046     if (ret != 0)
2047     {
2048         trace("closesocket failed: %d\n", WSAGetLastError());
2049         goto done;
2050     }
2051
2052     WaitForSingleObject(thread_handle, 1000);
2053     ok(thread_params.ReadKilled || broken(!thread_params.ReadKilled) /* Win98/ME, after accept */,
2054        "closesocket did not wakeup accept\n");
2055
2056 done:
2057     if (accepted != INVALID_SOCKET)
2058         closesocket(accepted);
2059     if (connector != INVALID_SOCKET)
2060         closesocket(connector);
2061     if (thread_handle != NULL)
2062         CloseHandle(thread_handle);
2063     if (server_ready != INVALID_HANDLE_VALUE)
2064         CloseHandle(server_ready);
2065     if (server_socket != INVALID_SOCKET)
2066         closesocket(server_socket);
2067 }
2068
2069 static void test_extendedSocketOptions(void)
2070 {
2071     WSADATA wsa;
2072     SOCKET sock;
2073     struct sockaddr_in sa;
2074     int sa_len = sizeof(struct sockaddr_in);
2075     int optval, optlen = sizeof(int), ret;
2076     BOOL bool_opt_val;
2077     LINGER linger_val;
2078
2079     if(WSAStartup(MAKEWORD(2,0), &wsa)){
2080         trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
2081         return;
2082     }
2083
2084     memset(&sa, 0, sa_len);
2085
2086     sa.sin_family = AF_INET;
2087     sa.sin_port = htons(0);
2088     sa.sin_addr.s_addr = htonl(INADDR_ANY);
2089
2090     if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP)) == INVALID_SOCKET) {
2091         trace("Creating the socket failed: %d\n", WSAGetLastError());
2092         WSACleanup();
2093         return;
2094     }
2095
2096     if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
2097         trace("Failed to bind socket: %d\n", WSAGetLastError());
2098         closesocket(sock);
2099         WSACleanup();
2100         return;
2101     }
2102
2103     ret = getsockopt(sock, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
2104
2105     ok(ret == 0, "getsockopt failed to query SO_MAX_MSG_SIZE, return value is 0x%08x\n", ret);
2106     ok((optval == 65507) || (optval == 65527),
2107             "SO_MAX_MSG_SIZE reported %d, expected 65507 or 65527\n", optval);
2108
2109     /* IE 3 use 0xffffffff instead of SOL_SOCKET (0xffff) */
2110     SetLastError(0xdeadbeef);
2111     optval = 0xdeadbeef;
2112     optlen = sizeof(int);
2113     ret = getsockopt(sock, 0xffffffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
2114     ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
2115         "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2116         ret, WSAGetLastError(), optval, optval);
2117
2118     /* more invalid values for level */
2119     SetLastError(0xdeadbeef);
2120     optval = 0xdeadbeef;
2121     optlen = sizeof(int);
2122     ret = getsockopt(sock, 0x1234ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
2123     ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
2124         "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2125         ret, WSAGetLastError(), optval, optval);
2126
2127     SetLastError(0xdeadbeef);
2128     optval = 0xdeadbeef;
2129     optlen = sizeof(int);
2130     ret = getsockopt(sock, 0x8000ffff, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
2131     ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
2132         "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2133         ret, WSAGetLastError(), optval, optval);
2134
2135     SetLastError(0xdeadbeef);
2136     optval = 0xdeadbeef;
2137     optlen = sizeof(int);
2138     ret = getsockopt(sock, 0x00008000, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
2139     ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
2140         "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2141         ret, WSAGetLastError(), optval, optval);
2142
2143     SetLastError(0xdeadbeef);
2144     optval = 0xdeadbeef;
2145     optlen = sizeof(int);
2146     ret = getsockopt(sock, 0x00000800, SO_MAX_MSG_SIZE, (char *)&optval, &optlen);
2147     ok( (ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEINVAL),
2148         "got %d with %d and optval: 0x%x/%d (expected SOCKET_ERROR with WSAEINVAL)\n",
2149         ret, WSAGetLastError(), optval, optval);
2150
2151     optlen = sizeof(LINGER);
2152     ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
2153     todo_wine{
2154     ok(ret == SOCKET_ERROR, "getsockopt should fail for UDP sockets but return value is 0x%08x\n", ret);
2155     }
2156
2157     closesocket(sock);
2158
2159     if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
2160         trace("Creating the socket failed: %d\n", WSAGetLastError());
2161         WSACleanup();
2162         return;
2163     }
2164
2165     if(bind(sock, (struct sockaddr *) &sa, sa_len) < 0){
2166         trace("Failed to bind socket: %d\n", WSAGetLastError());
2167         closesocket(sock);
2168         WSACleanup();
2169         return;
2170     }
2171
2172     ret = getsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&linger_val, &optlen);
2173     ok(ret == 0, "getsockopt failed to query SO_LINGER, return value is 0x%08x\n", ret);
2174
2175     optlen = sizeof(BOOL);
2176     ret = getsockopt(sock, SOL_SOCKET, SO_DONTLINGER, (char *)&bool_opt_val, &optlen);
2177     ok(ret == 0, "getsockopt failed to query SO_DONTLINGER, return value is 0x%08x\n", ret);
2178     ok((linger_val.l_onoff && !bool_opt_val) || (!linger_val.l_onoff && bool_opt_val),
2179             "Return value of SO_DONTLINGER is %d, but SO_LINGER returned l_onoff == %d.\n",
2180             bool_opt_val, linger_val.l_onoff);
2181
2182     closesocket(sock);
2183     WSACleanup();
2184 }
2185
2186 static void test_getsockname(void)
2187 {
2188     WSADATA wsa;
2189     SOCKET sock;
2190     struct sockaddr_in sa_set, sa_get;
2191     int sa_set_len = sizeof(struct sockaddr_in);
2192     int sa_get_len = sa_set_len;
2193     static const unsigned char null_padding[] = {0,0,0,0,0,0,0,0};
2194     int ret;
2195
2196     if(WSAStartup(MAKEWORD(2,0), &wsa)){
2197         trace("Winsock failed: %d. Aborting test\n", WSAGetLastError());
2198         return;
2199     }
2200
2201     memset(&sa_set, 0, sa_set_len);
2202
2203     sa_set.sin_family = AF_INET;
2204     sa_set.sin_port = htons(0);
2205     sa_set.sin_addr.s_addr = htonl(INADDR_ANY);
2206
2207     if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_IP)) == INVALID_SOCKET) {
2208         trace("Creating the socket failed: %d\n", WSAGetLastError());
2209         WSACleanup();
2210         return;
2211     }
2212
2213     memcpy(&sa_get, &sa_set, sizeof(sa_set));
2214     if (getsockname(sock, (struct sockaddr*) &sa_get, &sa_get_len) == 0)
2215         ok(0, "getsockname on unbound socket should fail\n");
2216     else {
2217         ok(WSAGetLastError() == WSAEINVAL, "getsockname on unbound socket "
2218             "failed with %d, expected %d\n", WSAGetLastError(), WSAEINVAL);
2219         ok(memcmp(&sa_get, &sa_set, sizeof(sa_get)) == 0,
2220             "failed getsockname modified sockaddr when it shouldn't\n");
2221     }
2222
2223     if(bind(sock, (struct sockaddr *) &sa_set, sa_set_len) < 0){
2224         trace("Failed to bind socket: %d\n", WSAGetLastError());
2225         closesocket(sock);
2226         WSACleanup();
2227         return;
2228     }
2229
2230     if(getsockname(sock, (struct sockaddr *) &sa_get, &sa_get_len) != 0){
2231         trace("Failed to call getsockname: %d\n", WSAGetLastError());
2232         closesocket(sock);
2233         WSACleanup();
2234         return;
2235     }
2236
2237     ret = memcmp(sa_get.sin_zero, null_padding, 8);
2238     ok(ret == 0 || broken(ret != 0), /* NT4 */
2239             "getsockname did not zero the sockaddr_in structure\n");
2240
2241     closesocket(sock);
2242     WSACleanup();
2243 }
2244
2245 static void test_dns(void)
2246 {
2247     struct hostent *h;
2248
2249     h = gethostbyname("");
2250     ok(h != NULL, "gethostbyname(\"\") failed with %d\n", h_errno);
2251 }
2252
2253 /* Our winsock headers don't define gethostname because it conflicts with the
2254  * definition in unistd.h. Define it here to get rid of the warning. */
2255
2256 int WINAPI gethostname(char *name, int namelen);
2257
2258 static void test_gethostbyname_hack(void)
2259 {
2260     struct hostent *he;
2261     char name[256];
2262     static BYTE loopback[] = {127, 0, 0, 1};
2263     static BYTE magic_loopback[] = {127, 12, 34, 56};
2264     int ret;
2265
2266     ret = gethostname(name, 256);
2267     ok(ret == 0, "gethostname() call failed: %d\n", WSAGetLastError());
2268
2269     he = gethostbyname("localhost");
2270     ok(he != NULL, "gethostbyname(\"localhost\") failed: %d\n", h_errno);
2271     if(he)
2272     {
2273         if(he->h_length != 4)
2274         {
2275             skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
2276             return;
2277         }
2278
2279         ok(memcmp(he->h_addr_list[0], loopback, he->h_length) == 0,
2280            "gethostbyname(\"localhost\") returned %d.%d.%d.%d\n",
2281            he->h_addr_list[0][0], he->h_addr_list[0][1], he->h_addr_list[0][2],
2282            he->h_addr_list[0][3]);
2283     }
2284
2285     /* No reason to test further with NULL hostname */
2286     if(name == NULL)
2287         return;
2288
2289     if(strcmp(name, "localhost") == 0)
2290     {
2291         skip("hostname seems to be \"localhost\", skipping test.\n");
2292         return;
2293     }
2294
2295     he = NULL;
2296     he = gethostbyname(name);
2297     ok(he != NULL, "gethostbyname(\"%s\") failed: %d\n", name, h_errno);
2298     if(he)
2299     {
2300         if(he->h_length != 4)
2301         {
2302             skip("h_length is %d, not IPv4, skipping test.\n", he->h_length);
2303             return;
2304         }
2305
2306         if (he->h_addr_list[0][0] == 127)
2307         {
2308             ok(memcmp(he->h_addr_list[0], magic_loopback, he->h_length) == 0,
2309                "gethostbyname(\"%s\") returned %d.%d.%d.%d not 127.12.34.56\n",
2310                name, he->h_addr_list[0][0], he->h_addr_list[0][1],
2311                he->h_addr_list[0][2], he->h_addr_list[0][3]);
2312         }
2313     }
2314
2315     he = NULL;
2316     he = gethostbyname("nonexistent.winehq.org");
2317     /* Don't check for the return value, as some braindead ISPs will kindly
2318      * resolve nonexistent host names to addresses of the ISP's spam pages. */
2319 }
2320
2321 static void test_inet_addr(void)
2322 {
2323     u_long addr;
2324
2325     addr = inet_addr(NULL);
2326     ok(addr == INADDR_NONE, "inet_addr succeeded unexpectedly\n");
2327 }
2328
2329 static void test_addr_to_print(void)
2330 {
2331     char dst[16];
2332     char dst6[64];
2333     const char * pdst;
2334     struct in_addr in;
2335     struct in6_addr in6;
2336
2337     u_long addr0_Num = 0x00000000;
2338     PCSTR addr0_Str = "0.0.0.0";
2339     u_long addr1_Num = 0x20201015;
2340     PCSTR addr1_Str = "21.16.32.32";
2341     u_char addr2_Num[16] = {0,0,0,0,0,0,0,0,0,0,0xff,0xfe,0xcC,0x98,0xbd,0x74};
2342     PCSTR addr2_Str = "::fffe:cc98:bd74";
2343     u_char addr3_Num[16] = {0x20,0x30,0xa4,0xb1};
2344     PCSTR addr3_Str = "2030:a4b1::";
2345     u_char addr4_Num[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0xcC,0x98,0xbd,0x74};
2346     PCSTR addr4_Str = "::204.152.189.116";
2347
2348     /* Test IPv4 addresses */
2349     in.s_addr = addr0_Num;
2350
2351     pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
2352     ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
2353     ok(!strcmp(pdst, addr0_Str),"Address %s != %s\n", pdst, addr0_Str);
2354
2355     /* Test that inet_ntoa and inet_ntop return the same value */
2356     in.S_un.S_addr = addr1_Num;
2357     pdst = inet_ntoa(*((struct in_addr*)&in.s_addr));
2358     ok(pdst != NULL, "inet_ntoa failed %s\n", dst);
2359     ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
2360
2361     /* InetNtop became available in Vista and Win2008 */
2362     if (!pInetNtop)
2363     {
2364         win_skip("InetNtop not present, not executing tests\n");
2365         return;
2366     }
2367
2368     /* Second part of test */
2369     pdst = pInetNtop(AF_INET,(void*)&in.s_addr, dst, sizeof(dst));
2370     ok(pdst != NULL, "InetNtop failed %s\n", dst);
2371     ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
2372
2373     /* Test invalid parm conditions */
2374     pdst = pInetNtop(1, (void*)&in.s_addr, dst, sizeof(dst));
2375     ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
2376     ok(WSAGetLastError() == WSAEAFNOSUPPORT, "Should be WSAEAFNOSUPPORT\n");
2377
2378     /* Test Null destination */
2379     pdst = NULL;
2380     pdst = pInetNtop(AF_INET, (void*)&in.s_addr, NULL, sizeof(dst));
2381     ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
2382     ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
2383        "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2384
2385     /* Test zero length passed */
2386     WSASetLastError(0);
2387     pdst = NULL;
2388     pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 0);
2389     ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
2390     ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
2391        "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2392
2393     /* Test length one shorter than the address length */
2394     WSASetLastError(0);
2395     pdst = NULL;
2396     pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, 6);
2397     ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
2398     ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
2399        "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2400
2401     /* Test longer length is ok */
2402     WSASetLastError(0);
2403     pdst = NULL;
2404     pdst = pInetNtop(AF_INET, (void*)&in.s_addr, dst, sizeof(dst)+1);
2405     ok(pdst != NULL, "The pointer should  be returned (%p)\n", pdst);
2406     ok(!strcmp(pdst, addr1_Str),"Address %s != %s\n", pdst, addr1_Str);
2407
2408     /* Test the IPv6 addresses */
2409
2410     /* Test an zero prefixed IPV6 address */
2411     memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
2412     pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
2413     ok(pdst != NULL, "InetNtop failed %s\n", dst6);
2414     ok(!strcmp(pdst, addr2_Str),"Address %s != %s\n", pdst, addr2_Str);
2415
2416     /* Test an zero suffixed IPV6 address */
2417     memcpy(in6.s6_addr, addr3_Num, sizeof(addr3_Num));
2418     pdst = pInetNtop(AF_INET6,(void*)&in6.s6_addr, dst6, sizeof(dst6));
2419     ok(pdst != NULL, "InetNtop failed %s\n", dst6);
2420     ok(!strcmp(pdst, addr3_Str),"Address %s != %s\n", pdst, addr3_Str);
2421
2422     /* Test the IPv6 address contains the IPv4 address in IPv4 notation */
2423     memcpy(in6.s6_addr, addr4_Num, sizeof(addr4_Num));
2424     pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, sizeof(dst6));
2425     ok(pdst != NULL, "InetNtop failed %s\n", dst6);
2426     ok(!strcmp(pdst, addr4_Str),"Address %s != %s\n", pdst, addr4_Str);
2427
2428     /* Test invalid parm conditions */
2429     memcpy(in6.u.Byte, addr2_Num, sizeof(addr2_Num));
2430
2431     /* Test Null destination */
2432     pdst = NULL;
2433     pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, NULL, sizeof(dst6));
2434     ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
2435     ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
2436        "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2437
2438     /* Test zero length passed */
2439     WSASetLastError(0);
2440     pdst = NULL;
2441     pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 0);
2442     ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
2443     ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
2444        "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2445
2446     /* Test length one shorter than the address length */
2447     WSASetLastError(0);
2448     pdst = NULL;
2449     pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 16);
2450     ok(pdst == NULL, "The pointer should not be returned (%p)\n", pdst);
2451     ok(WSAGetLastError() == STATUS_INVALID_PARAMETER || WSAGetLastError() == WSAEINVAL /* Win7 */,
2452        "Should be STATUS_INVALID_PARAMETER or WSAEINVAL not 0x%x\n", WSAGetLastError());
2453
2454     /* Test longer length is ok */
2455     WSASetLastError(0);
2456     pdst = NULL;
2457     pdst = pInetNtop(AF_INET6, (void*)&in6.s6_addr, dst6, 18);
2458     ok(pdst != NULL, "The pointer should be returned (%p)\n", pdst);
2459 }
2460
2461 static void test_ioctlsocket(void)
2462 {
2463     SOCKET sock;
2464     int ret;
2465     static const LONG cmds[] = {FIONBIO, FIONREAD, SIOCATMARK};
2466     UINT i;
2467     u_long arg = 0;
2468
2469     sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
2470     ok(sock != INVALID_SOCKET, "Creating the socket failed: %d\n", WSAGetLastError());
2471     if(sock == INVALID_SOCKET)
2472     {
2473         skip("Can't continue without a socket.\n");
2474         return;
2475     }
2476
2477     for(i = 0; i < sizeof(cmds)/sizeof(cmds[0]); i++)
2478     {
2479         /* broken apps like defcon pass the argp value directly instead of a pointer to it */
2480         ret = ioctlsocket(sock, cmds[i], (u_long *)1);
2481         ok(ret == SOCKET_ERROR, "ioctlsocket succeeded unexpectedly\n");
2482         ret = WSAGetLastError();
2483         ok(ret == WSAEFAULT, "expected WSAEFAULT, got %d instead\n", ret);
2484     }
2485
2486     /* A fresh and not connected socket has no urgent data, this test shows
2487      * that normal(not urgent) data returns a non-zero value for SIOCATMARK. */
2488
2489     ret = ioctlsocket(sock, SIOCATMARK, &arg);
2490     if(ret != SOCKET_ERROR)
2491         todo_wine ok(arg, "expected a non-zero value\n");
2492 }
2493
2494 static int drain_pause=0;
2495 static DWORD WINAPI drain_socket_thread(LPVOID arg)
2496 {
2497     char buffer[1024];
2498     SOCKET sock = *(SOCKET*)arg;
2499     int ret;
2500
2501     while ((ret = recv(sock, buffer, sizeof(buffer), 0)) != 0)
2502     {
2503         if (ret < 0)
2504         {
2505             if (WSAGetLastError() == WSAEWOULDBLOCK)
2506             {
2507                 fd_set readset;
2508                 FD_ZERO(&readset);
2509                 FD_SET(sock, &readset);
2510                 select(0, &readset, NULL, NULL, NULL);
2511                 while (drain_pause)
2512                     Sleep(100);
2513             }
2514             else
2515                 break;
2516         }
2517     }
2518     return 0;
2519 }
2520
2521 static void test_send(void)
2522 {
2523     SOCKET src = INVALID_SOCKET;
2524     SOCKET dst = INVALID_SOCKET;
2525     HANDLE hThread = NULL;
2526     const int buflen = 1024*1024;
2527     char *buffer = NULL;
2528     int ret;
2529     DWORD id;
2530
2531     if (tcp_socketpair(&src, &dst) != 0)
2532     {
2533         ok(0, "creating socket pair failed, skipping test\n");
2534         return;
2535     }
2536
2537     hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
2538     if (hThread == NULL)
2539     {
2540         ok(0, "CreateThread failed, error %d\n", GetLastError());
2541         goto end;
2542     }
2543
2544     buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen);
2545     if (buffer == NULL)
2546     {
2547         ok(0, "HeapAlloc failed, error %d\n", GetLastError());
2548         goto end;
2549     }
2550
2551     ret = send(src, buffer, buflen, 0);
2552     if (ret >= 0)
2553         ok(ret == buflen, "send should have sent %d bytes, but it only sent %d\n", buflen, ret);
2554     else
2555         ok(0, "send failed, error %d\n", WSAGetLastError());
2556
2557 end:
2558     if (src != INVALID_SOCKET)
2559         closesocket(src);
2560     if (dst != INVALID_SOCKET)
2561         closesocket(dst);
2562     if (hThread != NULL)
2563         CloseHandle(hThread);
2564     HeapFree(GetProcessHeap(), 0, buffer);
2565 }
2566
2567 typedef struct async_message
2568 {
2569     SOCKET socket;
2570     LPARAM lparam;
2571     struct async_message *next;
2572 } async_message;
2573
2574 static struct async_message *messages_recieved;
2575
2576 #define WM_SOCKET (WM_USER+100)
2577 static LRESULT CALLBACK ws2_test_WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
2578 {
2579     struct async_message *message;
2580
2581     switch (msg)
2582     {
2583     case WM_SOCKET:
2584         message = HeapAlloc(GetProcessHeap(), 0, sizeof(*message));
2585         message->socket = (SOCKET) wparam;
2586         message->lparam = lparam;
2587         message->next = NULL;
2588
2589         if (messages_recieved)
2590         {
2591             struct async_message *last = messages_recieved;
2592             while (last->next) last = last->next;
2593             last->next = message;
2594         }
2595         else
2596             messages_recieved = message;
2597         return 0;
2598     }
2599
2600     return DefWindowProc(hwnd, msg, wparam, lparam);
2601 }
2602
2603 static void get_event_details(int event, int *bit, char *name)
2604 {
2605     switch (event)
2606     {
2607         case FD_ACCEPT:
2608             if (bit) *bit = FD_ACCEPT_BIT;
2609             if (name) strcpy(name, "FD_ACCEPT");
2610             break;
2611         case FD_CONNECT:
2612             if (bit) *bit = FD_CONNECT_BIT;
2613             if (name) strcpy(name, "FD_CONNECT");
2614             break;
2615         case FD_READ:
2616             if (bit) *bit = FD_READ_BIT;
2617             if (name) strcpy(name, "FD_READ");
2618             break;
2619         case FD_OOB:
2620             if (bit) *bit = FD_OOB_BIT;
2621             if (name) strcpy(name, "FD_OOB");
2622             break;
2623         case FD_WRITE:
2624             if (bit) *bit = FD_WRITE_BIT;
2625             if (name) strcpy(name, "FD_WRITE");
2626             break;
2627         case FD_CLOSE:
2628             if (bit) *bit = FD_CLOSE_BIT;
2629             if (name) strcpy(name, "FD_CLOSE");
2630             break;
2631         default:
2632             if (bit) *bit = -1;
2633             if (name) sprintf(name, "bad%x", event);
2634     }
2635 }
2636
2637 static char *dbgstr_event_seq(const LPARAM *seq)
2638 {
2639     static char message[1024];
2640     char name[10];
2641
2642     message[0] = '[';
2643     message[1] = 0;
2644     while (*seq)
2645     {
2646         get_event_details(WSAGETSELECTEVENT(*seq), NULL, name);
2647
2648         sprintf(message, "%s%s%s(%d)", message, message[1] == 0 ? "" : " ",
2649                                        name, WSAGETSELECTERROR(*seq));
2650
2651         seq++;
2652     }
2653     strcat(message, "]");
2654     return message;
2655 }
2656
2657 static char *dbgstr_event_seq_result(SOCKET s, WSANETWORKEVENTS *netEvents)
2658 {
2659     static char message[1024];
2660     struct async_message *curr = messages_recieved;
2661     int index, error, bit = 0;
2662     char name[10];
2663
2664     message[0] = '[';
2665     message[1] = 0;
2666     while (1)
2667     {
2668         if (netEvents)
2669         {
2670             if (bit >= FD_MAX_EVENTS) break;
2671             if ( !(netEvents->lNetworkEvents & (1 << bit)) )
2672             {
2673                 bit++;
2674                 continue;
2675             }
2676             get_event_details(1 << bit, &index, name);
2677             error = netEvents->iErrorCode[index];
2678             bit++;
2679         }
2680         else
2681         {
2682             if (!curr) break;
2683             if (curr->socket != s)
2684             {
2685                 curr = curr->next;
2686                 continue;
2687             }
2688             get_event_details(WSAGETSELECTEVENT(curr->lparam), NULL, name);
2689             error = WSAGETSELECTERROR(curr->lparam);
2690             curr = curr->next;
2691         }
2692
2693         sprintf(message, "%s%s%s(%d)", message, message[1] == 0 ? "" : " ",
2694                                        name, error);
2695     }
2696     strcat(message, "]");
2697     return message;
2698 }
2699
2700 static void flush_events(SOCKET s, HANDLE hEvent)
2701 {
2702     WSANETWORKEVENTS netEvents;
2703     struct async_message *prev = NULL, *curr = messages_recieved;
2704     int ret;
2705     DWORD dwRet;
2706
2707     if (hEvent != INVALID_HANDLE_VALUE)
2708     {
2709         dwRet = WaitForSingleObject(hEvent, 100);
2710         if (dwRet == WAIT_OBJECT_0)
2711         {
2712             ret = WSAEnumNetworkEvents(s, hEvent, &netEvents);
2713             if (ret)
2714                 ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
2715         }
2716     }
2717     else
2718     {
2719         while (curr)
2720         {
2721             if (curr->socket == s)
2722             {
2723                 if (prev) prev->next = curr->next;
2724                 else messages_recieved = curr->next;
2725
2726                 HeapFree(GetProcessHeap(), 0, curr);
2727
2728                 if (prev) curr = prev->next;
2729                 else curr = messages_recieved;
2730             }
2731             else
2732             {
2733                 prev = curr;
2734                 curr = curr->next;
2735             }
2736         }
2737     }
2738 }
2739
2740 static int match_event_sequence(SOCKET s, WSANETWORKEVENTS *netEvents, const LPARAM *seq)
2741 {
2742     int event, index, error, events;
2743     struct async_message *curr;
2744
2745     if (netEvents)
2746     {
2747         events = netEvents->lNetworkEvents;
2748         while (*seq)
2749         {
2750             event = WSAGETSELECTEVENT(*seq);
2751             error = WSAGETSELECTERROR(*seq);
2752             get_event_details(event, &index, NULL);
2753
2754             if (!(events & event) && index != -1)
2755                 return 0;
2756             if (events & event && index != -1)
2757             {
2758                 if (netEvents->iErrorCode[index] != error)
2759                     return 0;
2760             }
2761             events &= ~event;
2762             seq++;
2763         }
2764         if (events)
2765             return 0;
2766     }
2767     else
2768     {
2769         curr = messages_recieved;
2770         while (curr)
2771         {
2772             if (curr->socket == s)
2773             {
2774                 if (!*seq) return 0;
2775                 if (*seq != curr->lparam) return 0;
2776                 seq++;
2777             }
2778             curr = curr->next;
2779         }
2780         if (*seq)
2781             return 0;
2782     }
2783     return 1;
2784 }
2785
2786 /* checks for a sequence of events, (order only checked if window is used) */
2787 static void ok_event_sequence(SOCKET s, HANDLE hEvent, const LPARAM *seq, const LPARAM **broken_seqs, int completelyBroken)
2788 {
2789     MSG msg;
2790     WSANETWORKEVENTS events, *netEvents = NULL;
2791     int ret;
2792     DWORD dwRet;
2793
2794     if (hEvent != INVALID_HANDLE_VALUE)
2795     {
2796         netEvents = &events;
2797
2798         dwRet = WaitForSingleObject(hEvent, 200);
2799         if (dwRet == WAIT_OBJECT_0)
2800         {
2801             ret = WSAEnumNetworkEvents(s, hEvent, netEvents);
2802             if (ret)
2803             {
2804                 winetest_ok(0, "WSAEnumNetworkEvents failed, error %d\n", ret);
2805                 return;
2806             }
2807         }
2808         else
2809             memset(netEvents, 0, sizeof(*netEvents));
2810     }
2811     else
2812     {
2813         Sleep(200);
2814         /* Run the message loop a little */
2815         while (PeekMessageA( &msg, 0, 0, 0, PM_REMOVE ))
2816         {
2817             DispatchMessageA(&msg);
2818         }
2819     }
2820
2821     if (match_event_sequence(s, netEvents, seq))
2822     {
2823         winetest_ok(1, "Sequence matches expected: %s\n", dbgstr_event_seq(seq));
2824         flush_events(s, hEvent);
2825         return;
2826     }
2827
2828     if (broken_seqs)
2829     {
2830         for (; *broken_seqs; broken_seqs++)
2831         {
2832             if (match_event_sequence(s, netEvents, *broken_seqs))
2833             {
2834                 winetest_ok(broken(1), "Sequence matches broken: %s, expected %s\n", dbgstr_event_seq_result(s, netEvents), dbgstr_event_seq(seq));
2835                 flush_events(s, hEvent);
2836                 return;
2837             }
2838         }
2839     }
2840
2841     winetest_ok(broken(completelyBroken), "Expected event sequence %s, got %s\n", dbgstr_event_seq(seq),
2842                 dbgstr_event_seq_result(s, netEvents));
2843     flush_events(s, hEvent);
2844 }
2845
2846 #define ok_event_seq (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : ok_event_sequence
2847
2848 static void test_events(int useMessages)
2849 {
2850     SOCKET server = INVALID_SOCKET;
2851     SOCKET src = INVALID_SOCKET, src2 = INVALID_SOCKET;
2852     SOCKET dst = INVALID_SOCKET, dst2 = INVALID_SOCKET;
2853     struct sockaddr_in addr;
2854     HANDLE hThread = NULL;
2855     HANDLE hEvent = INVALID_HANDLE_VALUE, hEvent2 = INVALID_HANDLE_VALUE;
2856     WNDCLASSEX wndclass;
2857     HWND hWnd = NULL;
2858     char *buffer = NULL;
2859     int bufferSize = 1024*1024;
2860     WSABUF bufs;
2861     OVERLAPPED ov, ov2;
2862     DWORD flags = 0;
2863     DWORD bytesReturned;
2864     DWORD id;
2865     int len;
2866     int ret;
2867     DWORD dwRet;
2868     BOOL bret;
2869     static char szClassName[] = "wstestclass";
2870     const LPARAM *broken_seq[3];
2871     static const LPARAM empty_seq[] = { 0 };
2872     static const LPARAM close_seq[] = { WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
2873     static const LPARAM write_seq[] = { WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
2874     static const LPARAM read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0), 0 };
2875     static const LPARAM oob_seq[] = { WSAMAKESELECTREPLY(FD_OOB, 0), 0 };
2876     static const LPARAM connect_seq[] = { WSAMAKESELECTREPLY(FD_CONNECT, 0),
2877                                           WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
2878     static const LPARAM read_read_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
2879                                             WSAMAKESELECTREPLY(FD_READ, 0), 0 };
2880     static const LPARAM read_write_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
2881                                              WSAMAKESELECTREPLY(FD_WRITE, 0), 0 };
2882     static const LPARAM read_close_seq[] = { WSAMAKESELECTREPLY(FD_READ, 0),
2883                                              WSAMAKESELECTREPLY(FD_CLOSE, 0), 0 };
2884
2885     memset(&ov, 0, sizeof(ov));
2886     memset(&ov2, 0, sizeof(ov2));
2887
2888     /* don't use socketpair, we want connection event */
2889     src = socket(AF_INET, SOCK_STREAM, 0);
2890     if (src == INVALID_SOCKET)
2891     {
2892         ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2893         goto end;
2894     }
2895
2896     src2 = socket(AF_INET, SOCK_STREAM, 0);
2897     if (src2 == INVALID_SOCKET)
2898     {
2899         ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2900         goto end;
2901     }
2902
2903     len = sizeof(BOOL);
2904     if (getsockopt(src, SOL_SOCKET, SO_OOBINLINE, (void *)&bret, &len) == SOCKET_ERROR)
2905     {
2906         ok(0, "failed to get oobinline status, %d\n", GetLastError());
2907         goto end;
2908     }
2909     ok(bret == FALSE, "OOB not inline\n");
2910
2911     if (useMessages)
2912     {
2913         trace("Event test using messages\n");
2914
2915         wndclass.cbSize         = sizeof(wndclass);
2916         wndclass.style          = CS_HREDRAW | CS_VREDRAW;
2917         wndclass.lpfnWndProc    = ws2_test_WndProc;
2918         wndclass.cbClsExtra     = 0;
2919         wndclass.cbWndExtra     = 0;
2920         wndclass.hInstance      = GetModuleHandle(NULL);
2921         wndclass.hIcon          = LoadIcon(NULL, IDI_APPLICATION);
2922         wndclass.hIconSm        = LoadIcon(NULL, IDI_APPLICATION);
2923         wndclass.hCursor        = LoadCursor(NULL, IDC_ARROW);
2924         wndclass.hbrBackground  = (HBRUSH)(COLOR_WINDOW + 1);
2925         wndclass.lpszClassName  = szClassName;
2926         wndclass.lpszMenuName   = NULL;
2927         RegisterClassEx(&wndclass);
2928
2929         hWnd = CreateWindow(szClassName, "WS2Test", WS_OVERLAPPEDWINDOW, 0, 0, 500, 500, NULL, NULL, GetModuleHandle(NULL), NULL);
2930         if (!hWnd)
2931         {
2932             ok(0, "failed to create window: %d\n", GetLastError());
2933             return;
2934         }
2935
2936         ret = WSAAsyncSelect(src, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
2937         if (ret)
2938         {
2939             ok(0, "WSAAsyncSelect failed, error %d\n", ret);
2940             goto end;
2941         }
2942
2943         ret = WSAAsyncSelect(src2, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
2944         if (ret)
2945         {
2946             ok(0, "WSAAsyncSelect failed, error %d\n", ret);
2947             goto end;
2948         }
2949     }
2950     else
2951     {
2952         trace("Event test using events\n");
2953
2954         hEvent = WSACreateEvent();
2955         if (hEvent == INVALID_HANDLE_VALUE)
2956         {
2957             ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
2958             goto end;
2959         }
2960
2961         hEvent2 = WSACreateEvent();
2962         if (hEvent2 == INVALID_HANDLE_VALUE)
2963         {
2964             ok(0, "WSACreateEvent failed, error %d\n", GetLastError());
2965             goto end;
2966         }
2967
2968         ret = WSAEventSelect(src, hEvent, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
2969         if (ret)
2970         {
2971             ok(0, "WSAEventSelect failed, error %d\n", ret);
2972             goto end;
2973         }
2974
2975         ret = WSAEventSelect(src2, hEvent2, FD_CONNECT | FD_READ | FD_OOB | FD_WRITE | FD_CLOSE);
2976         if (ret)
2977         {
2978             ok(0, "WSAEventSelect failed, error %d\n", ret);
2979             goto end;
2980         }
2981     }
2982
2983     server = socket(AF_INET, SOCK_STREAM, 0);
2984     if (server == INVALID_SOCKET)
2985     {
2986         ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2987         goto end;
2988     }
2989
2990     memset(&addr, 0, sizeof(addr));
2991     addr.sin_family = AF_INET;
2992     addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2993     ret = bind(server, (struct sockaddr*)&addr, sizeof(addr));
2994     if (ret != 0)
2995     {
2996         ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
2997         goto end;
2998     }
2999
3000     len = sizeof(addr);
3001     ret = getsockname(server, (struct sockaddr*)&addr, &len);
3002     if (ret != 0)
3003     {
3004         ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3005         goto end;
3006     }
3007
3008     ret = listen(server, 2);
3009     if (ret != 0)
3010     {
3011         ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3012         goto end;
3013     }
3014
3015     ret = connect(src, (struct sockaddr*)&addr, sizeof(addr));
3016     if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
3017     {
3018         ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3019         goto end;
3020     }
3021
3022     ret = connect(src2, (struct sockaddr*)&addr, sizeof(addr));
3023     if (ret == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
3024     {
3025         ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3026         goto end;
3027     }
3028
3029     len = sizeof(addr);
3030     dst = accept(server, (struct sockaddr*)&addr, &len);
3031     if (dst == INVALID_SOCKET)
3032     {
3033         ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3034         goto end;
3035     }
3036
3037     len = sizeof(addr);
3038     dst2 = accept(server, (struct sockaddr*)&addr, &len);
3039     if (dst2 == INVALID_SOCKET)
3040     {
3041         ok(0, "creating socket pair failed (%d), skipping test\n", GetLastError());
3042         goto end;
3043     }
3044
3045     closesocket(server);
3046     server = INVALID_SOCKET;
3047
3048     /* On Windows it seems when a non-blocking socket sends to a
3049        blocking socket on the same host, the send() is BLOCKING,
3050        so make both sockets non-blocking. src is already non-blocking
3051        from the async select */
3052
3053     if (set_blocking(dst, FALSE))
3054     {
3055         ok(0, "ioctlsocket failed, error %d\n", WSAGetLastError());
3056         goto end;
3057     }
3058
3059     buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufferSize);
3060     if (buffer == NULL)
3061     {
3062         ok(0, "could not allocate memory for test\n");
3063         goto end;
3064     }
3065
3066     ov.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
3067     if (ov.hEvent == NULL)
3068     {
3069         ok(0, "could not create event object, errno = %d\n", GetLastError());
3070         goto end;
3071     }
3072
3073     ov2.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
3074     if (ov2.hEvent == NULL)
3075     {
3076         ok(0, "could not create event object, errno = %d\n", GetLastError());
3077         goto end;
3078     }
3079
3080     /* FD_WRITE should be set initially, and allow us to send at least 1 byte */
3081     ok_event_seq(src, hEvent, connect_seq, NULL, 1);
3082     ok_event_seq(src2, hEvent2, connect_seq, NULL, 1);
3083     /* broken on all windows - FD_CONNECT error is garbage */
3084
3085     /* Test simple send/recv */
3086     ret = send(dst, buffer, 100, 0);
3087     ok(ret == 100, "Failed to send buffer %d err %d\n", ret, GetLastError());
3088     ok_event_seq(src, hEvent, read_seq, NULL, 0);
3089
3090     ret = recv(src, buffer, 50, 0);
3091     ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
3092     ok_event_seq(src, hEvent, read_seq, NULL, 0);
3093
3094     ret = recv(src, buffer, 50, 0);
3095     ok(ret == 50, "Failed to recv buffer %d err %d\n", ret, GetLastError());
3096     ok_event_seq(src, hEvent, empty_seq, NULL, 0);
3097
3098     /* fun fact - events are reenabled even on failure, but only for messages */
3099     ret = send(dst, "1", 1, 0);
3100     ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
3101     ok_event_seq(src, hEvent, read_seq, NULL, 0);
3102
3103     ret = recv(src, buffer, -1, 0);
3104     ok(ret == SOCKET_ERROR && (GetLastError() == WSAEFAULT || GetLastError() == WSAENOBUFS),
3105        "Failed to recv buffer %d err %d\n", ret, GetLastError());
3106     if (useMessages)
3107     {
3108         broken_seq[0] = empty_seq; /* win9x */
3109         broken_seq[1] = NULL;
3110         todo_wine ok_event_seq(src, hEvent, read_seq, broken_seq, 0);
3111     }
3112     else
3113         ok_event_seq(src, hEvent, empty_seq, NULL, 0);
3114
3115     ret = recv(src, buffer, 1, 0);
3116     ok(ret == 1, "Failed to recv buffer %d err %d\n", ret, GetLastError());
3117     ok_event_seq(src, hEvent, empty_seq, NULL, 0);
3118
3119     /* Interaction with overlapped */
3120     bufs.len = sizeof(char);
3121     bufs.buf = buffer;
3122     ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
3123     ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
3124        "WSARecv failed - %d error %d\n", ret, GetLastError());
3125
3126     bufs.len = sizeof(char);
3127     bufs.buf = buffer+1;
3128     ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov2, NULL);
3129     ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
3130        "WSARecv failed - %d error %d\n", ret, GetLastError());
3131
3132     ret = send(dst, "12", 2, 0);
3133     ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
3134     broken_seq[0] = read_read_seq; /* win9x */
3135     broken_seq[1] = NULL;
3136     /* we like to erase pmask in server, so we have varying behavior here *
3137      * it is only fixed for now because we refuse to send notifications with
3138      * any kind of asyncs requests running */
3139     ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
3140
3141     dwRet = WaitForSingleObject(ov.hEvent, 100);
3142     ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
3143     if (dwRet == WAIT_OBJECT_0)
3144     {
3145         bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
3146         ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
3147            "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
3148         ok(buffer[0] == '1', "Got %c instead of 1\n", buffer[0]);
3149     }
3150
3151     dwRet = WaitForSingleObject(ov2.hEvent, 100);
3152     ok(dwRet == WAIT_OBJECT_0, "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
3153     if (dwRet == WAIT_OBJECT_0)
3154     {
3155         bret = GetOverlappedResult((HANDLE)src, &ov2, &bytesReturned, FALSE);
3156         ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
3157            "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
3158         ok(buffer[1] == '2', "Got %c instead of 2\n", buffer[1]);
3159     }
3160
3161     ret = send(dst, "1", 1, 0);
3162     ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
3163     ok_event_seq(src, hEvent, read_seq, NULL, 0);
3164
3165     ret = recv(src, buffer, 1, 0);
3166     ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3167     ok_event_seq(src, hEvent, empty_seq, NULL, 0);
3168
3169     /* Notifications are delivered as soon as possible, blocked only on
3170      * async requests on the same type */
3171     bufs.len = sizeof(char);
3172     bufs.buf = buffer;
3173     ret = WSARecv(src, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
3174     ok(ret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING,
3175        "WSARecv failed - %d error %d\n", ret, GetLastError());
3176
3177     if (0) {
3178     ret = send(dst, "1", 1, MSG_OOB);
3179     ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
3180     ok_event_seq(src, hEvent, oob_seq, NULL, 0);
3181     }
3182
3183     dwRet = WaitForSingleObject(ov.hEvent, 100);
3184     ok(dwRet == WAIT_TIMEOUT, "OOB message activated read?: %d - %d\n", dwRet, GetLastError());
3185
3186     ret = send(dst, "2", 1, 0);
3187     ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
3188     broken_seq[0] = read_seq;  /* win98 */
3189     broken_seq[1] = NULL;
3190     ok_event_seq(src, hEvent, empty_seq, broken_seq, 0);
3191
3192     dwRet = WaitForSingleObject(ov.hEvent, 100);
3193     ok(dwRet == WAIT_OBJECT_0 || broken(dwRet == WAIT_TIMEOUT),
3194        "Failed to wait for recv message: %d - %d\n", dwRet, GetLastError());
3195     if (dwRet == WAIT_OBJECT_0)
3196     {
3197         bret = GetOverlappedResult((HANDLE)src, &ov, &bytesReturned, FALSE);
3198         ok((bret && bytesReturned == 1) || broken(!bret && GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */,
3199            "Got %d instead of 1 (%d - %d)\n", bytesReturned, bret, GetLastError());
3200         ok(buffer[0] == '2', "Got %c instead of 2\n", buffer[1]);
3201     }
3202     else if (dwRet == WAIT_TIMEOUT)
3203     {
3204         /* this happens on win98. We get an FD_READ later on the next test */
3205         CancelIo((HANDLE) src);
3206     }
3207
3208     if (0) {
3209     ret = recv(src, buffer, 1, MSG_OOB);
3210     todo_wine ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3211     /* We get OOB notification, but no data on wine */
3212     ok_event_seq(src, hEvent, empty_seq, NULL, 0);
3213     }
3214
3215     /* wine gets a stale notifications because of the async ops, clear them.
3216      * remove when sending messages during pending asyncs is fixed */
3217     ret = send(dst, "2", 1, 0);
3218     ok(ret == 1, "Failed to send buffer %d err %d\n", ret, GetLastError());
3219     ok_event_seq(src, hEvent, read_seq, NULL, 0);
3220
3221     ret = recv(src, buffer, 1, 0);
3222     ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3223     ok_event_seq(src, hEvent, empty_seq, NULL, 0);
3224
3225     /* Flood the send queue */
3226     hThread = CreateThread(NULL, 0, drain_socket_thread, &dst, 0, &id);
3227     if (hThread == NULL)
3228     {
3229         ok(0, "CreateThread failed, error %d\n", GetLastError());
3230         goto end;
3231     }
3232
3233     /* Now FD_WRITE should not be set, because the socket send buffer isn't full yet */
3234     ok_event_seq(src, hEvent, empty_seq, NULL, 0);
3235
3236     /* Now if we send a ton of data and the 'server' does not drain it fast
3237      * enough (set drain_pause to be sure), the socket send buffer will only
3238      * take some of it, and we will get a short write. This will trigger
3239      * another FD_WRITE event as soon as data is sent and more space becomes
3240      * available, but not any earlier. */
3241     drain_pause=1;
3242     do
3243     {
3244         ret = send(src, buffer, bufferSize, 0);
3245     } while (ret == bufferSize);
3246     drain_pause=0;
3247     if (ret >= 0 || WSAGetLastError() == WSAEWOULDBLOCK)
3248     {
3249         Sleep(400); /* win9x */
3250         broken_seq[0] = read_write_seq;
3251         broken_seq[1] = NULL;
3252         ok_event_seq(src, hEvent, write_seq, broken_seq, 0);
3253     }
3254     else
3255     {
3256         ok(0, "sending a lot of data failed with error %d\n", WSAGetLastError());
3257     }
3258
3259     /* Test how FD_CLOSE is handled */
3260     ret = send(dst, "12", 2, 0);
3261     ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
3262
3263     /* Wait a little and let the send complete */
3264     Sleep(100);
3265     closesocket(dst);
3266     dst = INVALID_SOCKET;
3267     Sleep(100);
3268
3269     /* We can never implement this in wine, best we can hope for is
3270        sending FD_CLOSE after the reads complete */
3271     broken_seq[0] = read_seq;  /* win9x */
3272     broken_seq[1] = NULL;
3273     todo_wine ok_event_seq(src, hEvent, read_close_seq, broken_seq, 0);
3274
3275     ret = recv(src, buffer, 1, 0);
3276     ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3277     ok_event_seq(src, hEvent, read_seq, NULL, 0);
3278
3279     ret = recv(src, buffer, 1, 0);
3280     ok(ret == 1, "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3281     /* want it? it's here, but you can't have it */
3282     broken_seq[0] = close_seq;  /* win9x */
3283     broken_seq[1] = NULL;
3284     todo_wine ok_event_seq(src, hEvent, empty_seq, /* wine sends FD_CLOSE here */
3285                            broken_seq, 0);
3286
3287     /* Test how FD_CLOSE is handled */
3288     ret = send(dst2, "12", 2, 0);
3289     ok(ret == 2, "Failed to send buffer %d err %d\n", ret, GetLastError());
3290
3291     Sleep(200);
3292     shutdown(dst2, SD_SEND);
3293     Sleep(200);
3294
3295     /* Some of the below are technically todo_wine, but our event sequence is still valid, so to prevent
3296        regressions, don't mark them as todo_wine, and mark windows as broken */
3297     broken_seq[0] = read_close_seq;
3298     broken_seq[1] = close_seq;
3299     broken_seq[2] = NULL;
3300     ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
3301
3302     ret = recv(src2, buffer, 1, 0);
3303     ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3304     broken_seq[0] = close_seq;  /* win98 */
3305     broken_seq[1] = NULL;
3306     ok_event_seq(src2, hEvent2, read_seq, broken_seq, 0);
3307
3308     ret = recv(src2, buffer, 1, 0);
3309     ok(ret == 1 || broken(!ret), "Failed to empty buffer: %d - %d\n", ret, GetLastError());
3310     broken_seq[0] = empty_seq;
3311     broken_seq[1] = NULL;
3312     ok_event_seq(src2, hEvent2, close_seq, broken_seq, 0);
3313
3314     ret = send(src2, "1", 1, 0);
3315     ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
3316     ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
3317
3318     ret = send(src2, "1", 1, 0);
3319     ok(ret == 1, "Sending to half-closed socket failed %d err %d\n", ret, GetLastError());
3320     ok_event_seq(src2, hEvent2, empty_seq, NULL, 0);
3321
3322 end:
3323     if (src != INVALID_SOCKET)
3324     {
3325         flush_events(src, hEvent);
3326         closesocket(src);
3327     }
3328     if (src2 != INVALID_SOCKET)
3329     {
3330         flush_events(src2, hEvent2);
3331         closesocket(src2);
3332     }
3333     HeapFree(GetProcessHeap(), 0, buffer);
3334     if (server != INVALID_SOCKET)
3335         closesocket(server);
3336     if (dst != INVALID_SOCKET)
3337         closesocket(dst);
3338     if (dst2 != INVALID_SOCKET)
3339         closesocket(dst2);
3340     if (hThread != NULL)
3341         CloseHandle(hThread);
3342     if (hWnd != NULL)
3343         CloseHandle(hWnd);
3344     if (hEvent != NULL)
3345         CloseHandle(hEvent);
3346     if (hEvent2 != NULL)
3347         CloseHandle(hEvent2);
3348     if (ov.hEvent != NULL)
3349         CloseHandle(ov.hEvent);
3350     if (ov2.hEvent != NULL)
3351         CloseHandle(ov2.hEvent);
3352 }
3353
3354 static void test_ipv6only(void)
3355 {
3356     SOCKET v4 = INVALID_SOCKET,
3357            v6 = INVALID_SOCKET;
3358     struct sockaddr_in sin4;
3359     struct sockaddr_in6 sin6;
3360     int ret;
3361
3362     memset(&sin4, 0, sizeof(sin4));
3363     sin4.sin_family = AF_INET;
3364     sin4.sin_port = htons(SERVERPORT);
3365
3366     memset(&sin6, 0, sizeof(sin6));
3367     sin6.sin6_family = AF_INET6;
3368     sin6.sin6_port = htons(SERVERPORT);
3369
3370     v6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
3371     if (v6 == INVALID_SOCKET) {
3372         skip("Could not create IPv6 socket (LastError: %d; %d expected if IPv6 not available).\n",
3373             WSAGetLastError(), WSAEAFNOSUPPORT);
3374         goto end;
3375     }
3376     ret = bind(v6, (struct sockaddr*)&sin6, sizeof(sin6));
3377     if (ret) {
3378         skip("Could not bind IPv6 address (LastError: %d).\n",
3379             WSAGetLastError());
3380         goto end;
3381     }
3382
3383     v4 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
3384     if (v4 == INVALID_SOCKET) {
3385         skip("Could not create IPv4 socket (LastError: %d).\n",
3386             WSAGetLastError());
3387         goto end;
3388     }
3389     ret = bind(v4, (struct sockaddr*)&sin4, sizeof(sin4));
3390     ok(!ret, "Could not bind IPv4 address (LastError: %d; %d expected if IPv6 binds to IPv4 as well).\n",
3391         WSAGetLastError(), WSAEADDRINUSE);
3392
3393 end:
3394     if (v4 != INVALID_SOCKET)
3395         closesocket(v4);
3396     if (v6 != INVALID_SOCKET)
3397         closesocket(v6);
3398 }
3399
3400 static void test_WSASendTo(void)
3401 {
3402     SOCKET s;
3403     struct sockaddr_in addr;
3404     char buf[12] = "hello world";
3405     WSABUF data_buf;
3406     DWORD bytesSent;
3407
3408     addr.sin_family = AF_INET;
3409     addr.sin_port = htons(139);
3410     addr.sin_addr.s_addr = inet_addr("127.0.0.1");
3411     data_buf.len = sizeof(buf);
3412     data_buf.buf = buf;
3413
3414     if( (s = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
3415         ok(0, "socket() failed error: %d\n", WSAGetLastError());
3416         return;
3417     }
3418
3419     WSASetLastError(12345);
3420     if(WSASendTo(s, &data_buf, 1, &bytesSent, 0, (struct sockaddr*)&addr, sizeof(addr), NULL, NULL)) {
3421         ok(0, "WSASendTo() failed error: %d\n", WSAGetLastError());
3422         return;
3423     }
3424     ok(!WSAGetLastError(), "WSAGetLastError() should return zero after "
3425             "a successful call to WSASendTo()\n");
3426 }
3427
3428 static void test_WSARecv(void)
3429 {
3430     SOCKET src, dest;
3431     char buf[20];
3432     WSABUF bufs;
3433     WSAOVERLAPPED ov;
3434     DWORD bytesReturned;
3435     DWORD flags;
3436     struct linger ling;
3437     int iret;
3438     DWORD dwret;
3439     BOOL bret;
3440
3441     tcp_socketpair(&src, &dest);
3442     if (src == INVALID_SOCKET || dest == INVALID_SOCKET)
3443     {
3444         skip("failed to create sockets\n");
3445         goto end;
3446     }
3447
3448     bufs.len = sizeof(buf);
3449     bufs.buf = buf;
3450     flags = 0;
3451
3452     memset(&ov, 0, sizeof(ov));
3453     ov.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
3454     ok(ov.hEvent != NULL, "could not create event object, errno = %d\n", GetLastError());
3455     if (!ov.hEvent)
3456         goto end;
3457
3458     ling.l_onoff = 1;
3459     ling.l_linger = 0;
3460     ok(!setsockopt (src, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling)), "Failed to set linger %d\n", GetLastError());
3461
3462     iret = WSARecv(dest, &bufs, 1, &bytesReturned, &flags, &ov, NULL);
3463     ok(iret == SOCKET_ERROR && GetLastError() == ERROR_IO_PENDING, "WSARecv failed - %d error %d\n", iret, GetLastError());
3464
3465     closesocket(src);
3466     src = INVALID_SOCKET;
3467
3468     dwret = WaitForSingleObject(ov.hEvent, 1000);
3469     ok(dwret == WAIT_OBJECT_0, "Waiting for disconnect event failed with %d + errno %d\n", dwret, GetLastError());
3470
3471     bret = GetOverlappedResult((HANDLE)dest, &ov, &bytesReturned, FALSE);
3472     todo_wine ok(!bret && (GetLastError() == ERROR_NETNAME_DELETED || broken(GetLastError() == ERROR_IO_INCOMPLETE) /* win9x */),
3473         "Did not get disconnect event: %d, error %d\n", bret, GetLastError());
3474     ok(bytesReturned == 0, "Bytes received is %d\n", bytesReturned);
3475
3476 end:
3477     if (dest != INVALID_SOCKET)
3478         closesocket(dest);
3479     if (src != INVALID_SOCKET)
3480         closesocket(src);
3481     if (ov.hEvent)
3482         WSACloseEvent(ov.hEvent);
3483 }
3484
3485 static void test_GetAddrInfoW(void)
3486 {
3487     static const WCHAR port[] = {'8','0',0};
3488     static const WCHAR empty[] = {0};
3489     static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
3490
3491     int ret;
3492     ADDRINFOW *result, hint;
3493
3494     if (!pGetAddrInfoW || !pFreeAddrInfoW)
3495     {
3496         win_skip("GetAddrInfoW and/or FreeAddrInfoW not present\n");
3497         return;
3498     }
3499
3500     memset(&hint, 0, sizeof(ADDRINFOW));
3501
3502     ret = pGetAddrInfoW(NULL, NULL, NULL, &result);
3503     ok(ret == WSAHOST_NOT_FOUND, "got %d expected WSAHOST_NOT_FOUND\n", ret);
3504
3505     result = NULL;
3506     ret = pGetAddrInfoW(empty, NULL, NULL, &result);
3507     todo_wine
3508     {
3509     ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3510     ok(result != NULL, "GetAddrInfoW failed\n");
3511     }
3512     pFreeAddrInfoW(result);
3513
3514     ret = pGetAddrInfoW(localhost, NULL, NULL, &result);
3515     ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3516     pFreeAddrInfoW(result);
3517
3518     ret = pGetAddrInfoW(localhost, port, NULL, &result);
3519     ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3520     pFreeAddrInfoW(result);
3521
3522     ret = pGetAddrInfoW(localhost, port, &hint, &result);
3523     ok(!ret, "GetAddrInfoW failed with %d\n", WSAGetLastError());
3524     pFreeAddrInfoW(result);
3525 }
3526
3527 static void test_AcceptEx(void)
3528 {
3529     SOCKET listener = INVALID_SOCKET;
3530     SOCKET acceptor = INVALID_SOCKET;
3531     SOCKET connector = INVALID_SOCKET;
3532     SOCKET connector2 = INVALID_SOCKET;
3533     struct sockaddr_in bindAddress;
3534     int socklen;
3535     GUID acceptExGuid = WSAID_ACCEPTEX;
3536     LPFN_ACCEPTEX pAcceptEx = NULL;
3537     fd_set fds_accept, fds_send;
3538     struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
3539     int got, conn1, i;
3540     DWORD bytesReturned;
3541     char buffer[1024];
3542     OVERLAPPED overlapped;
3543     int iret;
3544     BOOL bret;
3545     DWORD dwret;
3546
3547     memset(&overlapped, 0, sizeof(overlapped));
3548
3549     listener = socket(AF_INET, SOCK_STREAM, 0);
3550     if (listener == INVALID_SOCKET) {
3551         skip("could not create listener socket, error %d\n", WSAGetLastError());
3552         goto end;
3553     }
3554
3555     acceptor = socket(AF_INET, SOCK_STREAM, 0);
3556     if (acceptor == INVALID_SOCKET) {
3557         skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3558         goto end;
3559     }
3560
3561     connector = socket(AF_INET, SOCK_STREAM, 0);
3562     if (connector == INVALID_SOCKET) {
3563         skip("could not create connector socket, error %d\n", WSAGetLastError());
3564         goto end;
3565     }
3566
3567     memset(&bindAddress, 0, sizeof(bindAddress));
3568     bindAddress.sin_family = AF_INET;
3569     bindAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
3570     iret = bind(listener, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3571     if (iret != 0) {
3572         skip("failed to bind, error %d\n", WSAGetLastError());
3573         goto end;
3574     }
3575
3576     socklen = sizeof(bindAddress);
3577     iret = getsockname(listener, (struct sockaddr*)&bindAddress, &socklen);
3578     if (iret != 0) {
3579         skip("failed to lookup bind address, error %d\n", WSAGetLastError());
3580         goto end;
3581     }
3582
3583     if (set_blocking(listener, FALSE)) {
3584         skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
3585         goto end;
3586     }
3587
3588     iret = WSAIoctl(listener, SIO_GET_EXTENSION_FUNCTION_POINTER, &acceptExGuid, sizeof(acceptExGuid),
3589         &pAcceptEx, sizeof(pAcceptEx), &bytesReturned, NULL, NULL);
3590     if (iret) {
3591         skip("WSAIoctl failed to get AcceptEx with ret %d + errno %d\n", iret, WSAGetLastError());
3592         goto end;
3593     }
3594
3595     bret = pAcceptEx(INVALID_SOCKET, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3596         sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3597         &bytesReturned, &overlapped);
3598     ok(bret == FALSE && WSAGetLastError() == WSAENOTSOCK, "AcceptEx on invalid listening socket "
3599         "returned %d + errno %d\n", bret, WSAGetLastError());
3600
3601     bret = pAcceptEx(listener, INVALID_SOCKET, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3602         sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3603         &bytesReturned, &overlapped);
3604     ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on invalid accepting socket "
3605         "returned %d + errno %d\n", bret, WSAGetLastError());
3606
3607     bret = pAcceptEx(listener, acceptor, NULL, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3608         sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3609         &bytesReturned, &overlapped);
3610     ok(bret == FALSE &&
3611         (WSAGetLastError() == WSAEINVAL ||
3612          broken(WSAGetLastError() == WSAEFAULT)), /* NT4 */
3613         "AcceptEx on NULL buffer returned %d + errno %d\n", bret, WSAGetLastError());
3614
3615     bret = pAcceptEx(listener, acceptor, buffer, 0, 0, sizeof(struct sockaddr_in) + 16,
3616         &bytesReturned, &overlapped);
3617     ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on too small local address size "
3618         "returned %d + errno %d\n", bret, WSAGetLastError());
3619
3620     bret = pAcceptEx(listener, acceptor, buffer, 0, sizeof(struct sockaddr_in) + 16, 0,
3621         &bytesReturned, &overlapped);
3622     ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on too small remote address size "
3623         "returned %d + errno %d\n", bret, WSAGetLastError());
3624
3625     bret = pAcceptEx(listener, acceptor, buffer, 0,
3626         sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3627         &bytesReturned, NULL);
3628     ok(bret == FALSE && WSAGetLastError() == ERROR_INVALID_PARAMETER, "AcceptEx on a NULL overlapped "
3629         "returned %d + errno %d\n", bret, WSAGetLastError());
3630
3631     bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3632         sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3633         &bytesReturned, &overlapped);
3634     ok(bret == FALSE && WSAGetLastError() == WSAEINVAL, "AcceptEx on a non-listening socket "
3635         "returned %d + errno %d\n", bret, WSAGetLastError());
3636
3637     iret = listen(listener, 5);
3638     if (iret != 0) {
3639         skip("listening failed, errno = %d\n", WSAGetLastError());
3640         goto end;
3641     }
3642
3643     overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
3644     if (overlapped.hEvent == NULL) {
3645         skip("could not create event object, errno = %d\n", GetLastError());
3646         goto end;
3647     }
3648
3649     bret = pAcceptEx(listener, acceptor, buffer, 0,
3650         sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3651         &bytesReturned, &overlapped);
3652     ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3653
3654     bret = pAcceptEx(listener, acceptor, buffer, 0,
3655         sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3656         &bytesReturned, &overlapped);
3657     ok((bret == FALSE && WSAGetLastError() == WSAEINVAL) || broken(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) /* NT4 */,
3658        "AcceptEx on already pending socket returned %d + errno %d\n", bret, WSAGetLastError());
3659     if (bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING) {
3660         /* We need to cancel this call, otherwise things fail */
3661         bret = CancelIo((HANDLE) listener);
3662         ok(bret, "Failed to cancel failed test. Bailing...\n");
3663         if (!bret) return;
3664
3665         bret = pAcceptEx(listener, acceptor, buffer, 0,
3666             sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3667             &bytesReturned, &overlapped);
3668         ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3669     }
3670
3671     iret = connect(acceptor,  (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3672     ok((iret == SOCKET_ERROR && WSAGetLastError() == WSAEINVAL) || broken(!iret) /* NT4 */,
3673        "connecting to acceptex acceptor succeeded? return %d + errno %d\n", iret, WSAGetLastError());
3674     if (!iret || (iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)) {
3675         /* We need to cancel this call, otherwise things fail */
3676         closesocket(acceptor);
3677         acceptor = socket(AF_INET, SOCK_STREAM, 0);
3678         if (acceptor == INVALID_SOCKET) {
3679             skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3680             goto end;
3681         }
3682
3683         bret = CancelIo((HANDLE) listener);
3684         ok(bret, "Failed to cancel failed test. Bailing...\n");
3685         if (!bret) return;
3686
3687         bret = pAcceptEx(listener, acceptor, buffer, 0,
3688             sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3689             &bytesReturned, &overlapped);
3690         ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3691     }
3692
3693     iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3694     ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
3695
3696     dwret = WaitForSingleObject(overlapped.hEvent, INFINITE);
3697     ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
3698
3699     bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
3700     ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
3701     ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
3702
3703     closesocket(connector);
3704     connector = INVALID_SOCKET;
3705     closesocket(acceptor);
3706     acceptor = INVALID_SOCKET;
3707
3708     /* Test short reads */
3709
3710     acceptor = socket(AF_INET, SOCK_STREAM, 0);
3711     if (acceptor == INVALID_SOCKET) {
3712         skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3713         goto end;
3714     }
3715     connector = socket(AF_INET, SOCK_STREAM, 0);
3716     if (connector == INVALID_SOCKET) {
3717         skip("could not create connector socket, error %d\n", WSAGetLastError());
3718         goto end;
3719     }
3720     bret = pAcceptEx(listener, acceptor, buffer, 2,
3721         sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3722         &bytesReturned, &overlapped);
3723     ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3724
3725     iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3726     ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
3727
3728     dwret = WaitForSingleObject(overlapped.hEvent, 0);
3729     ok(dwret == WAIT_TIMEOUT, "Waiting for accept event timeout failed with %d + errno %d\n", dwret, GetLastError());
3730
3731     iret = send(connector, buffer, 1, 0);
3732     ok(iret == 1, "could not send 1 byte: send %d errno %d\n", iret, WSAGetLastError());
3733
3734     dwret = WaitForSingleObject(overlapped.hEvent, 1000);
3735     ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
3736
3737     bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
3738     ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
3739     ok(bytesReturned == 1, "bytesReturned isn't supposed to be %d\n", bytesReturned);
3740
3741     closesocket(connector);
3742     connector = INVALID_SOCKET;
3743     closesocket(acceptor);
3744     acceptor = INVALID_SOCKET;
3745
3746     /* Test CF_DEFER & AcceptEx interaction */
3747
3748     acceptor = socket(AF_INET, SOCK_STREAM, 0);
3749     if (acceptor == INVALID_SOCKET) {
3750         skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3751         goto end;
3752     }
3753     connector = socket(AF_INET, SOCK_STREAM, 0);
3754     if (connector == INVALID_SOCKET) {
3755         skip("could not create connector socket, error %d\n", WSAGetLastError());
3756         goto end;
3757     }
3758     connector2 = socket(AF_INET, SOCK_STREAM, 0);
3759     if (connector == INVALID_SOCKET) {
3760         skip("could not create connector socket, error %d\n", WSAGetLastError());
3761         goto end;
3762     }
3763
3764     if (set_blocking(connector, FALSE)) {
3765         skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
3766         goto end;
3767     }
3768
3769     if (set_blocking(connector2, FALSE)) {
3770         skip("couldn't make socket non-blocking, error %d\n", WSAGetLastError());
3771         goto end;
3772     }
3773
3774     /* Connect socket #1 */
3775     iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3776     ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
3777
3778     FD_ZERO ( &fds_accept );
3779     FD_ZERO ( &fds_send );
3780
3781     FD_SET ( listener, &fds_accept );
3782     FD_SET ( connector, &fds_send );
3783
3784     buffer[0] = '0';
3785     got = 0;
3786     conn1 = 0;
3787
3788     for (i = 0; i < 4000; ++i)
3789     {
3790         fd_set fds_openaccept = fds_accept, fds_opensend = fds_send;
3791
3792         wsa_ok ( ( select ( 0, &fds_openaccept, &fds_opensend, NULL, &timeout ) ), SOCKET_ERROR !=,
3793             "acceptex test(%d): could not select on socket, errno %d\n" );
3794
3795         /* check for incoming requests */
3796         if ( FD_ISSET ( listener, &fds_openaccept ) ) {
3797             got++;
3798             if (got == 1) {
3799                 SOCKET tmp = WSAAccept(listener, NULL, NULL, (LPCONDITIONPROC) AlwaysDeferConditionFunc, 0);
3800                 ok(tmp == INVALID_SOCKET && WSAGetLastError() == WSATRY_AGAIN, "Failed to defer connection, %d\n", WSAGetLastError());
3801                 bret = pAcceptEx(listener, acceptor, buffer, 0,
3802                                     sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3803                                     &bytesReturned, &overlapped);
3804                 ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3805             }
3806             else if (got == 2) {
3807                 /* this should be socket #2 */
3808                 SOCKET tmp = accept(listener, NULL, NULL);
3809                 ok(tmp != INVALID_SOCKET, "accept failed %d\n", WSAGetLastError());
3810                 closesocket(tmp);
3811             }
3812             else {
3813                 ok(FALSE, "Got more than 2 connections?\n");
3814             }
3815         }
3816         if ( conn1 && FD_ISSET ( connector2, &fds_opensend ) ) {
3817             /* Send data on second socket, and stop */
3818             send(connector2, "2", 1, 0);
3819             FD_CLR ( connector2, &fds_send );
3820
3821             break;
3822         }
3823         if ( FD_ISSET ( connector, &fds_opensend ) ) {
3824             /* Once #1 is connected, allow #2 to connect */
3825             conn1 = 1;
3826
3827             send(connector, "1", 1, 0);
3828             FD_CLR ( connector, &fds_send );
3829
3830             iret = connect(connector2, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3831             ok(iret == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
3832             FD_SET ( connector2, &fds_send );
3833         }
3834     }
3835
3836     ok (got == 2 || broken(got == 1) /* NT4 */,
3837             "Did not get both connections, got %d\n", got);
3838
3839     dwret = WaitForSingleObject(overlapped.hEvent, 0);
3840     ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
3841
3842     bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
3843     ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
3844     ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
3845
3846     set_blocking(acceptor, TRUE);
3847     iret = recv( acceptor, buffer, 2, 0);
3848     ok(iret == 1, "Failed to get data, %d, errno: %d\n", iret, WSAGetLastError());
3849
3850     ok(buffer[0] == '1', "The wrong first client was accepted by acceptex: %c != 1\n", buffer[0]);
3851
3852     closesocket(connector);
3853     connector = INVALID_SOCKET;
3854     closesocket(acceptor);
3855     acceptor = INVALID_SOCKET;
3856
3857     /* clean up in case of failures */
3858     while ((acceptor = accept(listener, NULL, NULL)) != INVALID_SOCKET)
3859         closesocket(acceptor);
3860
3861     /* Disconnect during receive? */
3862
3863     acceptor = socket(AF_INET, SOCK_STREAM, 0);
3864     if (acceptor == INVALID_SOCKET) {
3865         skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3866         goto end;
3867     }
3868     connector = socket(AF_INET, SOCK_STREAM, 0);
3869     if (connector == INVALID_SOCKET) {
3870         skip("could not create connector socket, error %d\n", WSAGetLastError());
3871         goto end;
3872     }
3873     bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3874         sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3875         &bytesReturned, &overlapped);
3876     ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3877
3878     iret = connect(connector, (struct sockaddr*)&bindAddress, sizeof(bindAddress));
3879     ok(iret == 0, "connecting to accepting socket failed, error %d\n", WSAGetLastError());
3880
3881     closesocket(connector);
3882     connector = INVALID_SOCKET;
3883
3884     dwret = WaitForSingleObject(overlapped.hEvent, 1000);
3885     ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
3886
3887     bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
3888     ok(bret, "GetOverlappedResult failed, error %d\n", GetLastError());
3889     ok(bytesReturned == 0, "bytesReturned isn't supposed to be %d\n", bytesReturned);
3890
3891     closesocket(acceptor);
3892     acceptor = INVALID_SOCKET;
3893
3894     /* Test closing with pending requests */
3895
3896     acceptor = socket(AF_INET, SOCK_STREAM, 0);
3897     if (acceptor == INVALID_SOCKET) {
3898         skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3899         goto end;
3900     }
3901     bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3902         sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3903         &bytesReturned, &overlapped);
3904     ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3905
3906     closesocket(acceptor);
3907     acceptor = INVALID_SOCKET;
3908
3909     dwret = WaitForSingleObject(overlapped.hEvent, 1000);
3910     ok(dwret == WAIT_OBJECT_0 || broken(dwret == WAIT_TIMEOUT) /* NT4/2000 */,
3911        "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
3912
3913     if (dwret != WAIT_TIMEOUT) {
3914         bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
3915         ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
3916     }
3917     else {
3918         bret = CancelIo((HANDLE) listener);
3919         ok(bret, "Failed to cancel failed test. Bailing...\n");
3920         if (!bret) return;
3921     }
3922
3923     acceptor = socket(AF_INET, SOCK_STREAM, 0);
3924     if (acceptor == INVALID_SOCKET) {
3925         skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3926         goto end;
3927     }
3928     bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3929         sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3930         &bytesReturned, &overlapped);
3931     ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3932
3933     CancelIo((HANDLE) acceptor);
3934
3935     dwret = WaitForSingleObject(overlapped.hEvent, 1000);
3936     ok(dwret == WAIT_TIMEOUT, "Waiting for timeout failed with %d + errno %d\n", dwret, GetLastError());
3937
3938     closesocket(acceptor);
3939     acceptor = INVALID_SOCKET;
3940
3941     acceptor = socket(AF_INET, SOCK_STREAM, 0);
3942     if (acceptor == INVALID_SOCKET) {
3943         skip("could not create acceptor socket, error %d\n", WSAGetLastError());
3944         goto end;
3945     }
3946     bret = pAcceptEx(listener, acceptor, buffer, sizeof(buffer) - 2*(sizeof(struct sockaddr_in) + 16),
3947         sizeof(struct sockaddr_in) + 16, sizeof(struct sockaddr_in) + 16,
3948         &bytesReturned, &overlapped);
3949     ok(bret == FALSE && WSAGetLastError() == ERROR_IO_PENDING, "AcceptEx returned %d + errno %d\n", bret, WSAGetLastError());
3950
3951     closesocket(listener);
3952     listener = INVALID_SOCKET;
3953
3954     dwret = WaitForSingleObject(overlapped.hEvent, 1000);
3955     ok(dwret == WAIT_OBJECT_0, "Waiting for accept event failed with %d + errno %d\n", dwret, GetLastError());
3956
3957     bret = GetOverlappedResult((HANDLE)listener, &overlapped, &bytesReturned, FALSE);
3958     ok(!bret && GetLastError() == ERROR_OPERATION_ABORTED, "GetOverlappedResult failed, error %d\n", GetLastError());
3959
3960 end:
3961     if (overlapped.hEvent)
3962         WSACloseEvent(overlapped.hEvent);
3963     if (listener != INVALID_SOCKET)
3964         closesocket(listener);
3965     if (acceptor != INVALID_SOCKET)
3966         closesocket(acceptor);
3967     if (connector != INVALID_SOCKET)
3968         closesocket(connector);
3969     if (connector2 != INVALID_SOCKET)
3970         closesocket(connector2);
3971 }
3972
3973 static void test_getpeername(void)
3974 {
3975     SOCKET sock;
3976     struct sockaddr_in sa, sa_out;
3977     int sa_len;
3978     const char buf[] = "hello world";
3979     int ret;
3980
3981     /* Test the parameter validation order. */
3982     ret = getpeername(INVALID_SOCKET, NULL, NULL);
3983     ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
3984     ok(WSAGetLastError() == WSAENOTSOCK,
3985        "Expected WSAGetLastError() to return WSAENOTSOCK, got %d\n", WSAGetLastError());
3986
3987     sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
3988     ok(sock != INVALID_SOCKET, "Expected socket to return a valid socket\n");
3989     if (sock == INVALID_SOCKET)
3990     {
3991         skip("Socket creation failed with %d\n", WSAGetLastError());
3992         return;
3993     }
3994
3995     ret = getpeername(sock, NULL, NULL);
3996     ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
3997     ok(WSAGetLastError() == WSAENOTCONN ||
3998        broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
3999        "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
4000
4001     memset(&sa, 0, sizeof(sa));
4002     sa.sin_family = AF_INET;
4003     sa.sin_port = htons(139);
4004     sa.sin_addr.s_addr = inet_addr("127.0.0.1");
4005
4006     /* sendto does not change a socket's connection state. */
4007     ret = sendto(sock, buf, sizeof(buf), 0, (struct sockaddr*)&sa, sizeof(sa));
4008     ok(ret != SOCKET_ERROR,
4009        "Expected sendto to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
4010
4011     ret = getpeername(sock, NULL, NULL);
4012     ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
4013     ok(WSAGetLastError() == WSAENOTCONN ||
4014        broken(WSAGetLastError() == WSAEFAULT), /* Win9x and WinMe */
4015        "Expected WSAGetLastError() to return WSAENOTCONN, got %d\n", WSAGetLastError());
4016
4017     ret = connect(sock, (struct sockaddr*)&sa, sizeof(sa));
4018     ok(ret == 0,
4019        "Expected connect to succeed, WSAGetLastError() = %d\n", WSAGetLastError());
4020
4021     ret = getpeername(sock, NULL, NULL);
4022     ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
4023     ok(WSAGetLastError() == WSAEFAULT,
4024        "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
4025
4026     /* Test crashes on Wine. */
4027     if (0)
4028     {
4029         ret = getpeername(sock, (void*)0xdeadbeef, (void*)0xcafebabe);
4030         ok(ret == SOCKET_ERROR, "Expected getpeername to return SOCKET_ERROR, got %d\n", ret);
4031         ok(WSAGetLastError() == WSAEFAULT,
4032            "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
4033     }
4034
4035     sa_len = 0;
4036     ret = getpeername(sock, (struct sockaddr*)&sa_out, &sa_len);
4037     ok(ret == SOCKET_ERROR, "Expected getpeername to return 0, got %d\n", ret);
4038     ok(WSAGetLastError() == WSAEFAULT,
4039        "Expected WSAGetLastError() to return WSAEFAULT, got %d\n", WSAGetLastError());
4040
4041     sa_len = sizeof(sa_out);
4042     ret = getpeername(sock, (struct sockaddr*)&sa_out, &sa_len);
4043     ok(ret == 0, "Expected getpeername to return 0, got %d\n", ret);
4044     ok(!memcmp(&sa, &sa_out, sizeof(sa)),
4045        "Expected the returned structure to be identical to the connect structure\n");
4046
4047     closesocket(sock);
4048 }
4049
4050 /**************** Main program  ***************/
4051
4052 START_TEST( sock )
4053 {
4054     int i;
4055
4056 /* Leave these tests at the beginning. They depend on WSAStartup not having been
4057  * called, which is done by Init() below. */
4058     test_WithoutWSAStartup();
4059     test_WithWSAStartup();
4060
4061     Init();
4062
4063     test_set_getsockopt();
4064     test_so_reuseaddr();
4065     test_extendedSocketOptions();
4066
4067     for (i = 0; i < NUM_TESTS; i++)
4068     {
4069         trace ( " **** STARTING TEST %d ****\n", i );
4070         do_test (  &tests[i] );
4071         trace ( " **** TEST %d COMPLETE ****\n", i );
4072     }
4073
4074     test_UDP();
4075
4076     test_getservbyname();
4077     test_WSASocket();
4078
4079     test_WSAAddressToStringA();
4080     test_WSAAddressToStringW();
4081
4082     test_WSAStringToAddressA();
4083     test_WSAStringToAddressW();
4084
4085     test_select();
4086     test_accept();
4087     test_getpeername();
4088     test_getsockname();
4089     test_inet_addr();
4090     test_addr_to_print();
4091     test_ioctlsocket();
4092     test_dns();
4093     test_gethostbyname_hack();
4094
4095     test_WSASendTo();
4096     test_WSARecv();
4097
4098     test_events(0);
4099     test_events(1);
4100
4101     test_ipv6only();
4102     test_GetAddrInfoW();
4103
4104     test_AcceptEx();
4105
4106     /* this is a io heavy test, do it at the end so the kernel doesn't start dropping packets */
4107     test_send();
4108
4109     Exit();
4110 }