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

   1 /*
   2  * Unit test suite for winsock functions
   3  *
   4  * Copyright 2002 Martin Wilck
   5  * Copyright 2005 Thomas Kho
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #include <windef.h>
  25 #include <winbase.h>
  26 #include <winsock2.h>
  27 #include <mswsock.h>
  28 #include "wine/test.h"
  29 #include <winnt.h>
  30 #include <winerror.h>
  31
  32 #define MAX_CLIENTS 4      /* Max number of clients */
  33 #define NUM_TESTS   3      /* Number of tests performed */
  34 #define FIRST_CHAR 'A'     /* First character in transferred pattern */
  35 #define BIND_SLEEP 10      /* seconds to wait between attempts to bind() */
  36 #define BIND_TRIES 6       /* Number of bind() attempts */
  37 #define TEST_TIMEOUT 30    /* seconds to wait before killing child threads
  38                               after server initialization, if something hangs */
  39
  40 #define NUM_UDP_PEERS 3    /* Number of UDP sockets to create and test > 1 */
  41
  42 #define NUM_THREADS 3      /* Number of threads to run getservbyname */
  43 #define NUM_QUERIES 250    /* Number of getservbyname queries per thread */
  44
  45 #define SERVERIP "127.0.0.1"   /* IP to bind to */
  46 #define SERVERPORT 9374        /* Port number to bind to */
  47
  48 #define wsa_ok(op, cond, msg) \
  49    do { \
  50         int tmp, err = 0; \
  51         tmp = op; \
  52         if ( !(cond tmp) ) err = WSAGetLastError(); \
  53         ok ( cond tmp, msg, GetCurrentThreadId(), err); \
  54    } while (0);
  55
  56
  57 /**************** Structs and typedefs ***************/
  58
  59 typedef struct thread_info
  60 {
  61     HANDLE thread;
  62     DWORD id;
  63 } thread_info;
  64
  65 /* Information in the server about open client connections */
  66 typedef struct sock_info
  67 {
  68     SOCKET                 s;
  69     struct sockaddr_in     addr;
  70     struct sockaddr_in     peer;
  71     char                  *buf;
  72     int                    n_recvd;
  73     int                    n_sent;
  74 } sock_info;
  75
  76 /* Test parameters for both server & client */
  77 typedef struct test_params
  78 {
  79     int          sock_type;
  80     int          sock_prot;
  81     const char  *inet_addr;
  82     short        inet_port;
  83     int          chunk_size;
  84     int          n_chunks;
  85     int          n_clients;
  86 } test_params;
  87
  88 /* server-specific test parameters */
  89 typedef struct server_params
  90 {
  91     test_params   *general;
  92     DWORD          sock_flags;
  93     int            buflen;
  94 } server_params;
  95
  96 /* client-specific test parameters */
  97 typedef struct client_params
  98 {
  99     test_params   *general;
 100     DWORD          sock_flags;
 101     int            buflen;
 102 } client_params;
 103
 104 /* This type combines all information for setting up a test scenario */
 105 typedef struct test_setup
 106 {
 107     test_params              general;
 108     LPVOID                   srv;
 109     server_params            srv_params;
 110     LPVOID                   clt;
 111     client_params            clt_params;
 112 } test_setup;
 113
 114 /* Thread local storage for server */
 115 typedef struct server_memory
 116 {
 117     SOCKET                  s;
 118     struct sockaddr_in      addr;
 119     sock_info               sock[MAX_CLIENTS];
 120 } server_memory;
 121
 122 /* Thread local storage for client */
 123 typedef struct client_memory
 124 {
 125     SOCKET s;
 126     struct sockaddr_in      addr;
 127     char                   *send_buf;
 128     char                   *recv_buf;
 129 } client_memory;
 130
 131 /**************** Static variables ***************/
 132
 133 static DWORD      tls;              /* Thread local storage index */
 134 static HANDLE     thread[1+MAX_CLIENTS];
 135 static DWORD      thread_id[1+MAX_CLIENTS];
 136 static HANDLE     server_ready;
 137 static HANDLE     client_ready[MAX_CLIENTS];
 138 static int        client_id;
 139
 140 /**************** General utility functions ***************/
 141
 142 static void set_so_opentype ( BOOL overlapped )
 143 {
 144     int optval = !overlapped, newval, len = sizeof (int);
 145
 146     ok ( setsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
 147                       (LPVOID) &optval, sizeof (optval) ) == 0,
 148          "setting SO_OPENTYPE failed\n" );
 149     ok ( getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
 150                       (LPVOID) &newval, &len ) == 0,
 151          "getting SO_OPENTYPE failed\n" );
 152     ok ( optval == newval, "failed to set SO_OPENTYPE\n" );
 153 }
 154
 155 static int set_blocking ( SOCKET s, BOOL blocking )
 156 {
 157     u_long val = !blocking;
 158     return ioctlsocket ( s, FIONBIO, &val );
 159 }
 160
 161 static void fill_buffer ( char *buf, int chunk_size, int n_chunks )
 162 {
 163     char c, *p;
 164     for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
 165         memset ( p, c, chunk_size );
 166 }
 167
 168 static char* test_buffer ( char *buf, int chunk_size, int n_chunks )
 169 {
 170     char c, *p;
 171     int i;
 172     for ( c = FIRST_CHAR, p = buf; c < FIRST_CHAR + n_chunks; c++, p += chunk_size )
 173     {
 174         for ( i = 0; i < chunk_size; i++ )
 175             if ( p[i] != c ) return p + i;
 176     }
 177     return NULL;
 178 }
 179
 180 /*
 181  * This routine is called when a client / server does not expect any more data,
 182  * but needs to acknowedge the closing of the connection (by reasing 0 bytes).
 183  */
 184 static void read_zero_bytes ( SOCKET s )
 185 {
 186     char buf[256];
 187     int tmp, n = 0;
 188     while ( ( tmp = recv ( s, buf, 256, 0 ) ) > 0 )
 189         n += tmp;
 190     ok ( n <= 0, "garbage data received: %d bytes\n", n );
 191 }
 192
 193 static int do_synchronous_send ( SOCKET s, char *buf, int buflen, int sendlen )
 194 {
 195     char* last = buf + buflen, *p;
 196     int n = 1;
 197     for ( p = buf; n > 0 && p < last; p += n )
 198         n = send ( s, p, min ( sendlen, last - p ), 0 );
 199     wsa_ok ( n, 0 <=, "do_synchronous_send (%lx): error %d\n" );
 200     return p - buf;
 201 }
 202
 203 static int do_synchronous_recv ( SOCKET s, char *buf, int buflen, int recvlen )
 204 {
 205     char* last = buf + buflen, *p;
 206     int n = 1;
 207     for ( p = buf; n > 0 && p < last; p += n )
 208         n = recv ( s, p, min ( recvlen, last - p ), 0 );
 209     wsa_ok ( n, 0 <=, "do_synchronous_recv (%lx): error %d:\n" );
 210     return p - buf;
 211 }
 212
 213 /*
 214  *  Call this routine right after thread startup.
 215  *  SO_OPENTYPE must by 0, regardless what the server did.
 216  */
 217 static void check_so_opentype (void)
 218 {
 219     int tmp = 1, len;
 220     len = sizeof (tmp);
 221     getsockopt ( INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (LPVOID) &tmp, &len );
 222     ok ( tmp == 0, "check_so_opentype: wrong startup value of SO_OPENTYPE: %d\n", tmp );
 223 }
 224
 225 /**************** Server utility functions ***************/
 226
 227 /*
 228  *  Even if we have closed our server socket cleanly,
 229  *  the OS may mark the address "in use" for some time -
 230  *  this happens with native Linux apps, too.
 231  */
 232 static void do_bind ( SOCKET s, struct sockaddr* addr, int addrlen )
 233 {
 234     int err, wsaerr = 0, n_try = BIND_TRIES;
 235
 236     while ( ( err = bind ( s, addr, addrlen ) ) != 0 &&
 237             ( wsaerr = WSAGetLastError () ) == WSAEADDRINUSE &&
 238             n_try-- >= 0)
 239     {
 240         trace ( "address in use, waiting ...\n" );
 241         Sleep ( 1000 * BIND_SLEEP );
 242     }
 243     ok ( err == 0, "failed to bind: %d\n", wsaerr );
 244 }
 245
 246 static void server_start ( server_params *par )
 247 {
 248     int i;
 249     test_params *gen = par->general;
 250     server_memory *mem = (LPVOID) LocalAlloc ( LPTR, sizeof (server_memory));
 251
 252     TlsSetValue ( tls, mem );
 253     mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
 254                           NULL, 0, par->sock_flags );
 255     ok ( mem->s != INVALID_SOCKET, "Server: WSASocket failed\n" );
 256
 257     mem->addr.sin_family = AF_INET;
 258     mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
 259     mem->addr.sin_port = htons ( gen->inet_port );
 260
 261     for (i = 0; i < MAX_CLIENTS; i++)
 262     {
 263         mem->sock[i].s = INVALID_SOCKET;
 264         mem->sock[i].buf = (LPVOID) LocalAlloc ( LPTR, gen->n_chunks * gen->chunk_size );
 265         mem->sock[i].n_recvd = 0;
 266         mem->sock[i].n_sent = 0;
 267     }
 268
 269     if ( gen->sock_type == SOCK_STREAM )
 270         do_bind ( mem->s, (struct sockaddr*) &mem->addr, sizeof (mem->addr) );
 271 }
 272
 273 static void server_stop (void)
 274 {
 275     int i;
 276     server_memory *mem = TlsGetValue ( tls );
 277
 278     for (i = 0; i < MAX_CLIENTS; i++ )
 279     {
 280         LocalFree ( (HANDLE) mem->sock[i].buf );
 281         if ( mem->sock[i].s != INVALID_SOCKET )
 282             closesocket ( mem->sock[i].s );
 283     }
 284     ok ( closesocket ( mem->s ) == 0, "closesocket failed\n" );
 285     LocalFree ( (HANDLE) mem );
 286     ExitThread ( GetCurrentThreadId () );
 287 }
 288
 289 /**************** Client utilitiy functions ***************/
 290
 291 static void client_start ( client_params *par )
 292 {
 293     test_params *gen = par->general;
 294     client_memory *mem = (LPVOID) LocalAlloc (LPTR, sizeof (client_memory));
 295
 296     TlsSetValue ( tls, mem );
 297
 298     WaitForSingleObject ( server_ready, INFINITE );
 299
 300     mem->s = WSASocketA ( AF_INET, gen->sock_type, gen->sock_prot,
 301                           NULL, 0, par->sock_flags );
 302
 303     mem->addr.sin_family = AF_INET;
 304     mem->addr.sin_addr.s_addr = inet_addr ( gen->inet_addr );
 305     mem->addr.sin_port = htons ( gen->inet_port );
 306
 307     ok ( mem->s != INVALID_SOCKET, "Client: WSASocket failed\n" );
 308
 309     mem->send_buf = (LPVOID) LocalAlloc ( LPTR, 2 * gen->n_chunks * gen->chunk_size );
 310     mem->recv_buf = mem->send_buf + gen->n_chunks * gen->chunk_size;
 311     fill_buffer ( mem->send_buf, gen->chunk_size, gen->n_chunks );
 312
 313     SetEvent ( client_ready[client_id] );
 314     /* Wait for the other clients to come up */
 315     WaitForMultipleObjects ( min ( gen->n_clients, MAX_CLIENTS ), client_ready, TRUE, INFINITE );
 316 }
 317
 318 static void client_stop (void)
 319 {
 320     client_memory *mem = TlsGetValue ( tls );
 321     wsa_ok ( closesocket ( mem->s ), 0 ==, "closesocket error (%lx): %d\n" );
 322     LocalFree ( (HANDLE) mem->send_buf );
 323     LocalFree ( (HANDLE) mem );
 324     ExitThread(0);
 325 }
 326
 327 /**************** Servers ***************/
 328
 329 /*
 330  * simple_server: A very basic server doing synchronous IO.
 331  */
 332 static VOID WINAPI simple_server ( server_params *par )
 333 {
 334     test_params *gen = par->general;
 335     server_memory *mem;
 336     int n_recvd, n_sent, n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
 337         id = GetCurrentThreadId();
 338     char *p;
 339
 340     trace ( "simple_server (%x) starting\n", id );
 341
 342     set_so_opentype ( FALSE ); /* non-overlapped */
 343     server_start ( par );
 344     mem = TlsGetValue ( tls );
 345
 346     wsa_ok ( set_blocking ( mem->s, TRUE ), 0 ==, "simple_server (%lx): failed to set blocking mode: %d\n");
 347     wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "simple_server (%lx): listen failed: %d\n");
 348
 349     trace ( "simple_server (%x) ready\n", id );
 350     SetEvent ( server_ready ); /* notify clients */
 351
 352     for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
 353     {
 354         trace ( "simple_server (%x): waiting for client\n", id );
 355
 356         /* accept a single connection */
 357         tmp = sizeof ( mem->sock[0].peer );
 358         mem->sock[0].s = accept ( mem->s, (struct sockaddr*) &mem->sock[0].peer, &tmp );
 359         wsa_ok ( mem->sock[0].s, INVALID_SOCKET !=, "simple_server (%lx): accept failed: %d\n" );
 360
 361         ok ( mem->sock[0].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
 362              "simple_server (%x): strange peer address\n", id );
 363
 364         /* Receive data & check it */
 365         n_recvd = do_synchronous_recv ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
 366         ok ( n_recvd == n_expected,
 367              "simple_server (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
 368         p = test_buffer ( mem->sock[0].buf, gen->chunk_size, gen->n_chunks );
 369         ok ( p == NULL, "simple_server (%x): test pattern error: %d\n", id, p - mem->sock[0].buf);
 370
 371         /* Echo data back */
 372         n_sent = do_synchronous_send ( mem->sock[0].s, mem->sock[0].buf, n_expected, par->buflen );
 373         ok ( n_sent == n_expected,
 374              "simple_server (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
 375
 376         /* cleanup */
 377         read_zero_bytes ( mem->sock[0].s );
 378         wsa_ok ( closesocket ( mem->sock[0].s ),  0 ==, "simple_server (%lx): closesocket error: %d\n" );
 379         mem->sock[0].s = INVALID_SOCKET;
 380     }
 381
 382     trace ( "simple_server (%x) exiting\n", id );
 383     server_stop ();
 384 }
 385
 386 /*
 387  * select_server: A non-blocking server.
 388  */
 389 static VOID WINAPI select_server ( server_params *par )
 390 {
 391     test_params *gen = par->general;
 392     server_memory *mem;
 393     int n_expected = gen->n_chunks * gen->chunk_size, tmp, i,
 394         id = GetCurrentThreadId(), n_connections = 0, n_sent, n_recvd,
 395         n_set, delta, n_ready;
 396     char *p;
 397     struct timeval timeout = {0,10}; /* wait for 10 milliseconds */
 398     fd_set fds_recv, fds_send, fds_openrecv, fds_opensend;
 399
 400     trace ( "select_server (%x) starting\n", id );
 401
 402     set_so_opentype ( FALSE ); /* non-overlapped */
 403     server_start ( par );
 404     mem = TlsGetValue ( tls );
 405
 406     wsa_ok ( set_blocking ( mem->s, FALSE ), 0 ==, "select_server (%lx): failed to set blocking mode: %d\n");
 407     wsa_ok ( listen ( mem->s, SOMAXCONN ), 0 ==, "select_server (%lx): listen failed: %d\n");
 408
 409     trace ( "select_server (%x) ready\n", id );
 410     SetEvent ( server_ready ); /* notify clients */
 411
 412     FD_ZERO ( &fds_openrecv );
 413     FD_ZERO ( &fds_recv );
 414     FD_ZERO ( &fds_send );
 415     FD_ZERO ( &fds_opensend );
 416
 417     FD_SET ( mem->s, &fds_openrecv );
 418
 419     while(1)
 420     {
 421         fds_recv = fds_openrecv;
 422         fds_send = fds_opensend;
 423
 424         n_set = 0;
 425
 426         wsa_ok ( ( n_ready = select ( 0, &fds_recv, &fds_send, NULL, &timeout ) ), SOCKET_ERROR !=,
 427             "select_server (%lx): select() failed: %d\n" );
 428
 429         /* check for incoming requests */
 430         if ( FD_ISSET ( mem->s, &fds_recv ) ) {
 431             n_set += 1;
 432
 433             trace ( "select_server (%x): accepting client connection\n", id );
 434
 435             /* accept a single connection */
 436             tmp = sizeof ( mem->sock[n_connections].peer );
 437             mem->sock[n_connections].s = accept ( mem->s, (struct sockaddr*) &mem->sock[n_connections].peer, &tmp );
 438             wsa_ok ( mem->sock[n_connections].s, INVALID_SOCKET !=, "select_server (%lx): accept() failed: %d\n" );
 439
 440             ok ( mem->sock[n_connections].peer.sin_addr.s_addr == inet_addr ( gen->inet_addr ),
 441                 "select_server (%x): strange peer address\n", id );
 442
 443             /* add to list of open connections */
 444             FD_SET ( mem->sock[n_connections].s, &fds_openrecv );
 445             FD_SET ( mem->sock[n_connections].s, &fds_opensend );
 446
 447             n_connections++;
 448         }
 449
 450         /* handle open requests */
 451
 452         for ( i = 0; i < n_connections; i++ )
 453         {
 454             if ( FD_ISSET( mem->sock[i].s, &fds_recv ) ) {
 455                 n_set += 1;
 456
 457                 if ( mem->sock[i].n_recvd < n_expected ) {
 458                     /* Receive data & check it */
 459                     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 );
 460                     ok ( n_recvd != SOCKET_ERROR, "select_server (%x): error in recv(): %d\n", id, WSAGetLastError() );
 461                     mem->sock[i].n_recvd += n_recvd;
 462
 463                     if ( mem->sock[i].n_recvd == n_expected ) {
 464                         p = test_buffer ( mem->sock[i].buf, gen->chunk_size, gen->n_chunks );
 465                         ok ( p == NULL, "select_server (%x): test pattern error: %d\n", id, p - mem->sock[i].buf );
 466                         FD_CLR ( mem->sock[i].s, &fds_openrecv );
 467                     }
 468
 469                     ok ( mem->sock[i].n_recvd <= n_expected, "select_server (%x): received too many bytes: %d\n", id, mem->sock[i].n_recvd );
 470                 }
 471             }
 472
 473             /* only echo back what we've received */
 474             delta = mem->sock[i].n_recvd - mem->sock[i].n_sent;
 475
 476             if ( FD_ISSET ( mem->sock[i].s, &fds_send ) ) {
 477                 n_set += 1;
 478
 479                 if ( ( delta > 0 ) && ( mem->sock[i].n_sent < n_expected ) ) {
 480                     /* Echo data back */
 481                     n_sent = send ( mem->sock[i].s, mem->sock[i].buf + mem->sock[i].n_sent, min ( delta, par->buflen ), 0 );
 482                     ok ( n_sent != SOCKET_ERROR, "select_server (%x): error in send(): %d\n", id, WSAGetLastError() );
 483                     mem->sock[i].n_sent += n_sent;
 484
 485                     if ( mem->sock[i].n_sent == n_expected ) {
 486                         FD_CLR ( mem->sock[i].s, &fds_opensend );
 487                     }
 488
 489                     ok ( mem->sock[i].n_sent <= n_expected, "select_server (%x): sent too many bytes: %d\n", id, mem->sock[i].n_sent );
 490                 }
 491             }
 492         }
 493
 494         /* check that select returned the correct number of ready sockets */
 495         ok ( ( n_set == n_ready ), "select_server (%x): select() returns wrong number of ready sockets\n", id );
 496
 497         /* check if all clients are done */
 498         if ( ( fds_opensend.fd_count == 0 )
 499             && ( fds_openrecv.fd_count == 1 ) /* initial socket that accepts clients */
 500             && ( n_connections  == min ( gen->n_clients, MAX_CLIENTS ) ) ) {
 501             break;
 502         }
 503     }
 504
 505     for ( i = 0; i < min ( gen->n_clients, MAX_CLIENTS ); i++ )
 506     {
 507         /* cleanup */
 508         read_zero_bytes ( mem->sock[i].s );
 509         wsa_ok ( closesocket ( mem->sock[i].s ),  0 ==, "select_server (%lx): closesocket error: %d\n" );
 510         mem->sock[i].s = INVALID_SOCKET;
 511     }
 512
 513     trace ( "select_server (%x) exiting\n", id );
 514     server_stop ();
 515 }
 516
 517 /**************** Clients ***************/
 518
 519 /*
 520  * simple_client: A very basic client doing synchronous IO.
 521  */
 522 static VOID WINAPI simple_client ( client_params *par )
 523 {
 524     test_params *gen = par->general;
 525     client_memory *mem;
 526     int n_sent, n_recvd, n_expected = gen->n_chunks * gen->chunk_size, id;
 527     char *p;
 528
 529     id = GetCurrentThreadId();
 530     trace ( "simple_client (%x): starting\n", id );
 531     /* wait here because we want to call set_so_opentype before creating a socket */
 532     WaitForSingleObject ( server_ready, INFINITE );
 533     trace ( "simple_client (%x): server ready\n", id );
 534
 535     check_so_opentype ();
 536     set_so_opentype ( FALSE ); /* non-overlapped */
 537     client_start ( par );
 538     mem = TlsGetValue ( tls );
 539
 540     /* Connect */
 541     wsa_ok ( connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) ),
 542              0 ==, "simple_client (%lx): connect error: %d\n" );
 543     ok ( set_blocking ( mem->s, TRUE ) == 0,
 544          "simple_client (%x): failed to set blocking mode\n", id );
 545     trace ( "simple_client (%x) connected\n", id );
 546
 547     /* send data to server */
 548     n_sent = do_synchronous_send ( mem->s, mem->send_buf, n_expected, par->buflen );
 549     ok ( n_sent == n_expected,
 550          "simple_client (%x): sent less data than expected: %d of %d\n", id, n_sent, n_expected );
 551
 552     /* shutdown send direction */
 553     wsa_ok ( shutdown ( mem->s, SD_SEND ), 0 ==, "simple_client (%lx): shutdown failed: %d\n" );
 554
 555     /* Receive data echoed back & check it */
 556     n_recvd = do_synchronous_recv ( mem->s, mem->recv_buf, n_expected, par->buflen );
 557     ok ( n_recvd == n_expected,
 558          "simple_client (%x): received less data than expected: %d of %d\n", id, n_recvd, n_expected );
 559
 560     /* check data */
 561     p = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
 562     ok ( p == NULL, "simple_client (%x): test pattern error: %d\n", id, p - mem->recv_buf);
 563
 564     /* cleanup */
 565     read_zero_bytes ( mem->s );
 566     trace ( "simple_client (%x) exiting\n", id );
 567     client_stop ();
 568 }
 569
 570 /*
 571  * event_client: An event-driven client
 572  */
 573 static void WINAPI event_client ( client_params *par )
 574 {
 575     test_params *gen = par->general;
 576     client_memory *mem;
 577     int id = GetCurrentThreadId(), n_expected = gen->n_chunks * gen->chunk_size,
 578         tmp, err, n;
 579     HANDLE event;
 580     WSANETWORKEVENTS wsa_events;
 581     char *send_last, *recv_last, *send_p, *recv_p;
 582     long mask = FD_READ | FD_WRITE | FD_CLOSE;
 583
 584     trace ( "event_client (%x): starting\n", id );
 585     client_start ( par );
 586     trace ( "event_client (%x): server ready\n", id );
 587
 588     mem = TlsGetValue ( tls );
 589
 590     /* Prepare event notification for connect, makes socket nonblocking */
 591     event = WSACreateEvent ();
 592     WSAEventSelect ( mem->s, event, FD_CONNECT );
 593     tmp = connect ( mem->s, (struct sockaddr*) &mem->addr, sizeof ( mem->addr ) );
 594     if ( tmp != 0 && ( err = WSAGetLastError () ) != WSAEWOULDBLOCK )
 595         ok ( 0, "event_client (%x): connect error: %d\n", id, err );
 596
 597     tmp = WaitForSingleObject ( event, INFINITE );
 598     ok ( tmp == WAIT_OBJECT_0, "event_client (%x): wait for connect event failed: %d\n", id, tmp );
 599     err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
 600     wsa_ok ( err, 0 ==, "event_client (%lx): WSAEnumNetworkEvents error: %d\n" );
 601
 602     err = wsa_events.iErrorCode[ FD_CONNECT_BIT ];
 603     ok ( err == 0, "event_client (%x): connect error: %d\n", id, err );
 604     if ( err ) goto out;
 605
 606     trace ( "event_client (%x) connected\n", id );
 607
 608     WSAEventSelect ( mem->s, event, mask );
 609
 610     recv_p = mem->recv_buf;
 611     recv_last = mem->recv_buf + n_expected;
 612     send_p = mem->send_buf;
 613     send_last = mem->send_buf + n_expected;
 614
 615     while ( TRUE )
 616     {
 617         err = WaitForSingleObject ( event, INFINITE );
 618         ok ( err == WAIT_OBJECT_0, "event_client (%x): wait failed\n", id );
 619
 620         err = WSAEnumNetworkEvents ( mem->s, event, &wsa_events );
 621         wsa_ok ( err, 0 ==, "event_client (%lx): WSAEnumNetworkEvents error: %d\n" );
 622
 623         if ( wsa_events.lNetworkEvents & FD_WRITE )
 624         {
 625             err = wsa_events.iErrorCode[ FD_WRITE_BIT ];
 626             ok ( err == 0, "event_client (%x): FD_WRITE error code: %d\n", id, err );
 627
 628             if ( err== 0 )
 629                 do
 630                 {
 631                     n = send ( mem->s, send_p, min ( send_last - send_p, par->buflen ), 0 );
 632                     if ( n < 0 )
 633                     {
 634                         err = WSAGetLastError ();
 635                         ok ( err == WSAEWOULDBLOCK, "event_client (%x): send error: %d\n", id, err );
 636                     }
 637                     else
 638                         send_p += n;
 639                 }
 640                 while ( n >= 0 && send_p < send_last );
 641
 642             if ( send_p == send_last )
 643             {
 644                 trace ( "event_client (%x): all data sent - shutdown\n", id );
 645                 shutdown ( mem->s, SD_SEND );
 646                 mask &= ~FD_WRITE;
 647                 WSAEventSelect ( mem->s, event, mask );
 648             }
 649         }
 650         if ( wsa_events.lNetworkEvents & FD_READ )
 651         {
 652             err = wsa_events.iErrorCode[ FD_READ_BIT ];
 653             ok ( err == 0, "event_client (%x): FD_READ error code: %d\n", id, err );
 654             if ( err != 0 ) break;
 655
 656             /* First read must succeed */
 657             n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
 658             wsa_ok ( n, 0 <=, "event_client (%lx): recv error: %d\n" );
 659
 660             while ( n >= 0 ) {
 661                 recv_p += n;
 662                 if ( recv_p == recv_last )
 663                 {
 664                     mask &= ~FD_READ;
 665                     trace ( "event_client (%x): all data received\n", id );
 666                     WSAEventSelect ( mem->s, event, mask );
 667                     break;
 668                 }
 669                 n = recv ( mem->s, recv_p, min ( recv_last - recv_p, par->buflen ), 0 );
 670                 if ( n < 0 && ( err = WSAGetLastError()) != WSAEWOULDBLOCK )
 671                     ok ( 0, "event_client (%x): read error: %d\n", id, err );
 672
 673             }
 674         }
 675         if ( wsa_events.lNetworkEvents & FD_CLOSE )
 676         {
 677             trace ( "event_client (%x): close event\n", id );
 678             err = wsa_events.iErrorCode[ FD_CLOSE_BIT ];
 679             ok ( err == 0, "event_client (%x): FD_CLOSE error code: %d\n", id, err );
 680             break;
 681         }
 682     }
 683
 684     ok ( send_p == send_last,
 685          "simple_client (%x): sent less data than expected: %d of %d\n",
 686          id, send_p - mem->send_buf, n_expected );
 687     ok ( recv_p == recv_last,
 688          "simple_client (%x): received less data than expected: %d of %d\n",
 689          id, recv_p - mem->recv_buf, n_expected );
 690     recv_p = test_buffer ( mem->recv_buf, gen->chunk_size, gen->n_chunks );
 691     ok ( recv_p == NULL, "event_client (%x): test pattern error: %d\n", id, recv_p - mem->recv_buf);
 692
 693 out:
 694     WSACloseEvent ( event );
 695     trace ( "event_client (%x) exiting\n", id );
 696     client_stop ();
 697 }
 698
 699 /**************** Main program utility functions ***************/
 700
 701 static void Init (void)
 702 {
 703     WORD ver = MAKEWORD (2, 2);
 704     WSADATA data;
 705
 706     ok ( WSAStartup ( ver, &data ) == 0, "WSAStartup failed\n" );
 707     tls = TlsAlloc();
 708 }
 709
 710 static void Exit (void)
 711 {
 712     INT ret, err;
 713     TlsFree ( tls );
 714     ret = WSACleanup();
 715     err = WSAGetLastError();
 716     ok ( ret == 0, "WSACleanup failed ret = %d GetLastError is %d\n", ret, err);
 717     ret = WSACleanup();
 718     err = WSAGetLastError();
 719     ok ( ret == SOCKET_ERROR && err ==  WSANOTINITIALISED,
 720             "WSACleanup returned %d GetLastError is %d\n", ret, err);
 721 }
 722
 723 static void StartServer (LPTHREAD_START_ROUTINE routine,
 724                          test_params *general, server_params *par)
 725 {
 726     par->general = general;
 727     thread[0] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[0] );
 728     ok ( thread[0] != NULL, "Failed to create server thread\n" );
 729 }
 730
 731 static void StartClients (LPTHREAD_START_ROUTINE routine,
 732                           test_params *general, client_params *par)
 733 {
 734     int i;
 735     par->general = general;
 736     for ( i = 1; i <= min ( general->n_clients, MAX_CLIENTS ); i++ )
 737     {
 738         client_id = i - 1;
 739         thread[i] = CreateThread ( NULL, 0, routine, par, 0, &thread_id[i] );
 740         ok ( thread[i] != NULL, "Failed to create client thread\n" );
 741         /* Make sure the client is up and running */
 742         WaitForSingleObject ( client_ready[client_id], INFINITE );
 743     };
 744 }
 745
 746 static void do_test( test_setup *test )
 747 {
 748     DWORD i, n = min (test->general.n_clients, MAX_CLIENTS);
 749     DWORD wait;
 750
 751     server_ready = CreateEventW ( NULL, TRUE, FALSE, NULL );
 752     for (i = 0; i <= n; i++)
 753         client_ready[i] = CreateEventW ( NULL, TRUE, FALSE, NULL );
 754
 755     StartServer ( test->srv, &test->general, &test->srv_params );
 756     StartClients ( test->clt, &test->general, &test->clt_params );
 757     WaitForSingleObject ( server_ready, INFINITE );
 758
 759     wait = WaitForMultipleObjects ( 1 + n, thread, TRUE, 1000 * TEST_TIMEOUT );
 760     ok ( wait >= WAIT_OBJECT_0 && wait <= WAIT_OBJECT_0 + n ,
 761          "some threads have not completed: %lx\n", wait );
 762
 763     if ( ! ( wait >= WAIT_OBJECT_0 && wait <= WAIT_OBJECT_0 + n ) )
 764     {
 765         for (i = 0; i <= n; i++)
 766         {
 767             trace ("terminating thread %08lx\n", thread_id[i]);
 768             if ( WaitForSingleObject ( thread[i], 0 ) != WAIT_OBJECT_0 )
 769                 TerminateThread ( thread [i], 0 );
 770         }
 771     }
 772     CloseHandle ( server_ready );
 773     for (i = 0; i <= n; i++)
 774         CloseHandle ( client_ready[i] );
 775 }
 776
 777 /********* some tests for getsockopt(setsockopt(X)) == X ***********/
 778 /* optname = SO_LINGER */
 779 LINGER linger_testvals[] = {
 780     {0,0},
 781     {0,73},
 782     {1,0},
 783     {5,189}
 784 };
 785
 786 /* optname = SO_RCVTIMEO, SOSNDTIMEO */
 787 #define SOCKTIMEOUT1 63000 /* 63 seconds. Do not test fractional part because of a
 788                         bug in the linux kernel (fixed in 2.6.8) */
 789 #define SOCKTIMEOUT2 997000 /* 997 seconds */
 790
 791 static void test_set_getsockopt(void)
 792 {
 793     SOCKET s;
 794     int i, err;
 795     int timeout;
 796     LINGER lingval;
 797     int size;
 798
 799     s = socket(AF_INET, SOCK_STREAM, 0);
 800     ok(s!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
 801     if( s == INVALID_SOCKET) return;
 802     /* SO_RCVTIMEO */
 803     timeout = SOCKTIMEOUT1;
 804     size = sizeof(timeout);
 805     err = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, size);
 806     if( !err)
 807         err = getsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char *) &timeout, &size);
 808     ok( !err, "get/setsockopt(SO_RCVTIMEO) failed error: %d\n", WSAGetLastError());
 809     ok( timeout == SOCKTIMEOUT1, "getsockopt(SO_RCVTIMEO) returned wrong value %d\n", timeout);
 810     /* SO_SNDTIMEO */
 811     timeout = SOCKTIMEOUT2; /* 54 seconds. See remark above */
 812     size = sizeof(timeout);
 813     err = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, size);
 814     if( !err)
 815         err = getsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *) &timeout, &size);
 816     ok( !err, "get/setsockopt(SO_SNDTIMEO) failed error: %d\n", WSAGetLastError());
 817     ok( timeout == SOCKTIMEOUT2, "getsockopt(SO_SNDTIMEO) returned wrong value %d\n", timeout);
 818     /* SO_LINGER */
 819     for( i = 0; i < sizeof(linger_testvals)/sizeof(LINGER);i++) {
 820         size =  sizeof(lingval);
 821         lingval = linger_testvals[i];
 822         err = setsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, size);
 823         if( !err)
 824             err = getsockopt(s, SOL_SOCKET, SO_LINGER, (char *) &lingval, &size);
 825         ok( !err, "get/setsockopt(SO_LINGER) failed error: %d\n", WSAGetLastError());
 826         ok( !lingval.l_onoff == !linger_testvals[i].l_onoff &&
 827                 (lingval.l_linger == linger_testvals[i].l_linger ||
 828                  (!lingval.l_linger && !linger_testvals[i].l_onoff))
 829                 , "getsockopt(SO_LINGER #%d) returned wrong value %d,%d not %d,%d\n", i,
 830                  lingval.l_onoff, lingval.l_linger,
 831                  linger_testvals[i].l_onoff, linger_testvals[i].l_linger);
 832     }
 833     closesocket(s);
 834 }
 835
 836 static void test_so_reuseaddr(void)
 837 {
 838     struct sockaddr_in saddr;
 839     SOCKET s1,s2;
 840     unsigned int rc,reuse;
 841     int size;
 842
 843     saddr.sin_family      = AF_INET;
 844     saddr.sin_port        = htons(9375);
 845     saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
 846
 847     s1=socket(AF_INET, SOCK_STREAM, 0);
 848     ok(s1!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
 849     rc = bind(s1, (struct sockaddr*)&saddr, sizeof(saddr));
 850     ok(rc!=SOCKET_ERROR, "bind(s1) failed error: %d\n", WSAGetLastError());
 851
 852     s2=socket(AF_INET, SOCK_STREAM, 0);
 853     ok(s2!=INVALID_SOCKET, "socket() failed error: %d\n", WSAGetLastError());
 854
 855     reuse=0x1234;
 856     size=sizeof(reuse);
 857     rc=getsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, &size );
 858     ok(rc==0 && reuse==0,"wrong result in getsockopt(SO_REUSEADDR): rc=%d reuse=%d\n",rc,reuse);
 859
 860     rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
 861     ok(rc==SOCKET_ERROR, "bind() succeeded\n");
 862
 863     reuse = 1;
 864     rc = setsockopt(s2, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse));
 865     ok(rc==0, "setsockopt() failed error: %d\n", WSAGetLastError());
 866
 867     todo_wine {
 868     rc = bind(s2, (struct sockaddr*)&saddr, sizeof(saddr));
 869     ok(rc==0, "bind() failed error: %d\n", WSAGetLastError());
 870     }
 871
 872     closesocket(s2);
 873     closesocket(s1);
 874 }
 875
 876 /************* Array containing the tests to run **********/
 877
 878 #define STD_STREAM_SOCKET \
 879             SOCK_STREAM, \
 880             0, \
 881             SERVERIP, \
 882             SERVERPORT
 883
 884 static test_setup tests [NUM_TESTS] =
 885 {
 886     /* Test 0: synchronous client and server */
 887     {
 888         {
 889             STD_STREAM_SOCKET,
 890             2048,
 891             16,
 892             2
 893         },
 894         simple_server,
 895         {
 896             NULL,
 897             0,
 898             64
 899         },
 900         simple_client,
 901         {
 902             NULL,
 903             0,
 904             128
 905         }
 906     },
 907     /* Test 1: event-driven client, synchronous server */
 908     {
 909         {
 910             STD_STREAM_SOCKET,
 911             2048,
 912             16,
 913             2
 914         },
 915         simple_server,
 916         {
 917             NULL,
 918             0,
 919             64
 920         },
 921         event_client,
 922         {
 923             NULL,
 924             WSA_FLAG_OVERLAPPED,
 925             128
 926         }
 927     },
 928     /* Test 2: synchronous client, non-blocking server via select() */
 929     {
 930         {
 931             STD_STREAM_SOCKET,
 932             2048,
 933             16,
 934             2
 935         },
 936         select_server,
 937         {
 938             NULL,
 939             0,
 940             64
 941         },
 942         simple_client,
 943         {
 944             NULL,
 945             0,
 946             128
 947         }
 948     }
 949 };
 950
 951 static void test_UDP(void)
 952 {
 953     /* This function tests UDP sendto() and recvfrom(). UDP is unreliable, so it is
 954        possible that this test fails due to dropped packets. */
 955
 956     /* peer 0 receives data from all other peers */
 957     struct sock_info peer[NUM_UDP_PEERS];
 958     char buf[16];
 959     int ss, i, n_recv, n_sent;
 960
 961     for ( i = NUM_UDP_PEERS - 1; i >= 0; i-- ) {
 962         ok ( ( peer[i].s = socket ( AF_INET, SOCK_DGRAM, 0 ) ) != INVALID_SOCKET, "UDP: socket failed\n" );
 963
 964         peer[i].addr.sin_family         = AF_INET;
 965         peer[i].addr.sin_addr.s_addr    = inet_addr ( SERVERIP );
 966
 967         if ( i == 0 ) {
 968             peer[i].addr.sin_port       = htons ( SERVERPORT );
 969         } else {
 970             peer[i].addr.sin_port       = htons ( 0 );
 971         }
 972
 973         do_bind ( peer[i].s, (struct sockaddr *) &peer[i].addr, sizeof( peer[i].addr ) );
 974
 975         /* test getsockname() to get peer's port */
 976         ss = sizeof ( peer[i].addr );
 977         ok ( getsockname ( peer[i].s, (struct sockaddr *) &peer[i].addr, &ss ) != SOCKET_ERROR, "UDP: could not getsockname()\n" );
 978         ok ( peer[i].addr.sin_port != htons ( 0 ), "UDP: bind() did not associate port\n" );
 979     }
 980
 981     /* test getsockname() */
 982     ok ( peer[0].addr.sin_port == htons ( SERVERPORT ), "UDP: getsockname returned incorrect peer port\n" );
 983
 984     for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
 985         /* send client's ip */
 986         memcpy( buf, &peer[i].addr.sin_port, sizeof(peer[i].addr.sin_port) );
 987         n_sent = sendto ( peer[i].s, buf, sizeof(buf), 0, (struct sockaddr*) &peer[0].addr, sizeof(peer[0].addr) );
 988         ok ( n_sent == sizeof(buf), "UDP: sendto() sent wrong amount of data or socket error: %d\n", n_sent );
 989     }
 990
 991     for ( i = 1; i < NUM_UDP_PEERS; i++ ) {
 992         n_recv = recvfrom ( peer[0].s, buf, sizeof(buf), 0,(struct sockaddr *) &peer[0].peer, &ss );
 993         ok ( n_recv == sizeof(buf), "UDP: recvfrom() received wrong amount of data or socket error: %d\n", n_recv );
 994         ok ( memcmp ( &peer[0].peer.sin_port, buf, sizeof(peer[0].addr.sin_port) ) == 0, "UDP: port numbers do not match\n" );
 995     }
 996 }
 997
 998 static void WINAPI do_getservbyname( HANDLE *starttest )
 999 {
1000     struct {
1001         const char *name;
1002         const char *proto;
1003         int port;
1004     } serv[2] = { {"domain", "udp", 53}, {"telnet", "tcp", 23} };
1005
1006     int i, j;
1007     struct servent *pserv[2];
1008
1009     ok ( WaitForSingleObject ( *starttest, TEST_TIMEOUT * 1000 ) != WAIT_TIMEOUT, "test_getservbyname: timeout waiting for start signal\n");
1010
1011     /* ensure that necessary buffer resizes are completed */
1012     for ( j = 0; j < 2; j++) {
1013         pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1014     }
1015
1016     for ( i = 0; i < NUM_QUERIES / 2; i++ ) {
1017         for ( j = 0; j < 2; j++ ) {
1018             pserv[j] = getservbyname ( serv[j].name, serv[j].proto );
1019             ok ( pserv[j] != NULL, "getservbyname could not retrieve information for %s: %d\n", serv[j].name, WSAGetLastError() );
1020             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) );
1021             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 );
1022             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 );
1023         }
1024
1025         ok ( pserv[0] == pserv[1], "getservbyname: winsock resized servent buffer when not necessary\n" );
1026     }
1027 }
1028
1029 static void test_getservbyname(void)
1030 {
1031     int i;
1032     HANDLE starttest, thread[NUM_THREADS];
1033     DWORD thread_id[NUM_THREADS];
1034
1035     starttest = CreateEvent ( NULL, 1, 0, "test_getservbyname_starttest" );
1036
1037     /* create threads */
1038     for ( i = 0; i < NUM_THREADS; i++ ) {
1039         thread[i] = CreateThread ( NULL, 0, (LPTHREAD_START_ROUTINE) &do_getservbyname, &starttest, 0, &thread_id[i] );
1040     }
1041
1042     /* signal threads to start */
1043     SetEvent ( starttest );
1044
1045     for ( i = 0; i < NUM_THREADS; i++) {
1046         WaitForSingleObject ( thread[i], TEST_TIMEOUT * 1000 );
1047     }
1048 }
1049
1050 static void test_WSAAddressToStringA(void)
1051 {
1052     INT ret;
1053     DWORD len;
1054     int GLE;
1055     SOCKADDR_IN sockaddr;
1056     CHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1057
1058     CHAR expect1[] = "0.0.0.0";
1059     CHAR expect2[] = "255.255.255.255";
1060     CHAR expect3[] = "0.0.0.0:65535";
1061     CHAR expect4[] = "255.255.255.255:65535";
1062
1063     len = 0;
1064
1065     sockaddr.sin_family = AF_INET;
1066     sockaddr.sin_port = 0;
1067     sockaddr.sin_addr.s_addr = 0;
1068
1069     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1070     GLE = WSAGetLastError();
1071     ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
1072         "WSAAddressToStringA() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1073         GLE, ret );
1074
1075     len = sizeof(address);
1076
1077     sockaddr.sin_family = AF_INET;
1078     sockaddr.sin_port = 0;
1079     sockaddr.sin_addr.s_addr = 0;
1080
1081     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1082     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1083
1084     ok( !strcmp( address, expect1 ), "Expected: %s, got: %s\n", expect1, address );
1085
1086     len = sizeof(address);
1087
1088     sockaddr.sin_family = AF_INET;
1089     sockaddr.sin_port = 0;
1090     sockaddr.sin_addr.s_addr = 0xffffffff;
1091
1092     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1093     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1094
1095     ok( !strcmp( address, expect2 ), "Expected: %s, got: %s\n", expect2, address );
1096
1097     len = sizeof(address);
1098
1099     sockaddr.sin_family = AF_INET;
1100     sockaddr.sin_port = 0xffff;
1101     sockaddr.sin_addr.s_addr = 0;
1102
1103     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1104     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1105
1106     ok( !strcmp( address, expect3 ), "Expected: %s, got: %s\n", expect3, address );
1107
1108     len = sizeof(address);
1109
1110     sockaddr.sin_family = AF_INET;
1111     sockaddr.sin_port = 0xffff;
1112     sockaddr.sin_addr.s_addr = 0xffffffff;
1113
1114     ret = WSAAddressToStringA( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1115     ok( !ret, "WSAAddressToStringA() failed unexpectedly: %d\n", WSAGetLastError() );
1116
1117     ok( !strcmp( address, expect4 ), "Expected: %s, got: %s\n", expect4, address );
1118 }
1119
1120 static void test_WSAAddressToStringW(void)
1121 {
1122     INT ret;
1123     DWORD len;
1124     int GLE;
1125     SOCKADDR_IN sockaddr;
1126     WCHAR address[22]; /* 12 digits + 3 dots + ':' + 5 digits + '\0' */
1127
1128     WCHAR expect1[] = { '0','.','0','.','0','.','0', 0 };
1129     WCHAR expect2[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1130     WCHAR expect3[] = { '0','.','0','.','0','.','0', ':', '6', '5', '5', '3', '5', 0 };
1131     WCHAR expect4[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1132                         '6', '5', '5', '3', '5', 0 };
1133
1134     len = 0;
1135
1136     sockaddr.sin_family = AF_INET;
1137     sockaddr.sin_port = 0;
1138     sockaddr.sin_addr.s_addr = 0;
1139
1140     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1141     GLE = WSAGetLastError();
1142     ok( (ret == SOCKET_ERROR && GLE == WSAEFAULT) || (ret == 0),
1143         "WSAAddressToStringW() failed unexpectedly: WSAGetLastError()=%d, ret=%d\n",
1144         GLE, ret );
1145
1146     len = sizeof(address);
1147
1148     sockaddr.sin_family = AF_INET;
1149     sockaddr.sin_port = 0;
1150     sockaddr.sin_addr.s_addr = 0;
1151
1152     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1153     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %x\n", WSAGetLastError() );
1154
1155     ok( !lstrcmpW( address, expect1 ), "Expected different address string\n" );
1156
1157     len = sizeof(address);
1158
1159     sockaddr.sin_family = AF_INET;
1160     sockaddr.sin_port = 0;
1161     sockaddr.sin_addr.s_addr = 0xffffffff;
1162
1163     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1164     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %x\n", WSAGetLastError() );
1165
1166     ok( !lstrcmpW( address, expect2 ), "Expected different address string\n" );
1167
1168     len = sizeof(address);
1169
1170     sockaddr.sin_family = AF_INET;
1171     sockaddr.sin_port = 0xffff;
1172     sockaddr.sin_addr.s_addr = 0;
1173
1174     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1175     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %x\n", WSAGetLastError() );
1176
1177     ok( !lstrcmpW( address, expect3 ), "Expected different address string\n" );
1178
1179     len = sizeof(address);
1180
1181     sockaddr.sin_family = AF_INET;
1182     sockaddr.sin_port = 0xffff;
1183     sockaddr.sin_addr.s_addr = 0xffffffff;
1184
1185     ret = WSAAddressToStringW( (SOCKADDR*)&sockaddr, sizeof(sockaddr), NULL, address, &len );
1186     ok( !ret, "WSAAddressToStringW() failed unexpectedly: %x\n", WSAGetLastError() );
1187
1188     ok( !lstrcmpW( address, expect4 ), "Expected different address string\n" );
1189 }
1190
1191 static void test_WSAStringToAddressA(void)
1192 {
1193     INT ret, len;
1194     SOCKADDR_IN sockaddr;
1195     int GLE;
1196
1197     CHAR address1[] = "0.0.0.0";
1198     CHAR address2[] = "127.127.127.127";
1199     CHAR address3[] = "255.255.255.255";
1200     CHAR address4[] = "127.127.127.127:65535";
1201     CHAR address5[] = "255.255.255.255:65535";
1202
1203     len = 0;
1204     sockaddr.sin_family = AF_INET;
1205
1206     ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1207     ok( ret == SOCKET_ERROR, "WSAStringToAddressA() succeeded unexpectedly: %x\n",
1208         WSAGetLastError() );
1209
1210     len = sizeof(sockaddr);
1211     sockaddr.sin_port = 0;
1212     sockaddr.sin_addr.s_addr = 0;
1213
1214     ret = WSAStringToAddressA( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1215     ok( !ret && sockaddr.sin_addr.s_addr == 0,
1216         "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1217
1218     len = sizeof(sockaddr);
1219     sockaddr.sin_port = 0;
1220     sockaddr.sin_addr.s_addr = 0;
1221
1222     ret = WSAStringToAddressA( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1223     ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
1224         "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1225
1226     len = sizeof(sockaddr);
1227     sockaddr.sin_port = 0;
1228     sockaddr.sin_addr.s_addr = 0;
1229
1230     ret = WSAStringToAddressA( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1231     GLE = WSAGetLastError();
1232     ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
1233         (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1234         "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
1235
1236     len = sizeof(sockaddr);
1237     sockaddr.sin_port = 0;
1238     sockaddr.sin_addr.s_addr = 0;
1239
1240     ret = WSAStringToAddressA( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1241     ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
1242         "WSAStringToAddressA() failed unexpectedly: %d\n", WSAGetLastError() );
1243
1244     len = sizeof(sockaddr);
1245     sockaddr.sin_port = 0;
1246     sockaddr.sin_addr.s_addr = 0;
1247
1248     ret = WSAStringToAddressA( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1249     GLE = WSAGetLastError();
1250     ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
1251         (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1252         "WSAStringToAddressA() failed unexpectedly: %d\n", GLE );
1253 }
1254
1255 static void test_WSAStringToAddressW(void)
1256 {
1257     INT ret, len;
1258     SOCKADDR_IN sockaddr;
1259     int GLE;
1260
1261     WCHAR address1[] = { '0','.','0','.','0','.','0', 0 };
1262     WCHAR address2[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7', 0 };
1263     WCHAR address3[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', 0 };
1264     WCHAR address4[] = { '1','2','7','.','1','2','7','.','1','2','7','.','1','2','7',
1265                          ':', '6', '5', '5', '3', '5', 0 };
1266     WCHAR address5[] = { '2','5','5','.','2','5','5','.','2','5','5','.','2','5','5', ':',
1267                          '6', '5', '5', '3', '5', 0 };
1268
1269     len = 0;
1270     sockaddr.sin_family = AF_INET;
1271
1272     ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1273     ok( ret == SOCKET_ERROR, "WSAStringToAddressW() failed unexpectedly: %d\n",
1274         WSAGetLastError() );
1275
1276     len = sizeof(sockaddr);
1277     sockaddr.sin_port = 0;
1278     sockaddr.sin_addr.s_addr = 0;
1279
1280     ret = WSAStringToAddressW( address1, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1281     ok( !ret && sockaddr.sin_addr.s_addr == 0,
1282         "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1283
1284     len = sizeof(sockaddr);
1285     sockaddr.sin_port = 0;
1286     sockaddr.sin_addr.s_addr = 0;
1287
1288     ret = WSAStringToAddressW( address2, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1289     ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f,
1290         "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1291
1292     len = sizeof(sockaddr);
1293     sockaddr.sin_port = 0;
1294     sockaddr.sin_addr.s_addr = 0;
1295
1296     ret = WSAStringToAddressW( address3, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1297     GLE = WSAGetLastError();
1298     ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff) ||
1299         (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1300         "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
1301
1302     len = sizeof(sockaddr);
1303     sockaddr.sin_port = 0;
1304     sockaddr.sin_addr.s_addr = 0;
1305
1306     ret = WSAStringToAddressW( address4, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1307     ok( !ret && sockaddr.sin_addr.s_addr == 0x7f7f7f7f && sockaddr.sin_port == 0xffff,
1308         "WSAStringToAddressW() failed unexpectedly: %d\n", WSAGetLastError() );
1309
1310     len = sizeof(sockaddr);
1311     sockaddr.sin_port = 0;
1312     sockaddr.sin_addr.s_addr = 0;
1313
1314     ret = WSAStringToAddressW( address5, AF_INET, NULL, (SOCKADDR*)&sockaddr, &len );
1315     ok( (ret == 0 && sockaddr.sin_addr.s_addr == 0xffffffff && sockaddr.sin_port == 0xffff) ||
1316         (ret == SOCKET_ERROR && (GLE == ERROR_INVALID_PARAMETER || GLE == WSAEINVAL)),
1317         "WSAStringToAddressW() failed unexpectedly: %d\n", GLE );
1318 }
1319
1320 /**************** Main program  ***************/
1321
1322 START_TEST( sock )
1323 {
1324     int i;
1325     Init();
1326
1327     test_set_getsockopt();
1328     test_so_reuseaddr();
1329
1330     for (i = 0; i < NUM_TESTS; i++)
1331     {
1332         trace ( " **** STARTING TEST %d ****\n", i );
1333         do_test (  &tests[i] );
1334         trace ( " **** TEST %d COMPLETE ****\n", i );
1335     }
1336
1337     test_UDP();
1338
1339     test_getservbyname();
1340
1341     test_WSAAddressToStringA();
1342     test_WSAAddressToStringW();
1343
1344     test_WSAStringToAddressA();
1345     test_WSAStringToAddressW();
1346
1347     Exit();
1348 }