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 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 {
 116   IPTestData *data;
 117   GSocket *server;
 118   GError *error = NULL;
 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   g_assert_no_error (error);
 130
 131   g_assert_cmpint (g_socket_get_family (server), ==, family);
 132   g_assert_cmpint (g_socket_get_socket_type (server), ==, socket_type);
 133   g_assert_cmpint (g_socket_get_protocol (server), ==, G_SOCKET_PROTOCOL_DEFAULT);
 134
 135   g_socket_set_blocking (server, TRUE);
 136
 137 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
 138   if (v4mapped)
 139     {
 140       g_socket_set_option (data->server, IPPROTO_IPV6, IPV6_V6ONLY, FALSE, NULL);
 141       if (! g_socket_speaks_ipv4 (data->server))
 142         {
 143           g_object_unref (data->server);
 144           g_slice_free (IPTestData, data);
 145           return NULL;
 146         }
 147     }
 148 #endif
 149
 150   if (v4mapped)
 151     iaddr = g_inet_address_new_any (family);
 152   else
 153     iaddr = g_inet_address_new_loopback (family);
 154   addr = g_inet_socket_address_new (iaddr, 0);
 155   g_object_unref (iaddr);
 156
 157   g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), ==, 0);
 158   g_socket_bind (server, addr, TRUE, &error);
 159   g_assert_no_error (error);
 160   g_object_unref (addr);
 161
 162   addr = g_socket_get_local_address (server, &error);
 163   g_assert_no_error (error);
 164   g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), !=, 0);
 165   g_object_unref (addr);
 166
 167   if (socket_type == G_SOCKET_TYPE_STREAM)
 168     {
 169       g_socket_listen (server, &error);
 170       g_assert_no_error (error);
 171     }
 172   else
 173     {
 174       data->cancellable = g_cancellable_new ();
 175     }
 176
 177   data->thread = g_thread_new ("server", server_thread, data);
 178
 179   return data;
 180 }
 181
 182 static IPTestData *
 183 create_server (GSocketFamily family,
 184                GThreadFunc   server_thread,
 185                gboolean      v4mapped)
 186 {
 187   return create_server_full (family, G_SOCKET_TYPE_STREAM, server_thread, v4mapped);
 188 }
 189
 190 static const gchar *testbuf = "0123456789abcdef";
 191
 192 static gboolean
 193 test_ip_async_read_ready (GSocket      *client,
 194                           GIOCondition  cond,
 195                           gpointer      user_data)
 196 {
 197   IPTestData *data = user_data;
 198   GError *error = NULL;
 199   gssize len;
 200   gchar buf[128];
 201
 202   g_assert_cmpint (cond, ==, G_IO_IN);
 203
 204   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 205   g_assert_no_error (error);
 206   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 207
 208   g_assert_cmpstr (testbuf, ==, buf);
 209
 210   g_main_loop_quit (data->loop);
 211
 212   return FALSE;
 213 }
 214
 215 static gboolean
 216 test_ip_async_write_ready (GSocket      *client,
 217                            GIOCondition  cond,
 218                            gpointer      user_data)
 219 {
 220   IPTestData *data = user_data;
 221   GError *error = NULL;
 222   GSource *source;
 223   gssize len;
 224
 225   g_assert_cmpint (cond, ==, G_IO_OUT);
 226
 227   len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
 228   g_assert_no_error (error);
 229   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 230
 231   source = g_socket_create_source (client, G_IO_IN, NULL);
 232   g_source_set_callback (source, (GSourceFunc)test_ip_async_read_ready,
 233                          data, NULL);
 234   g_source_attach (source, NULL);
 235   g_source_unref (source);
 236
 237   return FALSE;
 238 }
 239
 240 static gboolean
 241 test_ip_async_timed_out (GSocket      *client,
 242                          GIOCondition  cond,
 243                          gpointer      user_data)
 244 {
 245   IPTestData *data = user_data;
 246   GError *error = NULL;
 247   GSource *source;
 248   gssize len;
 249   gchar buf[128];
 250
 251   if (data->family == G_SOCKET_FAMILY_IPV4)
 252     {
 253       g_assert_cmpint (cond, ==, G_IO_IN);
 254       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 255       g_assert_cmpint (len, ==, -1);
 256       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
 257       g_clear_error (&error);
 258     }
 259
 260   source = g_socket_create_source (client, G_IO_OUT, NULL);
 261   g_source_set_callback (source, (GSourceFunc)test_ip_async_write_ready,
 262                          data, NULL);
 263   g_source_attach (source, NULL);
 264   g_source_unref (source);
 265
 266   return FALSE;
 267 }
 268
 269 static gboolean
 270 test_ip_async_connected (GSocket      *client,
 271                          GIOCondition  cond,
 272                          gpointer      user_data)
 273 {
 274   IPTestData *data = user_data;
 275   GError *error = NULL;
 276   GSource *source;
 277   gssize len;
 278   gchar buf[128];
 279
 280   g_socket_check_connect_result (client, &error);
 281   g_assert_no_error (error);
 282   /* We do this after the check_connect_result, since that will give a
 283    * more useful assertion in case of error.
 284    */
 285   g_assert_cmpint (cond, ==, G_IO_OUT);
 286
 287   g_assert (g_socket_is_connected (client));
 288
 289   /* This adds 1 second to "make check", so let's just only do it once. */
 290   if (data->family == G_SOCKET_FAMILY_IPV4)
 291     {
 292       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 293       g_assert_cmpint (len, ==, -1);
 294       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
 295       g_clear_error (&error);
 296
 297       source = g_socket_create_source (client, G_IO_IN, NULL);
 298       g_source_set_callback (source, (GSourceFunc)test_ip_async_timed_out,
 299                              data, NULL);
 300       g_source_attach (source, NULL);
 301       g_source_unref (source);
 302     }
 303   else
 304     test_ip_async_timed_out (client, 0, data);
 305
 306   return FALSE;
 307 }
 308
 309 static gboolean
 310 idle_test_ip_async_connected (gpointer user_data)
 311 {
 312   IPTestData *data = user_data;
 313
 314   return test_ip_async_connected (data->client, G_IO_OUT, data);
 315 }
 316
 317 static void
 318 test_ip_async (GSocketFamily family)
 319 {
 320   IPTestData *data;
 321   GError *error = NULL;
 322   GSocket *client;
 323   GSocketAddress *addr;
 324   GSource *source;
 325   gssize len;
 326   gchar buf[128];
 327
 328   data = create_server (family, echo_server_thread, FALSE);
 329   addr = g_socket_get_local_address (data->server, &error);
 330   g_assert_no_error (error);
 331
 332   client = g_socket_new (family,
 333                          G_SOCKET_TYPE_STREAM,
 334                          G_SOCKET_PROTOCOL_DEFAULT,
 335                          &error);
 336   g_assert_no_error (error);
 337   data->client = client;
 338
 339   g_assert_cmpint (g_socket_get_family (client), ==, family);
 340   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
 341   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 342
 343   g_socket_set_blocking (client, FALSE);
 344   g_socket_set_timeout (client, 1);
 345
 346   if (g_socket_connect (client, addr, NULL, &error))
 347     {
 348       g_assert_no_error (error);
 349       g_idle_add (idle_test_ip_async_connected, data);
 350     }
 351   else
 352     {
 353       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
 354       g_clear_error (&error);
 355       source = g_socket_create_source (client, G_IO_OUT, NULL);
 356       g_source_set_callback (source, (GSourceFunc)test_ip_async_connected,
 357                              data, NULL);
 358       g_source_attach (source, NULL);
 359       g_source_unref (source);
 360     }
 361   g_object_unref (addr);
 362
 363   data->loop = g_main_loop_new (NULL, TRUE);
 364   g_main_loop_run (data->loop);
 365   g_main_loop_unref (data->loop);
 366
 367   g_socket_shutdown (client, FALSE, TRUE, &error);
 368   g_assert_no_error (error);
 369
 370   g_thread_join (data->thread);
 371
 372   if (family == G_SOCKET_FAMILY_IPV4)
 373     {
 374       /* Test that reading on a remote-closed socket gets back 0 bytes. */
 375       len = g_socket_receive_with_blocking (client, buf, sizeof (buf),
 376                                             TRUE, NULL, &error);
 377       g_assert_no_error (error);
 378       g_assert_cmpint (len, ==, 0);
 379     }
 380   else
 381     {
 382       /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */
 383       len = g_socket_send_with_blocking (client, testbuf, strlen (testbuf) + 1,
 384                                          TRUE, NULL, &error);
 385       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);
 386       g_assert_cmpint (len, ==, -1);
 387       g_clear_error (&error);
 388     }
 389
 390   g_socket_close (client, &error);
 391   g_assert_no_error (error);
 392   g_socket_close (data->server, &error);
 393   g_assert_no_error (error);
 394
 395   g_object_unref (data->server);
 396   g_object_unref (client);
 397
 398   g_slice_free (IPTestData, data);
 399 }
 400
 401 static void
 402 test_ipv4_async (void)
 403 {
 404   test_ip_async (G_SOCKET_FAMILY_IPV4);
 405 }
 406
 407 static void
 408 test_ipv6_async (void)
 409 {
 410   if (!ipv6_supported)
 411     {
 412       g_test_skip ("No support for IPv6");
 413       return;
 414     }
 415
 416   test_ip_async (G_SOCKET_FAMILY_IPV6);
 417 }
 418
 419 static const gchar testbuf2[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 420
 421 static void
 422 test_ip_sync (GSocketFamily family)
 423 {
 424   IPTestData *data;
 425   GError *error = NULL;
 426   GSocket *client;
 427   GSocketAddress *addr;
 428   gssize len;
 429   gchar buf[128];
 430
 431   data = create_server (family, echo_server_thread, FALSE);
 432   addr = g_socket_get_local_address (data->server, &error);
 433   g_assert_no_error (error);
 434
 435   client = g_socket_new (family,
 436                          G_SOCKET_TYPE_STREAM,
 437                          G_SOCKET_PROTOCOL_DEFAULT,
 438                          &error);
 439   g_assert_no_error (error);
 440
 441   g_assert_cmpint (g_socket_get_family (client), ==, family);
 442   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
 443   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 444
 445   g_socket_set_blocking (client, TRUE);
 446   g_socket_set_timeout (client, 1);
 447
 448   g_socket_connect (client, addr, NULL, &error);
 449   g_assert_no_error (error);
 450   g_assert (g_socket_is_connected (client));
 451   g_object_unref (addr);
 452
 453   /* This adds 1 second to "make check", so let's just only do it once. */
 454   if (family == G_SOCKET_FAMILY_IPV4)
 455     {
 456       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 457       g_assert_cmpint (len, ==, -1);
 458       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
 459       g_clear_error (&error);
 460     }
 461
 462   len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
 463   g_assert_no_error (error);
 464   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 465
 466   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 467   g_assert_no_error (error);
 468   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 469
 470   g_assert_cmpstr (testbuf, ==, buf);
 471
 472   {
 473     GOutputVector v[7] = { { NULL, }, };
 474
 475     v[0].buffer = testbuf2 + 0;
 476     v[0].size = 3;
 477     v[1].buffer = testbuf2 + 3;
 478     v[1].size = 5;
 479     v[2].buffer = testbuf2 + 3 + 5;
 480     v[2].size = 0;
 481     v[3].buffer = testbuf2 + 3 + 5;
 482     v[3].size = 6;
 483     v[4].buffer = testbuf2 + 3 + 5 + 6;
 484     v[4].size = 2;
 485     v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;
 486     v[5].size = 1;
 487     v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;
 488     v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);
 489
 490     len = g_socket_send_message (client, NULL, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);
 491     g_assert_no_error (error);
 492     g_assert_cmpint (len, ==, strlen (testbuf2));
 493
 494     memset (buf, 0, sizeof (buf));
 495     len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 496     g_assert_no_error (error);
 497     g_assert_cmpint (len, ==, strlen (testbuf2));
 498     g_assert_cmpstr (testbuf2, ==, buf);
 499   }
 500
 501   g_socket_shutdown (client, FALSE, TRUE, &error);
 502   g_assert_no_error (error);
 503
 504   g_thread_join (data->thread);
 505
 506   if (family == G_SOCKET_FAMILY_IPV4)
 507     {
 508       /* Test that reading on a remote-closed socket gets back 0 bytes. */
 509       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 510       g_assert_no_error (error);
 511       g_assert_cmpint (len, ==, 0);
 512     }
 513   else
 514     {
 515       /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */
 516       len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
 517       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);
 518       g_assert_cmpint (len, ==, -1);
 519       g_clear_error (&error);
 520     }
 521
 522   g_socket_close (client, &error);
 523   g_assert_no_error (error);
 524   g_socket_close (data->server, &error);
 525   g_assert_no_error (error);
 526
 527   g_object_unref (data->server);
 528   g_object_unref (client);
 529
 530   g_slice_free (IPTestData, data);
 531 }
 532
 533 static void
 534 test_ipv4_sync (void)
 535 {
 536   test_ip_sync (G_SOCKET_FAMILY_IPV4);
 537 }
 538
 539 static void
 540 test_ipv6_sync (void)
 541 {
 542   if (!ipv6_supported)
 543     {
 544       g_test_skip ("No support for IPv6");
 545       return;
 546     }
 547
 548   test_ip_sync (G_SOCKET_FAMILY_IPV6);
 549 }
 550
 551 static void
 552 test_ip_sync_dgram (GSocketFamily family)
 553 {
 554   IPTestData *data;
 555   GError *error = NULL;
 556   GSocket *client;
 557   GSocketAddress *dest_addr;
 558   gssize len;
 559   gchar buf[128];
 560
 561   data = create_server_full (family, G_SOCKET_TYPE_DATAGRAM,
 562                              echo_server_dgram_thread, FALSE);
 563
 564   dest_addr = g_socket_get_local_address (data->server, &error);
 565
 566   client = g_socket_new (family,
 567                          G_SOCKET_TYPE_DATAGRAM,
 568                          G_SOCKET_PROTOCOL_DEFAULT,
 569                          &error);
 570   g_assert_no_error (error);
 571
 572   g_assert_cmpint (g_socket_get_family (client), ==, family);
 573   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);
 574   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 575
 576   g_socket_set_blocking (client, TRUE);
 577   g_socket_set_timeout (client, 1);
 578
 579   len = g_socket_send_to (client, dest_addr, testbuf, strlen (testbuf) + 1, NULL, &error);
 580   g_assert_no_error (error);
 581   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 582
 583   len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 584   g_assert_no_error (error);
 585   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 586
 587   g_assert_cmpstr (testbuf, ==, buf);
 588
 589   {
 590     GOutputMessage m[3] = { { NULL, }, };
 591     GInputMessage im[3] = { { NULL, }, };
 592     GOutputVector v[7] = { { NULL, }, };
 593     GInputVector iv[7] = { { NULL, }, };
 594
 595     v[0].buffer = testbuf2 + 0;
 596     v[0].size = 3;
 597     v[1].buffer = testbuf2 + 3;
 598     v[1].size = 5;
 599     v[2].buffer = testbuf2 + 3 + 5;
 600     v[2].size = 0;
 601     v[3].buffer = testbuf2 + 3 + 5;
 602     v[3].size = 6;
 603     v[4].buffer = testbuf2 + 3 + 5 + 6;
 604     v[4].size = 2;
 605     v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;
 606     v[5].size = 1;
 607     v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;
 608     v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);
 609
 610     iv[0].buffer = buf + 0;
 611     iv[0].size = 3;
 612     iv[1].buffer = buf + 3;
 613     iv[1].size = 5;
 614     iv[2].buffer = buf + 3 + 5;
 615     iv[2].size = 0;
 616     iv[3].buffer = buf + 3 + 5;
 617     iv[3].size = 6;
 618     iv[4].buffer = buf + 3 + 5 + 6;
 619     iv[4].size = 2;
 620     iv[5].buffer = buf + 3 + 5 + 6 + 2;
 621     iv[5].size = 1;
 622     iv[6].buffer = buf + 3 + 5 + 6 + 2 + 1;
 623     iv[6].size = sizeof (buf) - (3 + 5 + 6 + 2 + 1);
 624
 625     len = g_socket_send_message (client, dest_addr, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);
 626     g_assert_no_error (error);
 627     g_assert_cmpint (len, ==, strlen (testbuf2));
 628
 629     memset (buf, 0, sizeof (buf));
 630     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 631     g_assert_no_error (error);
 632     g_assert_cmpint (len, ==, strlen (testbuf2));
 633     g_assert_cmpstr (testbuf2, ==, buf);
 634
 635     m[0].vectors = &v[0];
 636     m[0].num_vectors = 1;
 637     m[0].address = dest_addr;
 638     m[1].vectors = &v[0];
 639     m[1].num_vectors = 6;
 640     m[1].address = dest_addr;
 641     m[2].vectors = &v[6];
 642     m[2].num_vectors = 1;
 643     m[2].address = dest_addr;
 644
 645     len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
 646     g_assert_no_error (error);
 647     g_assert_cmpint (len, ==, G_N_ELEMENTS (m));
 648     g_assert_cmpint (m[0].bytes_sent, ==, 3);
 649     g_assert_cmpint (m[1].bytes_sent, ==, 17);
 650     g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);
 651
 652     memset (buf, 0, sizeof (buf));
 653     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 654     g_assert_no_error (error);
 655     g_assert_cmpint (len, ==, 3);
 656
 657     memset (buf, 0, sizeof (buf));
 658     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 659     g_assert_no_error (error);
 660     /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */
 661     g_assert_cmpint (len, ==, 17);
 662     g_assert (memcmp (testbuf2, buf, 17) == 0);
 663
 664     memset (buf, 0, sizeof (buf));
 665     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 666     g_assert_no_error (error);
 667     g_assert_cmpint (len, ==, v[6].size);
 668     g_assert_cmpstr (buf, ==, v[6].buffer);
 669
 670     /* reset since we're re-using the message structs */
 671     m[0].bytes_sent = 0;
 672     m[1].bytes_sent = 0;
 673     m[2].bytes_sent = 0;
 674
 675     /* now try receiving multiple messages */
 676     len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
 677     g_assert_no_error (error);
 678     g_assert_cmpint (len, ==, G_N_ELEMENTS (m));
 679     g_assert_cmpint (m[0].bytes_sent, ==, 3);
 680     g_assert_cmpint (m[1].bytes_sent, ==, 17);
 681     g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);
 682
 683     im[0].vectors = &iv[0];
 684     im[0].num_vectors = 1;
 685     im[1].vectors = &iv[0];
 686     im[1].num_vectors = 6;
 687     im[2].vectors = &iv[6];
 688     im[2].num_vectors = 1;
 689
 690     memset (buf, 0, sizeof (buf));
 691     len = g_socket_receive_messages (client, im, G_N_ELEMENTS (im), 0,
 692                                      NULL, &error);
 693     g_assert_no_error (error);
 694     g_assert_cmpint (len, ==, G_N_ELEMENTS (im));
 695
 696     g_assert_cmpuint (im[0].bytes_received, ==, 3);
 697     /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */
 698     g_assert_cmpuint (im[1].bytes_received, ==, 17);
 699     g_assert_cmpuint (im[2].bytes_received, ==, v[6].size);
 700
 701     /* reset since we're re-using the message structs */
 702     m[0].bytes_sent = 0;
 703     m[1].bytes_sent = 0;
 704     m[2].bytes_sent = 0;
 705
 706     /* now try to generate an early return by omitting the destination address on [1] */
 707     m[1].address = NULL;
 708     len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
 709     g_assert_no_error (error);
 710     g_assert_cmpint (len, ==, 1);
 711
 712     g_assert_cmpint (m[0].bytes_sent, ==, 3);
 713     g_assert_cmpint (m[1].bytes_sent, ==, 0);
 714     g_assert_cmpint (m[2].bytes_sent, ==, 0);
 715
 716     /* reset since we're re-using the message structs */
 717     m[0].bytes_sent = 0;
 718     m[1].bytes_sent = 0;
 719     m[2].bytes_sent = 0;
 720
 721     /* now try to generate an error by omitting all destination addresses */
 722     m[0].address = NULL;
 723     m[1].address = NULL;
 724     m[2].address = NULL;
 725     len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
 726     g_assert_error (error, G_IO_ERROR, G_IO_ERROR_FAILED);
 727     g_clear_error (&error);
 728     g_assert_cmpint (len, ==, -1);
 729
 730     g_assert_cmpint (m[0].bytes_sent, ==, 0);
 731     g_assert_cmpint (m[1].bytes_sent, ==, 0);
 732     g_assert_cmpint (m[2].bytes_sent, ==, 0);
 733
 734     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 735     g_assert_cmpint (len, ==, 3);
 736   }
 737
 738   g_cancellable_cancel (data->cancellable);
 739
 740   g_thread_join (data->thread);
 741
 742   g_socket_close (client, &error);
 743   g_assert_no_error (error);
 744   g_socket_close (data->server, &error);
 745   g_assert_no_error (error);
 746
 747   g_object_unref (data->server);
 748   g_object_unref (data->cancellable);
 749   g_object_unref (client);
 750   g_object_unref (dest_addr);
 751
 752   g_slice_free (IPTestData, data);
 753 }
 754
 755 static void
 756 test_ipv4_sync_dgram (void)
 757 {
 758   test_ip_sync_dgram (G_SOCKET_FAMILY_IPV4);
 759 }
 760
 761 static void
 762 test_ipv6_sync_dgram (void)
 763 {
 764   if (!ipv6_supported)
 765     {
 766       g_test_skip ("No support for IPv6");
 767       return;
 768     }
 769
 770   test_ip_sync_dgram (G_SOCKET_FAMILY_IPV6);
 771 }
 772
 773 static gpointer
 774 cancellable_thread_cb (gpointer data)
 775 {
 776   GCancellable *cancellable = data;
 777
 778   g_usleep (0.1 * G_USEC_PER_SEC);
 779   g_cancellable_cancel (cancellable);
 780   g_object_unref (cancellable);
 781
 782   return NULL;
 783 }
 784
 785 static void
 786 test_ip_sync_dgram_timeouts (GSocketFamily family)
 787 {
 788   GError *error = NULL;
 789   GSocket *client = NULL;
 790   GCancellable *cancellable = NULL;
 791   GThread *cancellable_thread = NULL;
 792   gssize len;
 793
 794   client = g_socket_new (family,
 795                          G_SOCKET_TYPE_DATAGRAM,
 796                          G_SOCKET_PROTOCOL_DEFAULT,
 797                          &error);
 798   g_assert_no_error (error);
 799
 800   g_assert_cmpint (g_socket_get_family (client), ==, family);
 801   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);
 802   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 803
 804   /* No overall timeout: test the per-operation timeouts instead. */
 805   g_socket_set_timeout (client, 0);
 806
 807   cancellable = g_cancellable_new ();
 808
 809   /* Check for timeouts when no server is running. */
 810   {
 811     gint64 start_time;
 812     GInputMessage im = { NULL, };
 813     GInputVector iv = { NULL, };
 814     guint8 buf[128];
 815
 816     iv.buffer = buf;
 817     iv.size = sizeof (buf);
 818
 819     im.vectors = &iv;
 820     im.num_vectors = 1;
 821
 822     memset (buf, 0, sizeof (buf));
 823
 824     /* Try a non-blocking read. */
 825     g_socket_set_blocking (client, FALSE);
 826     len = g_socket_receive_messages (client, &im, 1, 0  /* flags */,
 827                                      NULL, &error);
 828     g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
 829     g_assert_cmpint (len, ==, -1);
 830     g_clear_error (&error);
 831
 832     /* Try a timeout read. Can’t really validate the time taken more than
 833      * checking it’s positive. */
 834     g_socket_set_timeout (client, 1);
 835     g_socket_set_blocking (client, TRUE);
 836     start_time = g_get_monotonic_time ();
 837     len = g_socket_receive_messages (client, &im, 1, 0  /* flags */,
 838                                      NULL, &error);
 839     g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
 840     g_assert_cmpint (len, ==, -1);
 841     g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);
 842     g_clear_error (&error);
 843
 844     /* Try a blocking read, cancelled from another thread. */
 845     g_socket_set_timeout (client, 0);
 846     cancellable_thread = g_thread_new ("cancellable",
 847                                        cancellable_thread_cb,
 848                                        g_object_ref (cancellable));
 849
 850     start_time = g_get_monotonic_time ();
 851     len = g_socket_receive_messages (client, &im, 1, 0  /* flags */,
 852                                      cancellable, &error);
 853     g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
 854     g_assert_cmpint (len, ==, -1);
 855     g_assert_cmpint (g_get_monotonic_time () - start_time, >, 0);
 856     g_clear_error (&error);
 857
 858     g_thread_join (cancellable_thread);
 859   }
 860
 861   g_socket_close (client, &error);
 862   g_assert_no_error (error);
 863
 864   g_object_unref (client);
 865   g_object_unref (cancellable);
 866 }
 867
 868 static void
 869 test_ipv4_sync_dgram_timeouts (void)
 870 {
 871   test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV4);
 872 }
 873
 874 static void
 875 test_ipv6_sync_dgram_timeouts (void)
 876 {
 877   if (!ipv6_supported)
 878     {
 879       g_test_skip ("No support for IPv6");
 880       return;
 881     }
 882
 883   test_ip_sync_dgram_timeouts (G_SOCKET_FAMILY_IPV6);
 884 }
 885
 886 static gpointer
 887 graceful_server_thread (gpointer user_data)
 888 {
 889   IPTestData *data = user_data;
 890   GSocket *sock;
 891   GError *error = NULL;
 892   gssize len;
 893
 894   sock = g_socket_accept (data->server, NULL, &error);
 895   g_assert_no_error (error);
 896
 897   len = g_socket_send (sock, testbuf, strlen (testbuf) + 1, NULL, &error);
 898   g_assert_no_error (error);
 899   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 900
 901   return sock;
 902 }
 903
 904 static void
 905 test_close_graceful (void)
 906 {
 907   GSocketFamily family = G_SOCKET_FAMILY_IPV4;
 908   IPTestData *data;
 909   GError *error = NULL;
 910   GSocket *client, *server;
 911   GSocketAddress *addr;
 912   gssize len;
 913   gchar buf[128];
 914
 915   data = create_server (family, graceful_server_thread, FALSE);
 916   addr = g_socket_get_local_address (data->server, &error);
 917   g_assert_no_error (error);
 918
 919   client = g_socket_new (family,
 920                          G_SOCKET_TYPE_STREAM,
 921                          G_SOCKET_PROTOCOL_DEFAULT,
 922                          &error);
 923   g_assert_no_error (error);
 924
 925   g_assert_cmpint (g_socket_get_family (client), ==, family);
 926   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
 927   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 928
 929   g_socket_set_blocking (client, TRUE);
 930   g_socket_set_timeout (client, 1);
 931
 932   g_socket_connect (client, addr, NULL, &error);
 933   g_assert_no_error (error);
 934   g_assert (g_socket_is_connected (client));
 935   g_object_unref (addr);
 936
 937   server = g_thread_join (data->thread);
 938
 939   /* similar to g_tcp_connection_set_graceful_disconnect(), but explicit */
 940   g_socket_shutdown (server, FALSE, TRUE, &error);
 941   g_assert_no_error (error);
 942
 943   /* we must timeout */
 944   g_socket_condition_wait (client, G_IO_HUP, NULL, &error);
 945   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
 946   g_clear_error (&error);
 947
 948   /* check that the remaining data is received */
 949   len = g_socket_receive (client, buf, strlen (testbuf) + 1, NULL, &error);
 950   g_assert_no_error (error);
 951   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 952
 953   /* and only then the connection is closed */
 954   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 955   g_assert_no_error (error);
 956   g_assert_cmpint (len, ==, 0);
 957
 958   g_socket_close (server, &error);
 959   g_assert_no_error (error);
 960
 961   g_socket_close (client, &error);
 962   g_assert_no_error (error);
 963
 964   g_object_unref (server);
 965   g_object_unref (data->server);
 966   g_object_unref (client);
 967
 968   g_slice_free (IPTestData, data);
 969 }
 970
 971 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
 972 static gpointer
 973 v4mapped_server_thread (gpointer user_data)
 974 {
 975   IPTestData *data = user_data;
 976   GSocket *sock;
 977   GError *error = NULL;
 978   GSocketAddress *addr;
 979
 980   sock = g_socket_accept (data->server, NULL, &error);
 981   g_assert_no_error (error);
 982
 983   g_assert_cmpint (g_socket_get_family (sock), ==, G_SOCKET_FAMILY_IPV6);
 984
 985   addr = g_socket_get_local_address (sock, &error);
 986   g_assert_no_error (error);
 987   g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
 988   g_object_unref (addr);
 989
 990   addr = g_socket_get_remote_address (sock, &error);
 991   g_assert_no_error (error);
 992   g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
 993   g_object_unref (addr);
 994
 995   g_socket_close (sock, &error);
 996   g_assert_no_error (error);
 997   g_object_unref (sock);
 998   return NULL;
 999 }
1000
1001 static void
1002 test_ipv6_v4mapped (void)
1003 {
1004   IPTestData *data;
1005   GError *error = NULL;
1006   GSocket *client;
1007   GSocketAddress *addr, *v4addr;
1008   GInetAddress *iaddr;
1009
1010   if (!ipv6_supported)
1011     {
1012       g_test_skip ("No support for IPv6");
1013       return;
1014     }
1015
1016   data = create_server (G_SOCKET_FAMILY_IPV6, v4mapped_server_thread, TRUE);
1017
1018   if (data == NULL)
1019     {
1020       g_test_message ("Test not run: not supported by the OS");
1021       return;
1022     }
1023
1024   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1025                          G_SOCKET_TYPE_STREAM,
1026                          G_SOCKET_PROTOCOL_DEFAULT,
1027                          &error);
1028   g_assert_no_error (error);
1029
1030   g_socket_set_blocking (client, TRUE);
1031   g_socket_set_timeout (client, 1);
1032
1033   addr = g_socket_get_local_address (data->server, &error);
1034   g_assert_no_error (error);
1035   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1036   v4addr = g_inet_socket_address_new (iaddr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)));
1037   g_object_unref (iaddr);
1038   g_object_unref (addr);
1039
1040   g_socket_connect (client, v4addr, NULL, &error);
1041   g_assert_no_error (error);
1042   g_assert (g_socket_is_connected (client));
1043
1044   g_thread_join (data->thread);
1045
1046   g_socket_close (client, &error);
1047   g_assert_no_error (error);
1048   g_socket_close (data->server, &error);
1049   g_assert_no_error (error);
1050
1051   g_object_unref (data->server);
1052   g_object_unref (client);
1053   g_object_unref (v4addr);
1054
1055   g_slice_free (IPTestData, data);
1056 }
1057 #endif
1058
1059 static void
1060 test_timed_wait (void)
1061 {
1062   IPTestData *data;
1063   GError *error = NULL;
1064   GSocket *client;
1065   GSocketAddress *addr;
1066   gint64 start_time;
1067   gint poll_duration;
1068
1069   data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE);
1070   addr = g_socket_get_local_address (data->server, &error);
1071   g_assert_no_error (error);
1072
1073   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1074                          G_SOCKET_TYPE_STREAM,
1075                          G_SOCKET_PROTOCOL_DEFAULT,
1076                          &error);
1077   g_assert_no_error (error);
1078
1079   g_socket_set_blocking (client, TRUE);
1080   g_socket_set_timeout (client, 1);
1081
1082   g_socket_connect (client, addr, NULL, &error);
1083   g_assert_no_error (error);
1084   g_object_unref (addr);
1085
1086   start_time = g_get_monotonic_time ();
1087   g_socket_condition_timed_wait (client, G_IO_IN, 100000 /* 100 ms */,
1088                                  NULL, &error);
1089   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
1090   g_clear_error (&error);
1091   poll_duration = g_get_monotonic_time () - start_time;
1092
1093   g_assert_cmpint (poll_duration, >=, 98000);
1094   g_assert_cmpint (poll_duration, <, 112000);
1095
1096   g_socket_close (client, &error);
1097   g_assert_no_error (error);
1098
1099   g_thread_join (data->thread);
1100
1101   g_socket_close (data->server, &error);
1102   g_assert_no_error (error);
1103
1104   g_object_unref (data->server);
1105   g_object_unref (client);
1106
1107   g_slice_free (IPTestData, data);
1108 }
1109
1110 static int
1111 duplicate_fd (int fd)
1112 {
1113 #ifdef G_OS_WIN32
1114   HANDLE newfd;
1115
1116   if (!DuplicateHandle (GetCurrentProcess (),
1117                         (HANDLE)fd,
1118                         GetCurrentProcess (),
1119                         &newfd,
1120                         0,
1121                         FALSE,
1122                         DUPLICATE_SAME_ACCESS))
1123     {
1124       return -1;
1125     }
1126
1127   return (int)newfd;
1128 #else
1129   return dup (fd);
1130 #endif
1131 }
1132
1133 static void
1134 test_fd_reuse (void)
1135 {
1136   IPTestData *data;
1137   GError *error = NULL;
1138   GSocket *client;
1139   GSocket *client2;
1140   GSocketAddress *addr;
1141   int fd;
1142   gssize len;
1143   gchar buf[128];
1144
1145   g_test_bug ("741707");
1146
1147   data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE);
1148   addr = g_socket_get_local_address (data->server, &error);
1149   g_assert_no_error (error);
1150
1151   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1152                          G_SOCKET_TYPE_STREAM,
1153                          G_SOCKET_PROTOCOL_DEFAULT,
1154                          &error);
1155   g_assert_no_error (error);
1156
1157   g_socket_set_blocking (client, TRUE);
1158   g_socket_set_timeout (client, 1);
1159
1160   g_socket_connect (client, addr, NULL, &error);
1161   g_assert_no_error (error);
1162   g_assert (g_socket_is_connected (client));
1163   g_object_unref (addr);
1164
1165   /* we have to dup otherwise the fd gets closed twice on unref */
1166   fd = duplicate_fd (g_socket_get_fd (client));
1167   client2 = g_socket_new_from_fd (fd, &error);
1168   g_assert_no_error (error);
1169
1170   g_assert_cmpint (g_socket_get_family (client2), ==, g_socket_get_family (client));
1171   g_assert_cmpint (g_socket_get_socket_type (client2), ==, g_socket_get_socket_type (client));
1172   g_assert_cmpint (g_socket_get_protocol (client2), ==, G_SOCKET_PROTOCOL_TCP);
1173
1174   len = g_socket_send (client2, testbuf, strlen (testbuf) + 1, NULL, &error);
1175   g_assert_no_error (error);
1176   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1177
1178   len = g_socket_receive (client2, buf, sizeof (buf), NULL, &error);
1179   g_assert_no_error (error);
1180   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
1181
1182   g_assert_cmpstr (testbuf, ==, buf);
1183
1184   g_socket_shutdown (client, FALSE, TRUE, &error);
1185   g_assert_no_error (error);
1186   /* The semantics of dup()+shutdown() are ambiguous; this call will succeed
1187    * on Linux, but return ENOTCONN on OS X.
1188    */
1189   g_socket_shutdown (client2, FALSE, TRUE, NULL);
1190
1191   g_thread_join (data->thread);
1192
1193   g_socket_close (client, &error);
1194   g_assert_no_error (error);
1195   g_socket_close (client2, &error);
1196   g_assert_no_error (error);
1197   g_socket_close (data->server, &error);
1198   g_assert_no_error (error);
1199
1200   g_object_unref (data->server);
1201   g_object_unref (client);
1202   g_object_unref (client2);
1203
1204   g_slice_free (IPTestData, data);
1205 }
1206
1207 static void
1208 test_sockaddr (void)
1209 {
1210   struct sockaddr_in6 sin6, gsin6;
1211   GSocketAddress *saddr;
1212   GInetSocketAddress *isaddr;
1213   GInetAddress *iaddr;
1214   GError *error = NULL;
1215
1216   memset (&sin6, 0, sizeof (sin6));
1217   sin6.sin6_family = AF_INET6;
1218   sin6.sin6_addr = in6addr_loopback;
1219   sin6.sin6_port = g_htons (42);
1220   sin6.sin6_scope_id = 17;
1221   sin6.sin6_flowinfo = 1729;
1222
1223   saddr = g_socket_address_new_from_native (&sin6, sizeof (sin6));
1224   g_assert (G_IS_INET_SOCKET_ADDRESS (saddr));
1225
1226   isaddr = G_INET_SOCKET_ADDRESS (saddr);
1227   iaddr = g_inet_socket_address_get_address (isaddr);
1228   g_assert_cmpint (g_inet_address_get_family (iaddr), ==, G_SOCKET_FAMILY_IPV6);
1229   g_assert (g_inet_address_get_is_loopback (iaddr));
1230
1231   g_assert_cmpint (g_inet_socket_address_get_port (isaddr), ==, 42);
1232   g_assert_cmpint (g_inet_socket_address_get_scope_id (isaddr), ==, 17);
1233   g_assert_cmpint (g_inet_socket_address_get_flowinfo (isaddr), ==, 1729);
1234
1235   g_socket_address_to_native (saddr, &gsin6, sizeof (gsin6), &error);
1236   g_assert_no_error (error);
1237
1238   g_assert (memcmp (&sin6.sin6_addr, &gsin6.sin6_addr, sizeof (struct in6_addr)) == 0);
1239   g_assert_cmpint (sin6.sin6_port, ==, gsin6.sin6_port);
1240   g_assert_cmpint (sin6.sin6_scope_id, ==, gsin6.sin6_scope_id);
1241   g_assert_cmpint (sin6.sin6_flowinfo, ==, gsin6.sin6_flowinfo);
1242
1243   g_object_unref (saddr);
1244 }
1245
1246 #ifdef G_OS_UNIX
1247 static void
1248 test_unix_from_fd (void)
1249 {
1250   gint fd;
1251   GError *error;
1252   GSocket *s;
1253
1254   fd = socket (AF_UNIX, SOCK_STREAM, 0);
1255   g_assert_cmpint (fd, !=, -1);
1256
1257   error = NULL;
1258   s = g_socket_new_from_fd (fd, &error);
1259   g_assert_no_error (error);
1260   g_assert_cmpint (g_socket_get_family (s), ==, G_SOCKET_FAMILY_UNIX);
1261   g_assert_cmpint (g_socket_get_socket_type (s), ==, G_SOCKET_TYPE_STREAM);
1262   g_assert_cmpint (g_socket_get_protocol (s), ==, G_SOCKET_PROTOCOL_DEFAULT);
1263   g_object_unref (s);
1264 }
1265
1266 static void
1267 test_unix_connection (void)
1268 {
1269   gint fd;
1270   GError *error;
1271   GSocket *s;
1272   GSocketConnection *c;
1273
1274   fd = socket (AF_UNIX, SOCK_STREAM, 0);
1275   g_assert_cmpint (fd, !=, -1);
1276
1277   error = NULL;
1278   s = g_socket_new_from_fd (fd, &error);
1279   g_assert_no_error (error);
1280   c = g_socket_connection_factory_create_connection (s);
1281   g_assert (G_IS_UNIX_CONNECTION (c));
1282   g_object_unref (c);
1283   g_object_unref (s);
1284 }
1285
1286 static GSocketConnection *
1287 create_connection_for_fd (int fd)
1288 {
1289   GError *err = NULL;
1290   GSocket *socket;
1291   GSocketConnection *connection;
1292
1293   socket = g_socket_new_from_fd (fd, &err);
1294   g_assert_no_error (err);
1295   g_assert (G_IS_SOCKET (socket));
1296   connection = g_socket_connection_factory_create_connection (socket);
1297   g_assert (G_IS_UNIX_CONNECTION (connection));
1298   g_object_unref (socket);
1299   return connection;
1300 }
1301
1302 #define TEST_DATA "failure to say failure to say 'i love gnome-panel!'."
1303
1304 static void
1305 test_unix_connection_ancillary_data (void)
1306 {
1307   GError *err = NULL;
1308   gint pv[2], sv[3];
1309   gint status, fd, len;
1310   char buffer[1024];
1311   pid_t pid;
1312
1313   status = pipe (pv);
1314   g_assert_cmpint (status, ==, 0);
1315
1316   status = socketpair (PF_UNIX, SOCK_STREAM, 0, sv);
1317   g_assert_cmpint (status, ==, 0);
1318
1319   pid = fork ();
1320   g_assert_cmpint (pid, >=, 0);
1321
1322   /* Child: close its copy of the write end of the pipe, receive it
1323    * again from the parent over the socket, and write some text to it.
1324    *
1325    * Parent: send the write end of the pipe (still open for the
1326    * parent) over the socket, close it, and read some text from the
1327    * read end of the pipe.
1328    */
1329   if (pid == 0)
1330     {
1331       GSocketConnection *connection;
1332
1333       close (sv[1]);
1334       connection = create_connection_for_fd (sv[0]);
1335
1336       status = close (pv[1]);
1337       g_assert_cmpint (status, ==, 0);
1338
1339       err = NULL;
1340       fd = g_unix_connection_receive_fd (G_UNIX_CONNECTION (connection), NULL,
1341                                          &err);
1342       g_assert_no_error (err);
1343       g_assert_cmpint (fd, >, -1);
1344       g_object_unref (connection);
1345
1346       do
1347         len = write (fd, TEST_DATA, sizeof (TEST_DATA));
1348       while (len == -1 && errno == EINTR);
1349       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1350       exit (0);
1351     }
1352   else
1353     {
1354       GSocketConnection *connection;
1355
1356       close (sv[0]);
1357       connection = create_connection_for_fd (sv[1]);
1358
1359       err = NULL;
1360       g_unix_connection_send_fd (G_UNIX_CONNECTION (connection), pv[1], NULL,
1361                                  &err);
1362       g_assert_no_error (err);
1363       g_object_unref (connection);
1364
1365       status = close (pv[1]);
1366       g_assert_cmpint (status, ==, 0);
1367
1368       memset (buffer, 0xff, sizeof buffer);
1369       do
1370         len = read (pv[0], buffer, sizeof buffer);
1371       while (len == -1 && errno == EINTR);
1372
1373       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1374       g_assert_cmpstr (buffer, ==, TEST_DATA);
1375
1376       waitpid (pid, &status, 0);
1377       g_assert (WIFEXITED (status));
1378       g_assert_cmpint (WEXITSTATUS (status), ==, 0);
1379     }
1380
1381   /* TODO: add test for g_unix_connection_send_credentials() and
1382    * g_unix_connection_receive_credentials().
1383    */
1384 }
1385 #endif /* G_OS_UNIX */
1386
1387 static void
1388 test_reuse_tcp (void)
1389 {
1390   GSocket *sock1, *sock2;
1391   GError *error = NULL;
1392   GInetAddress *iaddr;
1393   GSocketAddress *addr;
1394
1395   sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1396                         G_SOCKET_TYPE_STREAM,
1397                         G_SOCKET_PROTOCOL_DEFAULT,
1398                         &error);
1399   g_assert_no_error (error);
1400
1401   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1402   addr = g_inet_socket_address_new (iaddr, 0);
1403   g_object_unref (iaddr);
1404   g_socket_bind (sock1, addr, TRUE, &error);
1405   g_object_unref (addr);
1406   g_assert_no_error (error);
1407
1408   g_socket_listen (sock1, &error);
1409   g_assert_no_error (error);
1410
1411   sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1412                         G_SOCKET_TYPE_STREAM,
1413                         G_SOCKET_PROTOCOL_DEFAULT,
1414                         &error);
1415   g_assert_no_error (error);
1416
1417   addr = g_socket_get_local_address (sock1, &error);
1418   g_assert_no_error (error);
1419   g_socket_bind (sock2, addr, TRUE, &error);
1420   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_ADDRESS_IN_USE);
1421   g_clear_error (&error);
1422   g_object_unref (addr);
1423
1424   g_object_unref (sock1);
1425   g_object_unref (sock2);
1426 }
1427
1428 static void
1429 test_reuse_udp (void)
1430 {
1431   GSocket *sock1, *sock2;
1432   GError *error = NULL;
1433   GInetAddress *iaddr;
1434   GSocketAddress *addr;
1435
1436   sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1437                         G_SOCKET_TYPE_DATAGRAM,
1438                         G_SOCKET_PROTOCOL_DEFAULT,
1439                         &error);
1440   g_assert_no_error (error);
1441
1442   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1443   addr = g_inet_socket_address_new (iaddr, 0);
1444   g_object_unref (iaddr);
1445   g_socket_bind (sock1, addr, TRUE, &error);
1446   g_object_unref (addr);
1447   g_assert_no_error (error);
1448
1449   sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1450                         G_SOCKET_TYPE_DATAGRAM,
1451                         G_SOCKET_PROTOCOL_DEFAULT,
1452                         &error);
1453   g_assert_no_error (error);
1454
1455   addr = g_socket_get_local_address (sock1, &error);
1456   g_assert_no_error (error);
1457   g_socket_bind (sock2, addr, TRUE, &error);
1458   g_object_unref (addr);
1459   g_assert_no_error (error);
1460
1461   g_object_unref (sock1);
1462   g_object_unref (sock2);
1463 }
1464
1465 static void
1466 test_get_available (gconstpointer user_data)
1467 {
1468   GSocketType socket_type = GPOINTER_TO_UINT (user_data);
1469   GError *err = NULL;
1470   GSocket *listener, *server, *client;
1471   GInetAddress *addr;
1472   GSocketAddress *saddr;
1473   gchar data[] = "0123456789abcdef";
1474   gchar buf[34];
1475   gssize nread;
1476
1477   listener = g_socket_new (G_SOCKET_FAMILY_IPV4,
1478                            socket_type,
1479                            G_SOCKET_PROTOCOL_DEFAULT,
1480                            &err);
1481   g_assert_no_error (err);
1482   g_assert (G_IS_SOCKET (listener));
1483
1484   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1485                          socket_type,
1486                          G_SOCKET_PROTOCOL_DEFAULT,
1487                          &err);
1488   g_assert_no_error (err);
1489   g_assert (G_IS_SOCKET (client));
1490
1491   if (socket_type == G_SOCKET_TYPE_STREAM)
1492     {
1493       g_socket_set_option (client, IPPROTO_TCP, TCP_NODELAY, TRUE, &err);
1494       g_assert_no_error (err);
1495     }
1496
1497   addr = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
1498   saddr = g_inet_socket_address_new (addr, 0);
1499
1500   g_socket_bind (listener, saddr, TRUE, &err);
1501   g_assert_no_error (err);
1502   g_object_unref (saddr);
1503   g_object_unref (addr);
1504
1505   saddr = g_socket_get_local_address (listener, &err);
1506   g_assert_no_error (err);
1507
1508   if (socket_type == G_SOCKET_TYPE_STREAM)
1509     {
1510       g_socket_listen (listener, &err);
1511       g_assert_no_error (err);
1512       g_socket_connect (client, saddr, NULL, &err);
1513       g_assert_no_error (err);
1514
1515       server = g_socket_accept (listener, NULL, &err);
1516       g_assert_no_error (err);
1517       g_socket_set_blocking (server, FALSE);
1518       g_object_unref (listener);
1519     }
1520   else
1521     server = listener;
1522
1523   g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1524   g_assert_no_error (err);
1525
1526   while (!g_socket_condition_wait (server, G_IO_IN, NULL, NULL))
1527     ;
1528   g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1529
1530   g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1531   g_assert_no_error (err);
1532
1533   /* We need to wait until the data has actually been copied into the
1534    * server socket's buffers, but g_socket_condition_wait() won't help
1535    * here since the socket is definitely already readable. So there's
1536    * a race condition in checking its available bytes. In the TCP
1537    * case, we poll for a bit until the new data shows up. In the UDP
1538    * case, there's not much we can do, but at least the failure mode
1539    * is passes-when-it-shouldn't, not fails-when-it-shouldn't.
1540    */
1541   if (socket_type == G_SOCKET_TYPE_STREAM)
1542     {
1543       int tries;
1544
1545       for (tries = 0; tries < 100; tries++)
1546         {
1547           if (g_socket_get_available_bytes (server) > sizeof (data))
1548             break;
1549           g_usleep (100000);
1550         }
1551
1552       g_assert_cmpint (g_socket_get_available_bytes (server), ==, 2 * sizeof (data));
1553     }
1554   else
1555     {
1556       g_usleep (100000);
1557       g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1558     }
1559
1560   g_assert_cmpint (sizeof (buf), >=, 2 * sizeof (data));
1561   nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1562   g_assert_no_error (err);
1563
1564   if (socket_type == G_SOCKET_TYPE_STREAM)
1565     {
1566       g_assert_cmpint (nread, ==, 2 * sizeof (data));
1567       g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1568     }
1569   else
1570     {
1571       g_assert_cmpint (nread, ==, sizeof (data));
1572       g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1573     }
1574
1575   nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1576   if (socket_type == G_SOCKET_TYPE_STREAM)
1577     {
1578       g_assert_cmpint (nread, ==, -1);
1579       g_assert_error (err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
1580       g_clear_error (&err);
1581     }
1582   else
1583     {
1584       g_assert_cmpint (nread, ==, sizeof (data));
1585       g_assert_no_error (err);
1586     }
1587
1588   g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1589
1590   g_socket_close (server, &err);
1591   g_assert_no_error (err);
1592
1593   g_object_unref (saddr);
1594   g_object_unref (server);
1595   g_object_unref (client);
1596 }
1597
1598 int
1599 main (int   argc,
1600       char *argv[])
1601 {
1602   GSocket *sock;
1603   GError *error = NULL;
1604
1605   g_test_init (&argc, &argv, NULL);
1606   g_test_bug_base ("https://bugzilla.gnome.org/");
1607
1608   sock = g_socket_new (G_SOCKET_FAMILY_IPV6,
1609                        G_SOCKET_TYPE_STREAM,
1610                        G_SOCKET_PROTOCOL_DEFAULT,
1611                        &error);
1612   if (sock != NULL)
1613     {
1614       ipv6_supported = TRUE;
1615       g_object_unref (sock);
1616     }
1617   else
1618     {
1619       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1620       g_clear_error (&error);
1621     }
1622
1623   g_test_add_func ("/socket/ipv4_sync", test_ipv4_sync);
1624   g_test_add_func ("/socket/ipv4_async", test_ipv4_async);
1625   g_test_add_func ("/socket/ipv6_sync", test_ipv6_sync);
1626   g_test_add_func ("/socket/ipv6_async", test_ipv6_async);
1627   g_test_add_func ("/socket/ipv4_sync/datagram", test_ipv4_sync_dgram);
1628   g_test_add_func ("/socket/ipv4_sync/datagram/timeouts", test_ipv4_sync_dgram_timeouts);
1629   g_test_add_func ("/socket/ipv6_sync/datagram", test_ipv6_sync_dgram);
1630   g_test_add_func ("/socket/ipv6_sync/datagram/timeouts", test_ipv6_sync_dgram_timeouts);
1631 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
1632   g_test_add_func ("/socket/ipv6_v4mapped", test_ipv6_v4mapped);
1633 #endif
1634   g_test_add_func ("/socket/close_graceful", test_close_graceful);
1635   g_test_add_func ("/socket/timed_wait", test_timed_wait);
1636   g_test_add_func ("/socket/fd_reuse", test_fd_reuse);
1637   g_test_add_func ("/socket/address", test_sockaddr);
1638 #ifdef G_OS_UNIX
1639   g_test_add_func ("/socket/unix-from-fd", test_unix_from_fd);
1640   g_test_add_func ("/socket/unix-connection", test_unix_connection);
1641   g_test_add_func ("/socket/unix-connection-ancillary-data", test_unix_connection_ancillary_data);
1642 #endif
1643   g_test_add_func ("/socket/reuse/tcp", test_reuse_tcp);
1644   g_test_add_func ("/socket/reuse/udp", test_reuse_udp);
1645   g_test_add_data_func ("/socket/get_available/datagram", GUINT_TO_POINTER (G_SOCKET_TYPE_DATAGRAM),
1646                         test_get_available);
1647   g_test_add_data_func ("/socket/get_available/stream", GUINT_TO_POINTER (G_SOCKET_TYPE_STREAM),
1648                         test_get_available);
1649
1650   return g_test_run();
1651 }
1652