gio/tests/socket.c

   1 /* GLib testing framework examples and tests
   2  *
   3  * Copyright (C) 2008-2011 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <gio/gio.h>
  20
  21 #ifdef G_OS_UNIX
  22 #include <errno.h>
  23 #include <sys/wait.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26 #include <gio/gnetworking.h>
  27 #include <gio/gunixconnection.h>
  28 #endif
  29
  30 #include "gnetworkingprivate.h"
  31
  32 static gboolean ipv6_supported;
  33
  34 typedef struct {
  35   GSocket *server;
  36   GSocket *client;
  37   GSocketFamily family;
  38   GThread *thread;
  39   GMainLoop *loop;
  40   GCancellable *cancellable; /* to shut down dgram echo server thread */
  41 } IPTestData;
  42
  43 static gpointer
  44 echo_server_dgram_thread (gpointer user_data)
  45 {
  46   IPTestData *data = user_data;
  47   GSocketAddress *sa;
  48   GCancellable *cancellable = data->cancellable;
  49   GSocket *sock;
  50   GError *error = NULL;
  51   gssize nread, nwrote;
  52   gchar buf[128];
  53
  54   sock = data->server;
  55
  56   while (TRUE)
  57     {
  58       nread = g_socket_receive_from (sock, &sa, buf, sizeof (buf), cancellable, &error);
  59       if (error && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
  60         break;
  61       g_assert_no_error (error);
  62       g_assert_cmpint (nread, >=, 0);
  63
  64       nwrote = g_socket_send_to (sock, sa, buf, nread, cancellable, &error);
  65       if (error && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
  66         break;
  67       g_assert_no_error (error);
  68       g_assert_cmpint (nwrote, ==, nread);
  69
  70       g_object_unref (sa);
  71     }
  72
  73   g_clear_error (&error);
  74
  75   return NULL;
  76 }
  77
  78 static gpointer
  79 echo_server_thread (gpointer user_data)
  80 {
  81   IPTestData *data = user_data;
  82   GSocket *sock;
  83   GError *error = NULL;
  84   gssize nread, nwrote;
  85   gchar buf[128];
  86
  87   sock = g_socket_accept (data->server, NULL, &error);
  88   g_assert_no_error (error);
  89
  90   while (TRUE)
  91     {
  92       nread = g_socket_receive (sock, buf, sizeof (buf), NULL, &error);
  93       g_assert_no_error (error);
  94       g_assert_cmpint (nread, >=, 0);
  95
  96       if (nread == 0)
  97         break;
  98
  99       nwrote = g_socket_send (sock, buf, nread, NULL, &error);
 100       g_assert_no_error (error);
 101       g_assert_cmpint (nwrote, ==, nread);
 102     }
 103
 104   g_socket_close (sock, &error);
 105   g_assert_no_error (error);
 106   g_object_unref (sock);
 107   return NULL;
 108 }
 109
 110 static IPTestData *
 111 create_server_full (GSocketFamily   family,
 112                     GSocketType     socket_type,
 113                     GThreadFunc     server_thread,
 114                     gboolean        v4mapped,
 115                     GError        **error)
 116 {
 117   IPTestData *data;
 118   GSocket *server;
 119   GSocketAddress *addr;
 120   GInetAddress *iaddr;
 121
 122   data = g_slice_new (IPTestData);
 123   data->family = family;
 124
 125   data->server = server = g_socket_new (family,
 126                                         socket_type,
 127                                         G_SOCKET_PROTOCOL_DEFAULT,
 128                                         error);
 129   if (server == NULL)
 130     goto error;
 131
 132   g_assert_cmpint (g_socket_get_family (server), ==, family);
 133   g_assert_cmpint (g_socket_get_socket_type (server), ==, socket_type);
 134   g_assert_cmpint (g_socket_get_protocol (server), ==, G_SOCKET_PROTOCOL_DEFAULT);
 135
 136   g_socket_set_blocking (server, TRUE);
 137
 138 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
 139   if (v4mapped)
 140     {
 141       g_socket_set_option (data->server, IPPROTO_IPV6, IPV6_V6ONLY, FALSE, NULL);
 142       if (!g_socket_speaks_ipv4 (data->server))
 143         {
 144           g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
 145                                "IPv6-only server cannot speak IPv4");
 146           goto error;
 147         }
 148     }
 149 #endif
 150
 151   if (v4mapped)
 152     iaddr = g_inet_address_new_any (family);
 153   else
 154     iaddr = g_inet_address_new_loopback (family);
 155   addr = g_inet_socket_address_new (iaddr, 0);
 156   g_object_unref (iaddr);
 157
 158   g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), ==, 0);
 159   if (!g_socket_bind (server, addr, TRUE, error))
 160     {
 161       g_object_unref (addr);
 162       goto error;
 163     }
 164   g_object_unref (addr);
 165
 166   addr = g_socket_get_local_address (server, error);
 167   if (addr == NULL)
 168     goto error;
 169   g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), !=, 0);
 170   g_object_unref (addr);
 171
 172   if (socket_type == G_SOCKET_TYPE_STREAM)
 173     {
 174       if (!g_socket_listen (server, error))
 175         goto error;
 176     }
 177   else
 178     {
 179       data->cancellable = g_cancellable_new ();
 180     }
 181
 182   data->thread = g_thread_new ("server", server_thread, data);
 183
 184   return data;
 185
 186 error:
 187   g_clear_object (&data->server);
 188   g_slice_free (IPTestData, data);
 189
 190   return NULL;
 191 }
 192
 193 static IPTestData *
 194 create_server (GSocketFamily   family,
 195                GThreadFunc     server_thread,
 196                gboolean        v4mapped,
 197                GError        **error)
 198 {
 199   return create_server_full (family, G_SOCKET_TYPE_STREAM, server_thread, v4mapped, error);
 200 }
 201
 202 static const gchar *testbuf = "0123456789abcdef";
 203
 204 static gboolean
 205 test_ip_async_read_ready (GSocket      *client,
 206                           GIOCondition  cond,
 207                           gpointer      user_data)
 208 {
 209   IPTestData *data = user_data;
 210   GError *error = NULL;
 211   gssize len;
 212   gchar buf[128];
 213
 214   g_assert_cmpint (cond, ==, G_IO_IN);
 215
 216   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 217   g_assert_no_error (error);
 218   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 219
 220   g_assert_cmpstr (testbuf, ==, buf);
 221
 222   g_main_loop_quit (data->loop);
 223
 224   return FALSE;
 225 }
 226
 227 static gboolean
 228 test_ip_async_write_ready (GSocket      *client,
 229                            GIOCondition  cond,
 230                            gpointer      user_data)
 231 {
 232   IPTestData *data = user_data;
 233   GError *error = NULL;
 234   GSource *source;
 235   gssize len;
 236
 237   g_assert_cmpint (cond, ==, G_IO_OUT);
 238
 239   len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
 240   g_assert_no_error (error);
 241   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 242
 243   source = g_socket_create_source (client, G_IO_IN, NULL);
 244   g_source_set_callback (source, (GSourceFunc)test_ip_async_read_ready,
 245                          data, NULL);
 246   g_source_attach (source, NULL);
 247   g_source_unref (source);
 248
 249   return FALSE;
 250 }
 251
 252 static gboolean
 253 test_ip_async_timed_out (GSocket      *client,
 254                          GIOCondition  cond,
 255                          gpointer      user_data)
 256 {
 257   IPTestData *data = user_data;
 258   GError *error = NULL;
 259   GSource *source;
 260   gssize len;
 261   gchar buf[128];
 262
 263   if (data->family == G_SOCKET_FAMILY_IPV4)
 264     {
 265       g_assert_cmpint (cond, ==, G_IO_IN);
 266       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 267       g_assert_cmpint (len, ==, -1);
 268       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
 269       g_clear_error (&error);
 270     }
 271
 272   source = g_socket_create_source (client, G_IO_OUT, NULL);
 273   g_source_set_callback (source, (GSourceFunc)test_ip_async_write_ready,
 274                          data, NULL);
 275   g_source_attach (source, NULL);
 276   g_source_unref (source);
 277
 278   return FALSE;
 279 }
 280
 281 static gboolean
 282 test_ip_async_connected (GSocket      *client,
 283                          GIOCondition  cond,
 284                          gpointer      user_data)
 285 {
 286   IPTestData *data = user_data;
 287   GError *error = NULL;
 288   GSource *source;
 289   gssize len;
 290   gchar buf[128];
 291
 292   g_socket_check_connect_result (client, &error);
 293   g_assert_no_error (error);
 294   /* We do this after the check_connect_result, since that will give a
 295    * more useful assertion in case of error.
 296    */
 297   g_assert_cmpint (cond, ==, G_IO_OUT);
 298
 299   g_assert (g_socket_is_connected (client));
 300
 301   /* This adds 1 second to "make check", so let's just only do it once. */
 302   if (data->family == G_SOCKET_FAMILY_IPV4)
 303     {
 304       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 305       g_assert_cmpint (len, ==, -1);
 306       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
 307       g_clear_error (&error);
 308
 309       source = g_socket_create_source (client, G_IO_IN, NULL);
 310       g_source_set_callback (source, (GSourceFunc)test_ip_async_timed_out,
 311                              data, NULL);
 312       g_source_attach (source, NULL);
 313       g_source_unref (source);
 314     }
 315   else
 316     test_ip_async_timed_out (client, 0, data);
 317
 318   return FALSE;
 319 }
 320
 321 static gboolean
 322 idle_test_ip_async_connected (gpointer user_data)
 323 {
 324   IPTestData *data = user_data;
 325
 326   return test_ip_async_connected (data->client, G_IO_OUT, data);
 327 }
 328
 329 static void
 330 test_ip_async (GSocketFamily family)
 331 {
 332   IPTestData *data;
 333   GError *error = NULL;
 334   GSocket *client;
 335   GSocketAddress *addr;
 336   GSource *source;
 337   gssize len;
 338   gchar buf[128];
 339
 340   data = create_server (family, echo_server_thread, FALSE, &error);
 341   if (error != NULL)
 342     {
 343       gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
 344       g_test_skip (message);
 345       g_free (message);
 346       g_clear_error (&error);
 347       return;
 348     }
 349   g_assert_nonnull (data);
 350
 351   addr = g_socket_get_local_address (data->server, &error);
 352   g_assert_no_error (error);
 353
 354   client = g_socket_new (family,
 355                          G_SOCKET_TYPE_STREAM,
 356                          G_SOCKET_PROTOCOL_DEFAULT,
 357                          &error);
 358   g_assert_no_error (error);
 359   data->client = client;
 360
 361   g_assert_cmpint (g_socket_get_family (client), ==, family);
 362   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
 363   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 364
 365   g_socket_set_blocking (client, FALSE);
 366   g_socket_set_timeout (client, 1);
 367
 368   if (g_socket_connect (client, addr, NULL, &error))
 369     {
 370       g_assert_no_error (error);
 371       g_idle_add (idle_test_ip_async_connected, data);
 372     }
 373   else
 374     {
 375       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
 376       g_clear_error (&error);
 377       source = g_socket_create_source (client, G_IO_OUT, NULL);
 378       g_source_set_callback (source, (GSourceFunc)test_ip_async_connected,
 379                              data, NULL);
 380       g_source_attach (source, NULL);
 381       g_source_unref (source);
 382     }
 383   g_object_unref (addr);
 384
 385   data->loop = g_main_loop_new (NULL, TRUE);
 386   g_main_loop_run (data->loop);
 387   g_main_loop_unref (data->loop);
 388
 389   g_socket_shutdown (client, FALSE, TRUE, &error);
 390   g_assert_no_error (error);
 391
 392   g_thread_join (data->thread);
 393
 394   if (family == G_SOCKET_FAMILY_IPV4)
 395     {
 396       /* Test that reading on a remote-closed socket gets back 0 bytes. */
 397       len = g_socket_receive_with_blocking (client, buf, sizeof (buf),
 398                                             TRUE, NULL, &error);
 399       g_assert_no_error (error);
 400       g_assert_cmpint (len, ==, 0);
 401     }
 402   else
 403     {
 404       /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */
 405       len = g_socket_send_with_blocking (client, testbuf, strlen (testbuf) + 1,
 406                                          TRUE, NULL, &error);
 407       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);
 408       g_assert_cmpint (len, ==, -1);
 409       g_clear_error (&error);
 410     }
 411
 412   g_socket_close (client, &error);
 413   g_assert_no_error (error);
 414   g_socket_close (data->server, &error);
 415   g_assert_no_error (error);
 416
 417   g_object_unref (data->server);
 418   g_object_unref (client);
 419
 420   g_slice_free (IPTestData, data);
 421 }
 422
 423 static void
 424 test_ipv4_async (void)
 425 {
 426   test_ip_async (G_SOCKET_FAMILY_IPV4);
 427 }
 428
 429 static void
 430 test_ipv6_async (void)
 431 {
 432   if (!ipv6_supported)
 433     {
 434       g_test_skip ("No support for IPv6");
 435       return;
 436     }
 437
 438   test_ip_async (G_SOCKET_FAMILY_IPV6);
 439 }
 440
 441 static const gchar testbuf2[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 442
 443 static void
 444 test_ip_sync (GSocketFamily family)
 445 {
 446   IPTestData *data;
 447   GError *error = NULL;
 448   GSocket *client;
 449   GSocketAddress *addr;
 450   gssize len;
 451   gchar buf[128];
 452
 453   data = create_server (family, echo_server_thread, FALSE, &error);
 454   if (error != NULL)
 455     {
 456       gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
 457       g_test_skip (message);
 458       g_free (message);
 459       g_clear_error (&error);
 460       return;
 461     }
 462
 463   addr = g_socket_get_local_address (data->server, &error);
 464   g_assert_no_error (error);
 465
 466   client = g_socket_new (family,
 467                          G_SOCKET_TYPE_STREAM,
 468                          G_SOCKET_PROTOCOL_DEFAULT,
 469                          &error);
 470   g_assert_no_error (error);
 471
 472   g_assert_cmpint (g_socket_get_family (client), ==, family);
 473   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
 474   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 475
 476   g_socket_set_blocking (client, TRUE);
 477   g_socket_set_timeout (client, 1);
 478
 479   g_socket_connect (client, addr, NULL, &error);
 480   g_assert_no_error (error);
 481   g_assert (g_socket_is_connected (client));
 482   g_object_unref (addr);
 483
 484   /* This adds 1 second to "make check", so let's just only do it once. */
 485   if (family == G_SOCKET_FAMILY_IPV4)
 486     {
 487       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 488       g_assert_cmpint (len, ==, -1);
 489       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
 490       g_clear_error (&error);
 491     }
 492
 493   len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
 494   g_assert_no_error (error);
 495   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 496
 497   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 498   g_assert_no_error (error);
 499   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 500
 501   g_assert_cmpstr (testbuf, ==, buf);
 502
 503   {
 504     GOutputVector v[7] = { { NULL, }, };
 505
 506     v[0].buffer = testbuf2 + 0;
 507     v[0].size = 3;
 508     v[1].buffer = testbuf2 + 3;
 509     v[1].size = 5;
 510     v[2].buffer = testbuf2 + 3 + 5;
 511     v[2].size = 0;
 512     v[3].buffer = testbuf2 + 3 + 5;
 513     v[3].size = 6;
 514     v[4].buffer = testbuf2 + 3 + 5 + 6;
 515     v[4].size = 2;
 516     v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;
 517     v[5].size = 1;
 518     v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;
 519     v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);
 520
 521     len = g_socket_send_message (client, NULL, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);
 522     g_assert_no_error (error);
 523     g_assert_cmpint (len, ==, strlen (testbuf2));
 524
 525     memset (buf, 0, sizeof (buf));
 526     len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 527     g_assert_no_error (error);
 528     g_assert_cmpint (len, ==, strlen (testbuf2));
 529     g_assert_cmpstr (testbuf2, ==, buf);
 530   }
 531
 532   g_socket_shutdown (client, FALSE, TRUE, &error);
 533   g_assert_no_error (error);
 534
 535   g_thread_join (data->thread);
 536
 537   if (family == G_SOCKET_FAMILY_IPV4)
 538     {
 539       /* Test that reading on a remote-closed socket gets back 0 bytes. */
 540       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 541       g_assert_no_error (error);
 542       g_assert_cmpint (len, ==, 0);
 543     }
 544   else
 545     {
 546       /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */
 547       len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
 548       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);
 549       g_assert_cmpint (len, ==, -1);
 550       g_clear_error (&error);
 551     }
 552
 553   g_socket_close (client, &error);
 554   g_assert_no_error (error);
 555   g_socket_close (data->server, &error);
 556   g_assert_no_error (error);
 557
 558   g_object_unref (data->server);
 559   g_object_unref (client);
 560
 561   g_slice_free (IPTestData, data);
 562 }
 563
 564 static void
 565 test_ipv4_sync (void)
 566 {
 567   test_ip_sync (G_SOCKET_FAMILY_IPV4);
 568 }
 569
 570 static void
 571 test_ipv6_sync (void)
 572 {
 573   if (!ipv6_supported)
 574     {
 575       g_test_skip ("No support for IPv6");
 576       return;
 577     }
 578
 579   test_ip_sync (G_SOCKET_FAMILY_IPV6);
 580 }
 581
 582 static void
 583 test_ip_sync_dgram (GSocketFamily family)
 584 {
 585   IPTestData *data;
 586   GError *error = NULL;
 587   GSocket *client;
 588   GSocketAddress *dest_addr;
 589   gssize len;
 590   gchar buf[128];
 591
 592   data = create_server_full (family, G_SOCKET_TYPE_DATAGRAM,
 593                              echo_server_dgram_thread, FALSE, &error);
 594   if (error != NULL)
 595     {
 596       gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
 597       g_test_skip (message);
 598       g_free (message);
 599       g_clear_error (&error);
 600       return;
 601     }
 602
 603   dest_addr = g_socket_get_local_address (data->server, &error);
 604
 605   client = g_socket_new (family,
 606                          G_SOCKET_TYPE_DATAGRAM,
 607                          G_SOCKET_PROTOCOL_DEFAULT,
 608                          &error);
 609   g_assert_no_error (error);
 610
 611   g_assert_cmpint (g_socket_get_family (client), ==, family);
 612   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);
 613   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 614
 615   g_socket_set_blocking (client, TRUE);
 616   g_socket_set_timeout (client, 1);
 617
 618   len = g_socket_send_to (client, dest_addr, testbuf, strlen (testbuf) + 1, NULL, &error);
 619   g_assert_no_error (error);
 620   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 621
 622   len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 623   g_assert_no_error (error);
 624   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 625
 626   g_assert_cmpstr (testbuf, ==, buf);
 627
 628   {
 629     GOutputMessage m[3] = { { NULL, }, };
 630     GInputMessage im[3] = { { NULL, }, };
 631     GOutputVector v[7] = { { NULL, }, };
 632     GInputVector iv[7] = { { NULL, }, };
 633
 634     v[0].buffer = testbuf2 + 0;
 635     v[0].size = 3;
 636     v[1].buffer = testbuf2 + 3;
 637     v[1].size = 5;
 638     v[2].buffer = testbuf2 + 3 + 5;
 639     v[2].size = 0;
 640     v[3].buffer = testbuf2 + 3 + 5;
 641     v[3].size = 6;
 642     v[4].buffer = testbuf2 + 3 + 5 + 6;
 643     v[4].size = 2;
 644     v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;
 645     v[5].size = 1;
 646     v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;
 647     v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);
 648
 649     iv[0].buffer = buf + 0;
 650     iv[0].size = 3;
 651     iv[1].buffer = buf + 3;
 652     iv[1].size = 5;
 653     iv[2].buffer = buf + 3 + 5;
 654     iv[2].size = 0;
 655     iv[3].buffer = buf + 3 + 5;
 656     iv[3].size = 6;
 657     iv[4].buffer = buf + 3 + 5 + 6;
 658     iv[4].size = 2;
 659     iv[5].buffer = buf + 3 + 5 + 6 + 2;
 660     iv[5].size = 1;
 661     iv[6].buffer = buf + 3 + 5 + 6 + 2 + 1;
 662     iv[6].size = sizeof (buf) - (3 + 5 + 6 + 2 + 1);
 663
 664     len = g_socket_send_message (client, dest_addr, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);
 665     g_assert_no_error (error);
 666     g_assert_cmpint (len, ==, strlen (testbuf2));
 667
 668     memset (buf, 0, sizeof (buf));
 669     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 670     g_assert_no_error (error);
 671     g_assert_cmpint (len, ==, strlen (testbuf2));
 672     g_assert_cmpstr (testbuf2, ==, buf);
 673
 674     m[0].vectors = &v[0];
 675     m[0].num_vectors = 1;
 676     m[0].address = dest_addr;
 677     m[1].vectors = &v[0];
 678     m[1].num_vectors = 6;
 679     m[1].address = dest_addr;
 680     m[2].vectors = &v[6];
 681     m[2].num_vectors = 1;
 682     m[2].address = dest_addr;
 683
 684     len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
 685     g_assert_no_error (error);
 686     g_assert_cmpint (len, ==, G_N_ELEMENTS (m));
 687     g_assert_cmpint (m[0].bytes_sent, ==, 3);
 688     g_assert_cmpint (m[1].bytes_sent, ==, 17);
 689     g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);
 690
 691     memset (buf, 0, sizeof (buf));
 692     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 693     g_assert_no_error (error);
 694     g_assert_cmpint (len, ==, 3);
 695
 696     memset (buf, 0, sizeof (buf));
 697     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 698     g_assert_no_error (error);
 699     /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */
 700     g_assert_cmpint (len, ==, 17);
 701     g_assert (memcmp (testbuf2, buf, 17) == 0);
 702
 703     memset (buf, 0, sizeof (buf));
 704     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 705     g_assert_no_error (error);
 706     g_assert_cmpint (len, ==, v[6].size);
 707     g_assert_cmpstr (buf, ==, v[6].buffer);
 708
 709     /* reset since we're re-using the message structs */
 710     m[0].bytes_sent = 0;
 711     m[1].bytes_sent = 0;
 712     m[2].bytes_sent = 0;
 713
 714     /* now try receiving multiple messages */
 715     len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
 716     g_assert_no_error (error);
 717     g_assert_cmpint (len, ==, G_N_ELEMENTS (m));
 718     g_assert_cmpint (m[0].bytes_sent, ==, 3);
 719     g_assert_cmpint (m[1].bytes_sent, ==, 17);
 720     g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);
 721
 722     im[0].vectors = &iv[0];
 723     im[0].num_vectors = 1;
 724     im[1].vectors = &iv[0];
 725     im[1].num_vectors = 6;
 726     im[2].vectors = &iv[6];
 727     im[2].num_vectors = 1;
 728
 729     memset (buf, 0, sizeof (buf));
 730     len = g_socket_receive_messages (client, im, G_N_ELEMENTS (im), 0,
 731                                      NULL, &error);
 732     g_assert_no_error (error);
 733     g_assert_cmpint (len, ==, G_N_ELEMENTS (im));
 734
 735     g_assert_cmpuint (im[0].bytes_received, ==, 3);
 736     /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */
 737     g_assert_cmpuint (im[1].bytes_received, ==, 17);
 738     g_assert_cmpuint (im[2].bytes_received, ==, v[6].size);
 739
 740     /* reset since we're re-using the message structs */
 741     m[0].bytes_sent = 0;
 742     m[1].bytes_sent = 0;
 743     m[2].bytes_sent = 0;
 744
 745     /* now try to generate an early return by omitting the destination address on [1] */
 746     m[1].address = NULL;
 747     len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
 748     g_assert_no_error (error);
 749     g_assert_cmpint (len, ==, 1);
 750
 751     g_assert_cmpint (m[0].bytes_sent, ==, 3);
 752     g_assert_cmpint (m[1].bytes_sent, ==, 0);
 753     g_assert_cmpint (m[2].bytes_sent, ==, 0);
 754
 755     /* reset since we're re-using the message structs */
 756     m[0].bytes_sent = 0;
 757     m[1].bytes_sent = 0;
 758     m[2].bytes_sent = 0;
 759
 760     /* now try to generate an error by omitting all destination addresses */
 761     m[0].address = NULL;
 762     m[1].address = NULL;
 763     m[2].address = NULL;
 764     len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
 765     /* This error code may vary between platforms and over time; it is not guaranteed API: */
 766 #ifndef G_OS_WIN32
 767     g_assert_error (error, G_IO_ERROR, G_IO_ERROR_FAILED);
 768 #else
 769     g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_CONNECTED);
 770 #endif
 771     g_clear_error (&error);
 772     g_assert_cmpint (len, ==, -1);
 773
 774     g_assert_cmpint (m[0].bytes_sent, ==, 0);
 775     g_assert_cmpint (m[1].bytes_sent, ==, 0);
 776     g_assert_cmpint (m[2].bytes_sent, ==, 0);
 777
 778     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 779     g_assert_cmpint (len, ==, 3);
 780   }
 781
 782   g_cancellable_cancel (data->cancellable);
 783
 784   g_thread_join (data->thread);
 785
 786   g_socket_close (client, &error);
 787   g_assert_no_error (error);
 788   g_socket_close (data->server, &error);
 789   g_assert_no_error (error);
 790
 791   g_object_unref (data->server);
 792   g_object_unref (data->cancellable);
 793   g_object_unref (client);
 794   g_object_unref (dest_addr);
 795
 796   g_slice_free (IPTestData, data);
 797 }
 798
 799 static void
 800 test_ipv4_sync_dgram (void)
 801 {
 802   test_ip_sync_dgram (G_SOCKET_FAMILY_IPV4);
 803 }
 804
 805 static void
 806 test_ipv6_sync_dgram (void)
 807 {
 808   if (!ipv6_supported)
 809     {
 810       g_test_skip ("No support for IPv6");
 811       return;
 812     }
 813
 814   test_ip_sync_dgram (G_SOCKET_FAMILY_IPV6);
 815 }
 816
 817 static gpointer
 818 cancellable_thread_cb (gpointer data)
 819 {
 820   GCancellable *cancellable = data;
 821
 822   g_usleep (0.1 * G_USEC_PER_SEC);
 823   g_cancellable_cancel (cancellable);
 824   g_object_unref (cancellable);
 825
 826   return NULL;
 827 }
 828
 829 static void
 830 test_ip_sync_dgram_timeouts (GSocketFamily family)
 831 {
 832   GError *error = NULL;
 833   GSocket *client = NULL;
 834   GCancellable *cancellable = NULL;
 835   GThread *cancellable_thread = NULL;
 836   gssize len;
 837 #ifdef G_OS_WIN32
 838   GInetAddress *iaddr;
 839   GSocketAddress *addr;
 840 #endif
 841
 842   client = g_socket_new (family,
 843                          G_SOCKET_TYPE_DATAGRAM,
 844                          G_SOCKET_PROTOCOL_DEFAULT,
 845                          &error);
 846   g_assert_no_error (error);
 847
 848   g_assert_cmpint (g_socket_get_family (client), ==, family);
 849   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);
 850   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 851
 852 #ifdef G_OS_WIN32
 853   /* Winsock can't recv() on unbound udp socket */
 854   iaddr = g_inet_address_new_loopback (family);
 855   addr = g_inet_socket_address_new (iaddr, 0);
 856   g_object_unref (iaddr);
 857   g_socket_bind (client, addr, TRUE, &error);
 858   g_object_unref (addr);
 859   g_assert_no_error (error);
 860 #endif
 861
 862   /* No overall timeout: test the per-operation timeouts instead. */
 863   g_socket_set_timeout (client, 0);
 864
 865   cancellable = g_cancellable_new ();
 866
 867   /* Check for timeouts when no server is running. */
 868   {
 869     gint64 start_time;
 870     GInputMessage im = { NULL, };
 871     GInputVector iv = { NULL, };
 872     guint8 buf[128];
 873
 874     iv.buffer = buf;
 875     iv.size = sizeof (buf);
 876
 877     im.vectors = &iv;
 878     im.num_vectors = 1;
 879
 880     memset (buf, 0, sizeof (buf));
 881
 882     /* Try a non-blocking read. */
 883     g_socket_set_blocking (client, FALSE);
 884     len = g_socket_receive_messages (client, &im, 1, 0  /* flags */,
 885                                      NULL, &error);
 886     g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
 887     g_assert_cmpint (len, ==, -1);
 888     g_clear_error (&error);
 889
 890     /* Try a timeout read. Can’t really validate the time taken more than
 891      * checking it’s positive. */
 892     g_socket_set_timeout (client, 1);
 893     g_socket_set_blocking (client, TRUE);
 894     start_time = g_get_monotonic_time ();
 895     len = g_socket_receive_messages (client, &im, 1, 0  /* flags */,
 896                                      NULL, &error);
 897     g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
 898     g_assert_cmpint (len, ==, -1);
 899     g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);
 900     g_clear_error (&error);
 901
 902     /* Try a blocking read, cancelled from another thread. */
 903     g_socket_set_timeout (client, 0);
 904     cancellable_thread = g_thread_new ("cancellable",
 905                                        cancellable_thread_cb,
 906                                        g_object_ref (cancellable));
 907
 908     start_time = g_get_monotonic_time ();
 909     len = g_socket_receive_messages (client, &im, 1, 0  /* flags */,
 910                                      cancellable, &error);
 911     g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
 912     g_assert_cmpint (len, ==, -1);
 913     g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);
 914     g_clear_error (&error);
 915
 916     g_thread_join (cancellable_thread);
 917   }
 918
 919   g_socket_close (client, &error);
 920   g_assert_no_error (error);
 921
 922   g_object_unref (client);
 923   g_object_unref (cancellable);
 924 }
 925
 926 static void
 927 test_ipv4_sync_dgram_timeouts (void)
 928 {
 929   test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV4);
 930 }
 931
 932 static void
 933 test_ipv6_sync_dgram_timeouts (void)
 934 {
 935   if (!ipv6_supported)
 936     {
 937       g_test_skip ("No support for IPv6");
 938       return;
 939     }
 940
 941   test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV6);
 942 }
 943
 944 static gpointer
 945 graceful_server_thread (gpointer user_data)
 946 {
 947   IPTestData *data = user_data;
 948   GSocket *sock;
 949   GError *error = NULL;
 950   gssize len;
 951
 952   sock = g_socket_accept (data->server, NULL, &error);
 953   g_assert_no_error (error);
 954
 955   len = g_socket_send (sock, testbuf, strlen (testbuf) + 1, NULL, &error);
 956   g_assert_no_error (error);
 957   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 958
 959   return sock;
 960 }
 961
 962 static void
 963 test_close_graceful (void)
 964 {
 965   GSocketFamily family = G_SOCKET_FAMILY_IPV4;
 966   IPTestData *data;
 967   GError *error = NULL;
 968   GSocket *client, *server;
 969   GSocketAddress *addr;
 970   gssize len;
 971   gchar buf[128];
 972
 973   data = create_server (family, graceful_server_thread, FALSE, &error);
 974   if (error != NULL)
 975     {
 976       gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
 977       g_test_skip (message);
 978       g_free (message);
 979       g_clear_error (&error);
 980       return;
 981     }
 982
 983   addr = g_socket_get_local_address (data->server, &error);
 984   g_assert_no_error (error);
 985
 986   client = g_socket_new (family,
 987                          G_SOCKET_TYPE_STREAM,
 988                          G_SOCKET_PROTOCOL_DEFAULT,
 989                          &error);
 990   g_assert_no_error (error);
 991
 992   g_assert_cmpint (g_socket_get_family (client), ==, family);
 993   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
 994   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 995
 996   g_socket_set_blocking (client, TRUE);
 997   g_socket_set_timeout (client, 1);
 998
 999   g_socket_connect (client, addr, NULL, &error);
1000   g_assert_no_error (error);
1001   g_assert (g_socket_is_connected (client));
1002   g_object_unref (addr);
1003
1004   server = g_thread_join (data->thread);
1005
1006   /* similar to g_tcp_connection_set_graceful_disconnect(), but explicit */
1007   g_socket_shutdown (server, FALSE, TRUE, &error);
1008   g_assert_no_error (error);
1009
1010   /* we must timeout */
1011   g_socket_condition_wait (client, G_IO_HUP, NULL, &error);
1012   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
1013   g_clear_error (&error);
1014
1015   /* check that the remaining data is received */
1016   len = g_socket_receive (client, buf, strlen (testbuf) + 1, NULL, &error);
1017   g_assert_no_error (error);
1018   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1019
1020   /* and only then the connection is closed */
1021   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
1022   g_assert_no_error (error);
1023   g_assert_cmpint (len, ==, 0);
1024
1025   g_socket_close (server, &error);
1026   g_assert_no_error (error);
1027
1028   g_socket_close (client, &error);
1029   g_assert_no_error (error);
1030
1031   g_object_unref (server);
1032   g_object_unref (data->server);
1033   g_object_unref (client);
1034
1035   g_slice_free (IPTestData, data);
1036 }
1037
1038 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
1039 static gpointer
1040 v4mapped_server_thread (gpointer user_data)
1041 {
1042   IPTestData *data = user_data;
1043   GSocket *sock;
1044   GError *error = NULL;
1045   GSocketAddress *addr;
1046
1047   sock = g_socket_accept (data->server, NULL, &error);
1048   g_assert_no_error (error);
1049
1050   g_assert_cmpint (g_socket_get_family (sock), ==, G_SOCKET_FAMILY_IPV6);
1051
1052   addr = g_socket_get_local_address (sock, &error);
1053   g_assert_no_error (error);
1054   g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
1055   g_object_unref (addr);
1056
1057   addr = g_socket_get_remote_address (sock, &error);
1058   g_assert_no_error (error);
1059   g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
1060   g_object_unref (addr);
1061
1062   g_socket_close (sock, &error);
1063   g_assert_no_error (error);
1064   g_object_unref (sock);
1065   return NULL;
1066 }
1067
1068 static void
1069 test_ipv6_v4mapped (void)
1070 {
1071   IPTestData *data;
1072   GError *error = NULL;
1073   GSocket *client;
1074   GSocketAddress *addr, *v4addr;
1075   GInetAddress *iaddr;
1076
1077   if (!ipv6_supported)
1078     {
1079       g_test_skip ("No support for IPv6");
1080       return;
1081     }
1082
1083   data = create_server (G_SOCKET_FAMILY_IPV6, v4mapped_server_thread, TRUE, &error);
1084   if (error != NULL)
1085     {
1086       gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
1087       g_test_skip (message);
1088       g_free (message);
1089       g_clear_error (&error);
1090       return;
1091     }
1092
1093   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1094                          G_SOCKET_TYPE_STREAM,
1095                          G_SOCKET_PROTOCOL_DEFAULT,
1096                          &error);
1097   g_assert_no_error (error);
1098
1099   g_socket_set_blocking (client, TRUE);
1100   g_socket_set_timeout (client, 1);
1101
1102   addr = g_socket_get_local_address (data->server, &error);
1103   g_assert_no_error (error);
1104   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1105   v4addr = g_inet_socket_address_new (iaddr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)));
1106   g_object_unref (iaddr);
1107   g_object_unref (addr);
1108
1109   g_socket_connect (client, v4addr, NULL, &error);
1110   g_assert_no_error (error);
1111   g_assert (g_socket_is_connected (client));
1112
1113   g_thread_join (data->thread);
1114
1115   g_socket_close (client, &error);
1116   g_assert_no_error (error);
1117   g_socket_close (data->server, &error);
1118   g_assert_no_error (error);
1119
1120   g_object_unref (data->server);
1121   g_object_unref (client);
1122   g_object_unref (v4addr);
1123
1124   g_slice_free (IPTestData, data);
1125 }
1126 #endif
1127
1128 static void
1129 test_timed_wait (void)
1130 {
1131   IPTestData *data;
1132   GError *error = NULL;
1133   GSocket *client;
1134   GSocketAddress *addr;
1135   gint64 start_time;
1136   gint poll_duration;
1137
1138   if (!g_test_thorough ())
1139     {
1140       g_test_skip ("Not running timing heavy test");
1141       return;
1142     }
1143
1144   data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE, &error);
1145   if (error != NULL)
1146     {
1147       gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
1148       g_test_skip (message);
1149       g_free (message);
1150       g_clear_error (&error);
1151       return;
1152     }
1153
1154   addr = g_socket_get_local_address (data->server, &error);
1155   g_assert_no_error (error);
1156
1157   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1158                          G_SOCKET_TYPE_STREAM,
1159                          G_SOCKET_PROTOCOL_DEFAULT,
1160                          &error);
1161   g_assert_no_error (error);
1162
1163   g_socket_set_blocking (client, TRUE);
1164   g_socket_set_timeout (client, 1);
1165
1166   g_socket_connect (client, addr, NULL, &error);
1167   g_assert_no_error (error);
1168   g_object_unref (addr);
1169
1170   start_time = g_get_monotonic_time ();
1171   g_socket_condition_timed_wait (client, G_IO_IN, 100000 /* 100 ms */,
1172                                  NULL, &error);
1173   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
1174   g_clear_error (&error);
1175   poll_duration = g_get_monotonic_time () - start_time;
1176
1177   g_assert_cmpint (poll_duration, >=, 98000);
1178   g_assert_cmpint (poll_duration, <, 112000);
1179
1180   g_socket_close (client, &error);
1181   g_assert_no_error (error);
1182
1183   g_thread_join (data->thread);
1184
1185   g_socket_close (data->server, &error);
1186   g_assert_no_error (error);
1187
1188   g_object_unref (data->server);
1189   g_object_unref (client);
1190
1191   g_slice_free (IPTestData, data);
1192 }
1193
1194 static int
1195 duplicate_fd (int fd)
1196 {
1197 #ifdef G_OS_WIN32
1198   HANDLE newfd;
1199
1200   if (!DuplicateHandle (GetCurrentProcess (),
1201                         (HANDLE)fd,
1202                         GetCurrentProcess (),
1203                         &newfd,
1204                         0,
1205                         FALSE,
1206                         DUPLICATE_SAME_ACCESS))
1207     {
1208       return -1;
1209     }
1210
1211   return (int)newfd;
1212 #else
1213   return dup (fd);
1214 #endif
1215 }
1216
1217 static void
1218 test_fd_reuse (void)
1219 {
1220   IPTestData *data;
1221   GError *error = NULL;
1222   GSocket *client;
1223   GSocket *client2;
1224   GSocketAddress *addr;
1225   int fd;
1226   gssize len;
1227   gchar buf[128];
1228
1229   g_test_bug ("741707");
1230
1231   data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE, &error);
1232   if (error != NULL)
1233     {
1234       gchar *message = g_strdup_printf ("Failed to create server: %s", error->message);
1235       g_test_skip (message);
1236       g_free (message);
1237       g_clear_error (&error);
1238       return;
1239     }
1240
1241   addr = g_socket_get_local_address (data->server, &error);
1242   g_assert_no_error (error);
1243
1244   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1245                          G_SOCKET_TYPE_STREAM,
1246                          G_SOCKET_PROTOCOL_DEFAULT,
1247                          &error);
1248   g_assert_no_error (error);
1249
1250   g_socket_set_blocking (client, TRUE);
1251   g_socket_set_timeout (client, 1);
1252
1253   g_socket_connect (client, addr, NULL, &error);
1254   g_assert_no_error (error);
1255   g_assert (g_socket_is_connected (client));
1256   g_object_unref (addr);
1257
1258   /* we have to dup otherwise the fd gets closed twice on unref */
1259   fd = duplicate_fd (g_socket_get_fd (client));
1260   client2 = g_socket_new_from_fd (fd, &error);
1261   g_assert_no_error (error);
1262
1263   g_assert_cmpint (g_socket_get_family (client2), ==, g_socket_get_family (client));
1264   g_assert_cmpint (g_socket_get_socket_type (client2), ==, g_socket_get_socket_type (client));
1265   g_assert_cmpint (g_socket_get_protocol (client2), ==, G_SOCKET_PROTOCOL_TCP);
1266
1267   len = g_socket_send (client2, testbuf, strlen (testbuf) + 1, NULL, &error);
1268   g_assert_no_error (error);
1269   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1270
1271   len = g_socket_receive (client2, buf, sizeof (buf), NULL, &error);
1272   g_assert_no_error (error);
1273   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1274
1275   g_assert_cmpstr (testbuf, ==, buf);
1276
1277   g_socket_shutdown (client, FALSE, TRUE, &error);
1278   g_assert_no_error (error);
1279   /* The semantics of dup()+shutdown() are ambiguous; this call will succeed
1280    * on Linux, but return ENOTCONN on OS X.
1281    */
1282   g_socket_shutdown (client2, FALSE, TRUE, NULL);
1283
1284   g_thread_join (data->thread);
1285
1286   g_socket_close (client, &error);
1287   g_assert_no_error (error);
1288   g_socket_close (client2, &error);
1289   g_assert_no_error (error);
1290   g_socket_close (data->server, &error);
1291   g_assert_no_error (error);
1292
1293   g_assert_cmpint (g_socket_get_fd (client), ==, -1);
1294   g_assert_cmpint (g_socket_get_fd (client2), ==, -1);
1295   g_assert_cmpint (g_socket_get_fd (data->server), ==, -1);
1296
1297   g_object_unref (data->server);
1298   g_object_unref (client);
1299   g_object_unref (client2);
1300
1301   g_slice_free (IPTestData, data);
1302 }
1303
1304 static void
1305 test_sockaddr (void)
1306 {
1307   struct sockaddr_in6 sin6, gsin6;
1308   GSocketAddress *saddr;
1309   GInetSocketAddress *isaddr;
1310   GInetAddress *iaddr;
1311   GError *error = NULL;
1312
1313   memset (&sin6, 0, sizeof (sin6));
1314   sin6.sin6_family = AF_INET6;
1315   sin6.sin6_addr = in6addr_loopback;
1316   sin6.sin6_port = g_htons (42);
1317   sin6.sin6_scope_id = 17;
1318   sin6.sin6_flowinfo = 1729;
1319
1320   saddr = g_socket_address_new_from_native (&sin6, sizeof (sin6));
1321   g_assert (G_IS_INET_SOCKET_ADDRESS (saddr));
1322
1323   isaddr = G_INET_SOCKET_ADDRESS (saddr);
1324   iaddr = g_inet_socket_address_get_address (isaddr);
1325   g_assert_cmpint (g_inet_address_get_family (iaddr), ==, G_SOCKET_FAMILY_IPV6);
1326   g_assert (g_inet_address_get_is_loopback (iaddr));
1327
1328   g_assert_cmpint (g_inet_socket_address_get_port (isaddr), ==, 42);
1329   g_assert_cmpint (g_inet_socket_address_get_scope_id (isaddr), ==, 17);
1330   g_assert_cmpint (g_inet_socket_address_get_flowinfo (isaddr), ==, 1729);
1331
1332   g_socket_address_to_native (saddr, &gsin6, sizeof (gsin6), &error);
1333   g_assert_no_error (error);
1334
1335   g_assert (memcmp (&sin6.sin6_addr, &gsin6.sin6_addr, sizeof (struct in6_addr)) == 0);
1336   g_assert_cmpint (sin6.sin6_port, ==, gsin6.sin6_port);
1337   g_assert_cmpint (sin6.sin6_scope_id, ==, gsin6.sin6_scope_id);
1338   g_assert_cmpint (sin6.sin6_flowinfo, ==, gsin6.sin6_flowinfo);
1339
1340   g_object_unref (saddr);
1341 }
1342
1343 #ifdef G_OS_UNIX
1344 static void
1345 test_unix_from_fd (void)
1346 {
1347   gint fd;
1348   GError *error;
1349   GSocket *s;
1350
1351   fd = socket (AF_UNIX, SOCK_STREAM, 0);
1352   g_assert_cmpint (fd, !=, -1);
1353
1354   error = NULL;
1355   s = g_socket_new_from_fd (fd, &error);
1356   g_assert_no_error (error);
1357   g_assert_cmpint (g_socket_get_family (s), ==, G_SOCKET_FAMILY_UNIX);
1358   g_assert_cmpint (g_socket_get_socket_type (s), ==, G_SOCKET_TYPE_STREAM);
1359   g_assert_cmpint (g_socket_get_protocol (s), ==, G_SOCKET_PROTOCOL_DEFAULT);
1360   g_object_unref (s);
1361 }
1362
1363 static void
1364 test_unix_connection (void)
1365 {
1366   gint fd;
1367   GError *error;
1368   GSocket *s;
1369   GSocketConnection *c;
1370
1371   fd = socket (AF_UNIX, SOCK_STREAM, 0);
1372   g_assert_cmpint (fd, !=, -1);
1373
1374   error = NULL;
1375   s = g_socket_new_from_fd (fd, &error);
1376   g_assert_no_error (error);
1377   c = g_socket_connection_factory_create_connection (s);
1378   g_assert (G_IS_UNIX_CONNECTION (c));
1379   g_object_unref (c);
1380   g_object_unref (s);
1381 }
1382
1383 static GSocketConnection *
1384 create_connection_for_fd (int fd)
1385 {
1386   GError *err = NULL;
1387   GSocket *socket;
1388   GSocketConnection *connection;
1389
1390   socket = g_socket_new_from_fd (fd, &err);
1391   g_assert_no_error (err);
1392   g_assert (G_IS_SOCKET (socket));
1393   connection = g_socket_connection_factory_create_connection (socket);
1394   g_assert (G_IS_UNIX_CONNECTION (connection));
1395   g_object_unref (socket);
1396   return connection;
1397 }
1398
1399 #define TEST_DATA "failure to say failure to say 'i love gnome-panel!'."
1400
1401 static void
1402 test_unix_connection_ancillary_data (void)
1403 {
1404   GError *err = NULL;
1405   gint pv[2], sv[3];
1406   gint status, fd, len;
1407   char buffer[1024];
1408   pid_t pid;
1409
1410   status = pipe (pv);
1411   g_assert_cmpint (status, ==, 0);
1412
1413   status = socketpair (PF_UNIX, SOCK_STREAM, 0, sv);
1414   g_assert_cmpint (status, ==, 0);
1415
1416   pid = fork ();
1417   g_assert_cmpint (pid, >=, 0);
1418
1419   /* Child: close its copy of the write end of the pipe, receive it
1420    * again from the parent over the socket, and write some text to it.
1421    *
1422    * Parent: send the write end of the pipe (still open for the
1423    * parent) over the socket, close it, and read some text from the
1424    * read end of the pipe.
1425    */
1426   if (pid == 0)
1427     {
1428       GSocketConnection *connection;
1429
1430       close (sv[1]);
1431       connection = create_connection_for_fd (sv[0]);
1432
1433       status = close (pv[1]);
1434       g_assert_cmpint (status, ==, 0);
1435
1436       err = NULL;
1437       fd = g_unix_connection_receive_fd (G_UNIX_CONNECTION (connection), NULL,
1438                                          &err);
1439       g_assert_no_error (err);
1440       g_assert_cmpint (fd, >, -1);
1441       g_object_unref (connection);
1442
1443       do
1444         len = write (fd, TEST_DATA, sizeof (TEST_DATA));
1445       while (len == -1 && errno == EINTR);
1446       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1447       exit (0);
1448     }
1449   else
1450     {
1451       GSocketConnection *connection;
1452
1453       close (sv[0]);
1454       connection = create_connection_for_fd (sv[1]);
1455
1456       err = NULL;
1457       g_unix_connection_send_fd (G_UNIX_CONNECTION (connection), pv[1], NULL,
1458                                  &err);
1459       g_assert_no_error (err);
1460       g_object_unref (connection);
1461
1462       status = close (pv[1]);
1463       g_assert_cmpint (status, ==, 0);
1464
1465       memset (buffer, 0xff, sizeof buffer);
1466       do
1467         len = read (pv[0], buffer, sizeof buffer);
1468       while (len == -1 && errno == EINTR);
1469
1470       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1471       g_assert_cmpstr (buffer, ==, TEST_DATA);
1472
1473       waitpid (pid, &status, 0);
1474       g_assert (WIFEXITED (status));
1475       g_assert_cmpint (WEXITSTATUS (status), ==, 0);
1476     }
1477
1478   /* TODO: add test for g_unix_connection_send_credentials() and
1479    * g_unix_connection_receive_credentials().
1480    */
1481 }
1482
1483 static gboolean
1484 postmortem_source_cb (GSocket      *socket,
1485                       GIOCondition  condition,
1486                       gpointer      user_data)
1487 {
1488   gboolean *been_here = user_data;
1489
1490   g_assert_cmpint (condition, ==, G_IO_NVAL);
1491
1492   *been_here = TRUE;
1493   return FALSE;
1494 }
1495
1496 static void
1497 test_source_postmortem (void)
1498 {
1499   GMainContext *context;
1500   GSocket *socket;
1501   GSource *source;
1502   GError *error = NULL;
1503   gboolean callback_visited = FALSE;
1504
1505   socket = g_socket_new (G_SOCKET_FAMILY_UNIX, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, &error);
1506   g_assert_no_error (error);
1507
1508   context = g_main_context_new ();
1509
1510   source = g_socket_create_source (socket, G_IO_IN, NULL);
1511   g_source_set_callback (source, (GSourceFunc) postmortem_source_cb,
1512                          &callback_visited, NULL);
1513   g_source_attach (source, context);
1514   g_source_unref (source);
1515
1516   g_socket_close (socket, &error);
1517   g_assert_no_error (error);
1518   g_object_unref (socket);
1519
1520   /* Test that, after a socket is closed, its source callback should be called
1521    * exactly once. */
1522   g_main_context_iteration (context, FALSE);
1523   g_assert (callback_visited);
1524   g_assert (!g_main_context_pending (context));
1525
1526   g_main_context_unref (context);
1527 }
1528
1529 #endif /* G_OS_UNIX */
1530
1531 static void
1532 test_reuse_tcp (void)
1533 {
1534   GSocket *sock1, *sock2;
1535   GError *error = NULL;
1536   GInetAddress *iaddr;
1537   GSocketAddress *addr;
1538
1539   sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1540                         G_SOCKET_TYPE_STREAM,
1541                         G_SOCKET_PROTOCOL_DEFAULT,
1542                         &error);
1543   g_assert_no_error (error);
1544
1545   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1546   addr = g_inet_socket_address_new (iaddr, 0);
1547   g_object_unref (iaddr);
1548   g_socket_bind (sock1, addr, TRUE, &error);
1549   g_object_unref (addr);
1550   g_assert_no_error (error);
1551
1552   g_socket_listen (sock1, &error);
1553   g_assert_no_error (error);
1554
1555   sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1556                         G_SOCKET_TYPE_STREAM,
1557                         G_SOCKET_PROTOCOL_DEFAULT,
1558                         &error);
1559   g_assert_no_error (error);
1560
1561   addr = g_socket_get_local_address (sock1, &error);
1562   g_assert_no_error (error);
1563   g_socket_bind (sock2, addr, TRUE, &error);
1564   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_ADDRESS_IN_USE);
1565   g_clear_error (&error);
1566   g_object_unref (addr);
1567
1568   g_object_unref (sock1);
1569   g_object_unref (sock2);
1570 }
1571
1572 static void
1573 test_reuse_udp (void)
1574 {
1575   GSocket *sock1, *sock2;
1576   GError *error = NULL;
1577   GInetAddress *iaddr;
1578   GSocketAddress *addr;
1579
1580   sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1581                         G_SOCKET_TYPE_DATAGRAM,
1582                         G_SOCKET_PROTOCOL_DEFAULT,
1583                         &error);
1584   g_assert_no_error (error);
1585
1586   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1587   addr = g_inet_socket_address_new (iaddr, 0);
1588   g_object_unref (iaddr);
1589   g_socket_bind (sock1, addr, TRUE, &error);
1590   g_object_unref (addr);
1591   g_assert_no_error (error);
1592
1593   sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1594                         G_SOCKET_TYPE_DATAGRAM,
1595                         G_SOCKET_PROTOCOL_DEFAULT,
1596                         &error);
1597   g_assert_no_error (error);
1598
1599   addr = g_socket_get_local_address (sock1, &error);
1600   g_assert_no_error (error);
1601   g_socket_bind (sock2, addr, TRUE, &error);
1602   g_object_unref (addr);
1603   g_assert_no_error (error);
1604
1605   g_object_unref (sock1);
1606   g_object_unref (sock2);
1607 }
1608
1609 static void
1610 test_get_available (gconstpointer user_data)
1611 {
1612   GSocketType socket_type = GPOINTER_TO_UINT (user_data);
1613   GError *err = NULL;
1614   GSocket *listener, *server, *client;
1615   GInetAddress *addr;
1616   GSocketAddress *saddr, *boundaddr;
1617   gchar data[] = "0123456789abcdef";
1618   gchar buf[34];
1619   gssize nread;
1620
1621   listener = g_socket_new (G_SOCKET_FAMILY_IPV4,
1622                            socket_type,
1623                            G_SOCKET_PROTOCOL_DEFAULT,
1624                            &err);
1625   g_assert_no_error (err);
1626   g_assert (G_IS_SOCKET (listener));
1627
1628   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1629                          socket_type,
1630                          G_SOCKET_PROTOCOL_DEFAULT,
1631                          &err);
1632   g_assert_no_error (err);
1633   g_assert (G_IS_SOCKET (client));
1634
1635   if (socket_type == G_SOCKET_TYPE_STREAM)
1636     {
1637       g_socket_set_option (client, IPPROTO_TCP, TCP_NODELAY, TRUE, &err);
1638       g_assert_no_error (err);
1639     }
1640
1641   addr = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
1642   saddr = g_inet_socket_address_new (addr, 0);
1643
1644   g_socket_bind (listener, saddr, TRUE, &err);
1645   g_assert_no_error (err);
1646   g_object_unref (saddr);
1647   g_object_unref (addr);
1648
1649   boundaddr = g_socket_get_local_address (listener, &err);
1650   g_assert_no_error (err);
1651
1652   addr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1653   saddr = g_inet_socket_address_new (addr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (boundaddr)));
1654   g_object_unref (addr);
1655   g_object_unref (boundaddr);
1656
1657   if (socket_type == G_SOCKET_TYPE_STREAM)
1658     {
1659       g_socket_listen (listener, &err);
1660       g_assert_no_error (err);
1661       g_socket_connect (client, saddr, NULL, &err);
1662       g_assert_no_error (err);
1663
1664       server = g_socket_accept (listener, NULL, &err);
1665       g_assert_no_error (err);
1666       g_socket_set_blocking (server, FALSE);
1667       g_object_unref (listener);
1668     }
1669   else
1670     server = listener;
1671
1672   g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1673   g_assert_no_error (err);
1674
1675   while (!g_socket_condition_wait (server, G_IO_IN, NULL, NULL))
1676     ;
1677   g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1678
1679   g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1680   g_assert_no_error (err);
1681
1682   /* We need to wait until the data has actually been copied into the
1683    * server socket's buffers, but g_socket_condition_wait() won't help
1684    * here since the socket is definitely already readable. So there's
1685    * a race condition in checking its available bytes. In the TCP
1686    * case, we poll for a bit until the new data shows up. In the UDP
1687    * case, there's not much we can do, but at least the failure mode
1688    * is passes-when-it-shouldn't, not fails-when-it-shouldn't.
1689    */
1690   if (socket_type == G_SOCKET_TYPE_STREAM)
1691     {
1692       int tries;
1693
1694       for (tries = 0; tries < 100; tries++)
1695         {
1696           if (g_socket_get_available_bytes (server) > sizeof (data))
1697             break;
1698           g_usleep (100000);
1699         }
1700
1701       g_assert_cmpint (g_socket_get_available_bytes (server), ==, 2 * sizeof (data));
1702     }
1703   else
1704     {
1705       g_usleep (100000);
1706       g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1707     }
1708
1709   g_assert_cmpint (sizeof (buf), >=, 2 * sizeof (data));
1710   nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1711   g_assert_no_error (err);
1712
1713   if (socket_type == G_SOCKET_TYPE_STREAM)
1714     {
1715       g_assert_cmpint (nread, ==, 2 * sizeof (data));
1716       g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1717     }
1718   else
1719     {
1720       g_assert_cmpint (nread, ==, sizeof (data));
1721       g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1722     }
1723
1724   nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1725   if (socket_type == G_SOCKET_TYPE_STREAM)
1726     {
1727       g_assert_cmpint (nread, ==, -1);
1728       g_assert_error (err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
1729       g_clear_error (&err);
1730     }
1731   else
1732     {
1733       g_assert_cmpint (nread, ==, sizeof (data));
1734       g_assert_no_error (err);
1735     }
1736
1737   g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1738
1739   g_socket_close (server, &err);
1740   g_assert_no_error (err);
1741
1742   g_object_unref (saddr);
1743   g_object_unref (server);
1744   g_object_unref (client);
1745 }
1746
1747 typedef struct {
1748   GInputStream *is;
1749   GOutputStream *os;
1750   const guint8 *write_data;
1751   guint8 *read_data;
1752 } TestReadWriteData;
1753
1754 static gpointer
1755 test_read_write_write_thread (gpointer user_data)
1756 {
1757   TestReadWriteData *data = user_data;
1758   gsize bytes_written;
1759   GError *error = NULL;
1760   gboolean res;
1761
1762   res = g_output_stream_write_all (data->os, data->write_data, 1024, &bytes_written, NULL, &error);
1763   g_assert_true (res);
1764   g_assert_no_error (error);
1765   g_assert_cmpint (bytes_written, ==, 1024);
1766
1767   return NULL;
1768 }
1769
1770 static gpointer
1771 test_read_write_read_thread (gpointer user_data)
1772 {
1773   TestReadWriteData *data = user_data;
1774   gsize bytes_read;
1775   GError *error = NULL;
1776   gboolean res;
1777
1778   res = g_input_stream_read_all (data->is, data->read_data, 1024, &bytes_read, NULL, &error);
1779   g_assert_true (res);
1780   g_assert_no_error (error);
1781   g_assert_cmpint (bytes_read, ==, 1024);
1782
1783   return NULL;
1784 }
1785
1786 static gpointer
1787 test_read_write_writev_thread (gpointer user_data)
1788 {
1789   TestReadWriteData *data = user_data;
1790   gsize bytes_written;
1791   GError *error = NULL;
1792   gboolean res;
1793   GOutputVector vectors[3];
1794
1795   vectors[0].buffer = data->write_data;
1796   vectors[0].size = 256;
1797   vectors[1].buffer = data->write_data + 256;
1798   vectors[1].size = 256;
1799   vectors[2].buffer = data->write_data + 512;
1800   vectors[2].size = 512;
1801
1802   res = g_output_stream_writev_all (data->os, vectors, G_N_ELEMENTS (vectors), &bytes_written, NULL, &error);
1803   g_assert_true (res);
1804   g_assert_no_error (error);
1805   g_assert_cmpint (bytes_written, ==, 1024);
1806
1807   return NULL;
1808 }
1809
1810 /* test if normal read/write/writev via the GSocket*Streams works on TCP sockets */
1811 static void
1812 test_read_write (gconstpointer user_data)
1813 {
1814   gboolean writev = GPOINTER_TO_INT (user_data);
1815   GError *err = NULL;
1816   GSocket *listener, *server, *client;
1817   GInetAddress *addr;
1818   GSocketAddress *saddr, *boundaddr;
1819   TestReadWriteData data;
1820   guint8 data_write[1024], data_read[1024];
1821   GSocketConnection *server_stream, *client_stream;
1822   GThread *write_thread, *read_thread;
1823   guint i;
1824
1825   listener = g_socket_new (G_SOCKET_FAMILY_IPV4,
1826                            G_SOCKET_TYPE_STREAM,
1827                            G_SOCKET_PROTOCOL_DEFAULT,
1828                            &err);
1829   g_assert_no_error (err);
1830   g_assert (G_IS_SOCKET (listener));
1831
1832   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1833                          G_SOCKET_TYPE_STREAM,
1834                          G_SOCKET_PROTOCOL_DEFAULT,
1835                          &err);
1836   g_assert_no_error (err);
1837   g_assert (G_IS_SOCKET (client));
1838
1839   addr = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
1840   saddr = g_inet_socket_address_new (addr, 0);
1841
1842   g_socket_bind (listener, saddr, TRUE, &err);
1843   g_assert_no_error (err);
1844   g_object_unref (saddr);
1845   g_object_unref (addr);
1846
1847   boundaddr = g_socket_get_local_address (listener, &err);
1848   g_assert_no_error (err);
1849
1850   g_socket_listen (listener, &err);
1851   g_assert_no_error (err);
1852
1853   addr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1854   saddr = g_inet_socket_address_new (addr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (boundaddr)));
1855   g_object_unref (addr);
1856   g_object_unref (boundaddr);
1857
1858   g_socket_connect (client, saddr, NULL, &err);
1859   g_assert_no_error (err);
1860
1861   server = g_socket_accept (listener, NULL, &err);
1862   g_assert_no_error (err);
1863   g_socket_set_blocking (server, FALSE);
1864   g_object_unref (listener);
1865
1866   server_stream = g_socket_connection_factory_create_connection (server);
1867   g_assert_nonnull (server_stream);
1868   client_stream = g_socket_connection_factory_create_connection (client);
1869   g_assert_nonnull (client_stream);
1870
1871   for (i = 0; i < sizeof (data_write); i++)
1872     data_write[i] = i;
1873
1874   data.is = g_io_stream_get_input_stream (G_IO_STREAM (server_stream));
1875   data.os = g_io_stream_get_output_stream (G_IO_STREAM (client_stream));
1876   data.read_data = data_read;
1877   data.write_data = data_write;
1878
1879   if (writev)
1880     write_thread = g_thread_new ("writer", test_read_write_writev_thread, &data);
1881   else
1882     write_thread = g_thread_new ("writer", test_read_write_write_thread, &data);
1883   read_thread = g_thread_new ("reader", test_read_write_read_thread, &data);
1884
1885   g_thread_join (write_thread);
1886   g_thread_join (read_thread);
1887
1888   g_assert_cmpmem (data_write, sizeof data_write, data_read, sizeof data_read);
1889
1890   g_socket_close (server, &err);
1891   g_assert_no_error (err);
1892
1893   g_object_unref (server_stream);
1894   g_object_unref (client_stream);
1895
1896   g_object_unref (saddr);
1897   g_object_unref (server);
1898   g_object_unref (client);
1899 }
1900
1901 int
1902 main (int   argc,
1903       char *argv[])
1904 {
1905   GSocket *sock;
1906   GError *error = NULL;
1907
1908   g_test_init (&argc, &argv, NULL);
1909   g_test_bug_base ("https://bugzilla.gnome.org/");
1910
1911   sock = g_socket_new (G_SOCKET_FAMILY_IPV6,
1912                        G_SOCKET_TYPE_STREAM,
1913                        G_SOCKET_PROTOCOL_DEFAULT,
1914                        &error);
1915   if (sock != NULL)
1916     {
1917       ipv6_supported = TRUE;
1918       g_object_unref (sock);
1919     }
1920   else
1921     {
1922       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1923       g_clear_error (&error);
1924     }
1925
1926   g_test_add_func ("/socket/ipv4_sync", test_ipv4_sync);
1927   g_test_add_func ("/socket/ipv4_async", test_ipv4_async);
1928   g_test_add_func ("/socket/ipv6_sync", test_ipv6_sync);
1929   g_test_add_func ("/socket/ipv6_async", test_ipv6_async);
1930   g_test_add_func ("/socket/ipv4_sync/datagram", test_ipv4_sync_dgram);
1931   g_test_add_func ("/socket/ipv4_sync/datagram/timeouts", test_ipv4_sync_dgram_timeouts);
1932   g_test_add_func ("/socket/ipv6_sync/datagram", test_ipv6_sync_dgram);
1933   g_test_add_func ("/socket/ipv6_sync/datagram/timeouts", test_ipv6_sync_dgram_timeouts);
1934 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
1935   g_test_add_func ("/socket/ipv6_v4mapped", test_ipv6_v4mapped);
1936 #endif
1937   g_test_add_func ("/socket/close_graceful", test_close_graceful);
1938   g_test_add_func ("/socket/timed_wait", test_timed_wait);
1939   g_test_add_func ("/socket/fd_reuse", test_fd_reuse);
1940   g_test_add_func ("/socket/address", test_sockaddr);
1941 #ifdef G_OS_UNIX
1942   g_test_add_func ("/socket/unix-from-fd", test_unix_from_fd);
1943   g_test_add_func ("/socket/unix-connection", test_unix_connection);
1944   g_test_add_func ("/socket/unix-connection-ancillary-data", test_unix_connection_ancillary_data);
1945   g_test_add_func ("/socket/source-postmortem", test_source_postmortem);
1946 #endif
1947   g_test_add_func ("/socket/reuse/tcp", test_reuse_tcp);
1948   g_test_add_func ("/socket/reuse/udp", test_reuse_udp);
1949   g_test_add_data_func ("/socket/get_available/datagram", GUINT_TO_POINTER (G_SOCKET_TYPE_DATAGRAM),
1950                         test_get_available);
1951   g_test_add_data_func ("/socket/get_available/stream", GUINT_TO_POINTER (G_SOCKET_TYPE_STREAM),
1952                         test_get_available);
1953   g_test_add_data_func ("/socket/read_write", GUINT_TO_POINTER (FALSE),
1954                         test_read_write);
1955   g_test_add_data_func ("/socket/read_writev", GUINT_TO_POINTER (TRUE),
1956                         test_read_write);
1957
1958   return g_test_run();
1959 }
1960