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     len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 495     g_assert_no_error (error);
 496     g_assert_cmpint (len, ==, strlen (testbuf2));
 497     g_assert_cmpstr (testbuf2, ==, buf);
 498   }
 499
 500   g_socket_shutdown (client, FALSE, TRUE, &error);
 501   g_assert_no_error (error);
 502
 503   g_thread_join (data->thread);
 504
 505   if (family == G_SOCKET_FAMILY_IPV4)
 506     {
 507       /* Test that reading on a remote-closed socket gets back 0 bytes. */
 508       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 509       g_assert_no_error (error);
 510       g_assert_cmpint (len, ==, 0);
 511     }
 512   else
 513     {
 514       /* Test that writing to a remote-closed socket gets back CONNECTION_CLOSED. */
 515       len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
 516       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED);
 517       g_assert_cmpint (len, ==, -1);
 518       g_clear_error (&error);
 519     }
 520
 521   g_socket_close (client, &error);
 522   g_assert_no_error (error);
 523   g_socket_close (data->server, &error);
 524   g_assert_no_error (error);
 525
 526   g_object_unref (data->server);
 527   g_object_unref (client);
 528
 529   g_slice_free (IPTestData, data);
 530 }
 531
 532 static void
 533 test_ipv4_sync (void)
 534 {
 535   test_ip_sync (G_SOCKET_FAMILY_IPV4);
 536 }
 537
 538 static void
 539 test_ipv6_sync (void)
 540 {
 541   if (!ipv6_supported)
 542     {
 543       g_test_skip ("No support for IPv6");
 544       return;
 545     }
 546
 547   test_ip_sync (G_SOCKET_FAMILY_IPV6);
 548 }
 549
 550 static void
 551 test_ip_sync_dgram (GSocketFamily family)
 552 {
 553   IPTestData *data;
 554   GError *error = NULL;
 555   GSocket *client;
 556   GSocketAddress *dest_addr;
 557   gssize len;
 558   gchar buf[128];
 559
 560   data = create_server_full (family, G_SOCKET_TYPE_DATAGRAM,
 561                              echo_server_dgram_thread, FALSE);
 562
 563   dest_addr = g_socket_get_local_address (data->server, &error);
 564
 565   client = g_socket_new (family,
 566                          G_SOCKET_TYPE_DATAGRAM,
 567                          G_SOCKET_PROTOCOL_DEFAULT,
 568                          &error);
 569   g_assert_no_error (error);
 570
 571   g_assert_cmpint (g_socket_get_family (client), ==, family);
 572   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_DATAGRAM);
 573   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 574
 575   g_socket_set_blocking (client, TRUE);
 576   g_socket_set_timeout (client, 1);
 577
 578   len = g_socket_send_to (client, dest_addr, testbuf, strlen (testbuf) + 1, NULL, &error);
 579   g_assert_no_error (error);
 580   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 581
 582   len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 583   g_assert_no_error (error);
 584   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 585
 586   g_assert_cmpstr (testbuf, ==, buf);
 587
 588   {
 589     GOutputMessage m[3] = { { NULL, }, };
 590     GOutputVector v[7] = { { NULL, }, };
 591
 592     v[0].buffer = testbuf2 + 0;
 593     v[0].size = 3;
 594     v[1].buffer = testbuf2 + 3;
 595     v[1].size = 5;
 596     v[2].buffer = testbuf2 + 3 + 5;
 597     v[2].size = 0;
 598     v[3].buffer = testbuf2 + 3 + 5;
 599     v[3].size = 6;
 600     v[4].buffer = testbuf2 + 3 + 5 + 6;
 601     v[4].size = 2;
 602     v[5].buffer = testbuf2 + 3 + 5 + 6 + 2;
 603     v[5].size = 1;
 604     v[6].buffer = testbuf2 + 3 + 5 + 6 + 2 + 1;
 605     v[6].size = strlen (testbuf2) - (3 + 5 + 6 + 2 + 1);
 606
 607     len = g_socket_send_message (client, dest_addr, v, G_N_ELEMENTS (v), NULL, 0, 0, NULL, &error);
 608     g_assert_no_error (error);
 609     g_assert_cmpint (len, ==, strlen (testbuf2));
 610
 611     memset (buf, 0, sizeof (buf));
 612     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 613     g_assert_no_error (error);
 614     g_assert_cmpint (len, ==, strlen (testbuf2));
 615     g_assert_cmpstr (testbuf2, ==, buf);
 616
 617     m[0].vectors = &v[0];
 618     m[0].num_vectors = 1;
 619     m[0].address = dest_addr;
 620     m[1].vectors = &v[0];
 621     m[1].num_vectors = 6;
 622     m[1].address = dest_addr;
 623     m[2].vectors = &v[6];
 624     m[2].num_vectors = 1;
 625     m[2].address = dest_addr;
 626
 627     len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
 628     g_assert_no_error (error);
 629     g_assert_cmpint (len, ==, G_N_ELEMENTS (m));
 630     g_assert_cmpint (m[0].bytes_sent, ==, 3);
 631     g_assert_cmpint (m[1].bytes_sent, ==, 17);
 632     g_assert_cmpint (m[2].bytes_sent, ==, v[6].size);
 633
 634     memset (buf, 0, sizeof (buf));
 635     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 636     g_assert_no_error (error);
 637     g_assert_cmpint (len, ==, 3);
 638
 639     memset (buf, 0, sizeof (buf));
 640     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 641     g_assert_no_error (error);
 642     /* v[0].size + v[1].size + v[2].size + v[3].size + v[4].size + v[5].size */
 643     g_assert_cmpint (len, ==, 17);
 644     g_assert (memcmp (testbuf2, buf, 17) == 0);
 645
 646     memset (buf, 0, sizeof (buf));
 647     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 648     g_assert_no_error (error);
 649     g_assert_cmpint (len, ==, v[6].size);
 650     g_assert_cmpstr (buf, ==, v[6].buffer);
 651
 652     /* reset since we're re-using the message structs */
 653     m[0].bytes_sent = 0;
 654     m[1].bytes_sent = 0;
 655     m[2].bytes_sent = 0;
 656
 657     /* now try to generate an error by omitting the destination address on [1] */
 658     m[1].address = NULL;
 659     len = g_socket_send_messages (client, m, G_N_ELEMENTS (m), 0, NULL, &error);
 660     g_assert_error (error, G_IO_ERROR, G_IO_ERROR_FAILED);
 661     g_clear_error (&error);
 662     g_assert_cmpint (len, ==, -1);
 663
 664     g_assert_cmpint (m[0].bytes_sent, ==, 3);
 665     g_assert_cmpint (m[1].bytes_sent, ==, 0);
 666     g_assert_cmpint (m[2].bytes_sent, ==, 0);
 667
 668     len = g_socket_receive_from (client, NULL, buf, sizeof (buf), NULL, &error);
 669     g_assert_cmpint (len, ==, 3);
 670   }
 671
 672   g_cancellable_cancel (data->cancellable);
 673
 674   g_thread_join (data->thread);
 675
 676   g_socket_close (client, &error);
 677   g_assert_no_error (error);
 678   g_socket_close (data->server, &error);
 679   g_assert_no_error (error);
 680
 681   g_object_unref (data->server);
 682   g_object_unref (data->cancellable);
 683   g_object_unref (client);
 684   g_object_unref (dest_addr);
 685
 686   g_slice_free (IPTestData, data);
 687 }
 688
 689 static void
 690 test_ipv4_sync_dgram (void)
 691 {
 692   test_ip_sync_dgram (G_SOCKET_FAMILY_IPV4);
 693 }
 694
 695 static void
 696 test_ipv6_sync_dgram (void)
 697 {
 698   if (!ipv6_supported)
 699     {
 700       g_test_skip ("No support for IPv6");
 701       return;
 702     }
 703
 704   test_ip_sync_dgram (G_SOCKET_FAMILY_IPV6);
 705 }
 706
 707 static gpointer
 708 graceful_server_thread (gpointer user_data)
 709 {
 710   IPTestData *data = user_data;
 711   GSocket *sock;
 712   GError *error = NULL;
 713   gssize len;
 714
 715   sock = g_socket_accept (data->server, NULL, &error);
 716   g_assert_no_error (error);
 717
 718   len = g_socket_send (sock, testbuf, strlen (testbuf) + 1, NULL, &error);
 719   g_assert_no_error (error);
 720   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 721
 722   return sock;
 723 }
 724
 725 static void
 726 test_close_graceful (void)
 727 {
 728   GSocketFamily family = G_SOCKET_FAMILY_IPV4;
 729   IPTestData *data;
 730   GError *error = NULL;
 731   GSocket *client, *server;
 732   GSocketAddress *addr;
 733   gssize len;
 734   gchar buf[128];
 735
 736   data = create_server (family, graceful_server_thread, FALSE);
 737   addr = g_socket_get_local_address (data->server, &error);
 738   g_assert_no_error (error);
 739
 740   client = g_socket_new (family,
 741                          G_SOCKET_TYPE_STREAM,
 742                          G_SOCKET_PROTOCOL_DEFAULT,
 743                          &error);
 744   g_assert_no_error (error);
 745
 746   g_assert_cmpint (g_socket_get_family (client), ==, family);
 747   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
 748   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 749
 750   g_socket_set_blocking (client, TRUE);
 751   g_socket_set_timeout (client, 1);
 752
 753   g_socket_connect (client, addr, NULL, &error);
 754   g_assert_no_error (error);
 755   g_assert (g_socket_is_connected (client));
 756   g_object_unref (addr);
 757
 758   server = g_thread_join (data->thread);
 759
 760   /* similar to g_tcp_connection_set_graceful_disconnect(), but explicit */
 761   g_socket_shutdown (server, FALSE, TRUE, &error);
 762   g_assert_no_error (error);
 763
 764   /* we must timeout */
 765   g_socket_condition_wait (client, G_IO_HUP, NULL, &error);
 766   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
 767   g_clear_error (&error);
 768
 769   /* check that the remaining data is received */
 770   len = g_socket_receive (client, buf, strlen (testbuf) + 1, NULL, &error);
 771   g_assert_no_error (error);
 772   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 773
 774   /* and only then the connection is closed */
 775   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 776   g_assert_no_error (error);
 777   g_assert_cmpint (len, ==, 0);
 778
 779   g_socket_close (server, &error);
 780   g_assert_no_error (error);
 781
 782   g_socket_close (client, &error);
 783   g_assert_no_error (error);
 784
 785   g_object_unref (server);
 786   g_object_unref (data->server);
 787   g_object_unref (client);
 788
 789   g_slice_free (IPTestData, data);
 790 }
 791
 792 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
 793 static gpointer
 794 v4mapped_server_thread (gpointer user_data)
 795 {
 796   IPTestData *data = user_data;
 797   GSocket *sock;
 798   GError *error = NULL;
 799   GSocketAddress *addr;
 800
 801   sock = g_socket_accept (data->server, NULL, &error);
 802   g_assert_no_error (error);
 803
 804   g_assert_cmpint (g_socket_get_family (sock), ==, G_SOCKET_FAMILY_IPV6);
 805
 806   addr = g_socket_get_local_address (sock, &error);
 807   g_assert_no_error (error);
 808   g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
 809   g_object_unref (addr);
 810
 811   addr = g_socket_get_remote_address (sock, &error);
 812   g_assert_no_error (error);
 813   g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
 814   g_object_unref (addr);
 815
 816   g_socket_close (sock, &error);
 817   g_assert_no_error (error);
 818   g_object_unref (sock);
 819   return NULL;
 820 }
 821
 822 static void
 823 test_ipv6_v4mapped (void)
 824 {
 825   IPTestData *data;
 826   GError *error = NULL;
 827   GSocket *client;
 828   GSocketAddress *addr, *v4addr;
 829   GInetAddress *iaddr;
 830
 831   if (!ipv6_supported)
 832     {
 833       g_test_skip ("No support for IPv6");
 834       return;
 835     }
 836
 837   data = create_server (G_SOCKET_FAMILY_IPV6, v4mapped_server_thread, TRUE);
 838
 839   if (data == NULL)
 840     {
 841       g_test_message ("Test not run: not supported by the OS");
 842       return;
 843     }
 844
 845   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
 846                          G_SOCKET_TYPE_STREAM,
 847                          G_SOCKET_PROTOCOL_DEFAULT,
 848                          &error);
 849   g_assert_no_error (error);
 850
 851   g_socket_set_blocking (client, TRUE);
 852   g_socket_set_timeout (client, 1);
 853
 854   addr = g_socket_get_local_address (data->server, &error);
 855   g_assert_no_error (error);
 856   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
 857   v4addr = g_inet_socket_address_new (iaddr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)));
 858   g_object_unref (iaddr);
 859   g_object_unref (addr);
 860
 861   g_socket_connect (client, v4addr, NULL, &error);
 862   g_assert_no_error (error);
 863   g_assert (g_socket_is_connected (client));
 864
 865   g_thread_join (data->thread);
 866
 867   g_socket_close (client, &error);
 868   g_assert_no_error (error);
 869   g_socket_close (data->server, &error);
 870   g_assert_no_error (error);
 871
 872   g_object_unref (data->server);
 873   g_object_unref (client);
 874   g_object_unref (v4addr);
 875
 876   g_slice_free (IPTestData, data);
 877 }
 878 #endif
 879
 880 static void
 881 test_timed_wait (void)
 882 {
 883   IPTestData *data;
 884   GError *error = NULL;
 885   GSocket *client;
 886   GSocketAddress *addr;
 887   gint64 start_time;
 888   gint poll_duration;
 889
 890   data = create_server (G_SOCKET_FAMILY_IPV4, echo_server_thread, FALSE);
 891   addr = g_socket_get_local_address (data->server, &error);
 892   g_assert_no_error (error);
 893
 894   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
 895                          G_SOCKET_TYPE_STREAM,
 896                          G_SOCKET_PROTOCOL_DEFAULT,
 897                          &error);
 898   g_assert_no_error (error);
 899
 900   g_socket_set_blocking (client, TRUE);
 901   g_socket_set_timeout (client, 1);
 902
 903   g_socket_connect (client, addr, NULL, &error);
 904   g_assert_no_error (error);
 905   g_object_unref (addr);
 906
 907   start_time = g_get_monotonic_time ();
 908   g_socket_condition_timed_wait (client, G_IO_IN, 100000 /* 100 ms */,
 909                                  NULL, &error);
 910   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
 911   g_clear_error (&error);
 912   poll_duration = g_get_monotonic_time () - start_time;
 913
 914   g_assert_cmpint (poll_duration, >=, 98000);
 915   g_assert_cmpint (poll_duration, <, 112000);
 916
 917   g_socket_close (client, &error);
 918   g_assert_no_error (error);
 919
 920   g_thread_join (data->thread);
 921
 922   g_socket_close (data->server, &error);
 923   g_assert_no_error (error);
 924
 925   g_object_unref (data->server);
 926   g_object_unref (client);
 927
 928   g_slice_free (IPTestData, data);
 929 }
 930
 931 static void
 932 test_sockaddr (void)
 933 {
 934   struct sockaddr_in6 sin6, gsin6;
 935   GSocketAddress *saddr;
 936   GInetSocketAddress *isaddr;
 937   GInetAddress *iaddr;
 938   GError *error = NULL;
 939
 940   memset (&sin6, 0, sizeof (sin6));
 941   sin6.sin6_family = AF_INET6;
 942   sin6.sin6_addr = in6addr_loopback;
 943   sin6.sin6_port = g_htons (42);
 944   sin6.sin6_scope_id = 17;
 945   sin6.sin6_flowinfo = 1729;
 946
 947   saddr = g_socket_address_new_from_native (&sin6, sizeof (sin6));
 948   g_assert (G_IS_INET_SOCKET_ADDRESS (saddr));
 949
 950   isaddr = G_INET_SOCKET_ADDRESS (saddr);
 951   iaddr = g_inet_socket_address_get_address (isaddr);
 952   g_assert_cmpint (g_inet_address_get_family (iaddr), ==, G_SOCKET_FAMILY_IPV6);
 953   g_assert (g_inet_address_get_is_loopback (iaddr));
 954
 955   g_assert_cmpint (g_inet_socket_address_get_port (isaddr), ==, 42);
 956   g_assert_cmpint (g_inet_socket_address_get_scope_id (isaddr), ==, 17);
 957   g_assert_cmpint (g_inet_socket_address_get_flowinfo (isaddr), ==, 1729);
 958
 959   g_socket_address_to_native (saddr, &gsin6, sizeof (gsin6), &error);
 960   g_assert_no_error (error);
 961
 962   g_assert (memcmp (&sin6.sin6_addr, &gsin6.sin6_addr, sizeof (struct in6_addr)) == 0);
 963   g_assert_cmpint (sin6.sin6_port, ==, gsin6.sin6_port);
 964   g_assert_cmpint (sin6.sin6_scope_id, ==, gsin6.sin6_scope_id);
 965   g_assert_cmpint (sin6.sin6_flowinfo, ==, gsin6.sin6_flowinfo);
 966
 967   g_object_unref (saddr);
 968 }
 969
 970 #ifdef G_OS_UNIX
 971 static void
 972 test_unix_from_fd (void)
 973 {
 974   gint fd;
 975   GError *error;
 976   GSocket *s;
 977
 978   fd = socket (AF_UNIX, SOCK_STREAM, 0);
 979   g_assert_cmpint (fd, !=, -1);
 980
 981   error = NULL;
 982   s = g_socket_new_from_fd (fd, &error);
 983   g_assert_no_error (error);
 984   g_assert_cmpint (g_socket_get_family (s), ==, G_SOCKET_FAMILY_UNIX);
 985   g_assert_cmpint (g_socket_get_socket_type (s), ==, G_SOCKET_TYPE_STREAM);
 986   g_assert_cmpint (g_socket_get_protocol (s), ==, G_SOCKET_PROTOCOL_DEFAULT);
 987   g_object_unref (s);
 988 }
 989
 990 static void
 991 test_unix_connection (void)
 992 {
 993   gint fd;
 994   GError *error;
 995   GSocket *s;
 996   GSocketConnection *c;
 997
 998   fd = socket (AF_UNIX, SOCK_STREAM, 0);
 999   g_assert_cmpint (fd, !=, -1);
1000
1001   error = NULL;
1002   s = g_socket_new_from_fd (fd, &error);
1003   g_assert_no_error (error);
1004   c = g_socket_connection_factory_create_connection (s);
1005   g_assert (G_IS_UNIX_CONNECTION (c));
1006   g_object_unref (c);
1007   g_object_unref (s);
1008 }
1009
1010 static GSocketConnection *
1011 create_connection_for_fd (int fd)
1012 {
1013   GError *err = NULL;
1014   GSocket *socket;
1015   GSocketConnection *connection;
1016
1017   socket = g_socket_new_from_fd (fd, &err);
1018   g_assert_no_error (err);
1019   g_assert (G_IS_SOCKET (socket));
1020   connection = g_socket_connection_factory_create_connection (socket);
1021   g_assert (G_IS_UNIX_CONNECTION (connection));
1022   g_object_unref (socket);
1023   return connection;
1024 }
1025
1026 #define TEST_DATA "failure to say failure to say 'i love gnome-panel!'."
1027
1028 static void
1029 test_unix_connection_ancillary_data (void)
1030 {
1031   GError *err = NULL;
1032   gint pv[2], sv[3];
1033   gint status, fd, len;
1034   char buffer[1024];
1035   pid_t pid;
1036
1037   status = pipe (pv);
1038   g_assert_cmpint (status, ==, 0);
1039
1040   status = socketpair (PF_UNIX, SOCK_STREAM, 0, sv);
1041   g_assert_cmpint (status, ==, 0);
1042
1043   pid = fork ();
1044   g_assert_cmpint (pid, >=, 0);
1045
1046   /* Child: close its copy of the write end of the pipe, receive it
1047    * again from the parent over the socket, and write some text to it.
1048    *
1049    * Parent: send the write end of the pipe (still open for the
1050    * parent) over the socket, close it, and read some text from the
1051    * read end of the pipe.
1052    */
1053   if (pid == 0)
1054     {
1055       GSocketConnection *connection;
1056
1057       close (sv[1]);
1058       connection = create_connection_for_fd (sv[0]);
1059
1060       status = close (pv[1]);
1061       g_assert_cmpint (status, ==, 0);
1062
1063       err = NULL;
1064       fd = g_unix_connection_receive_fd (G_UNIX_CONNECTION (connection), NULL,
1065                                          &err);
1066       g_assert_no_error (err);
1067       g_assert_cmpint (fd, >, -1);
1068       g_object_unref (connection);
1069
1070       do
1071         len = write (fd, TEST_DATA, sizeof (TEST_DATA));
1072       while (len == -1 && errno == EINTR);
1073       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1074       exit (0);
1075     }
1076   else
1077     {
1078       GSocketConnection *connection;
1079
1080       close (sv[0]);
1081       connection = create_connection_for_fd (sv[1]);
1082
1083       err = NULL;
1084       g_unix_connection_send_fd (G_UNIX_CONNECTION (connection), pv[1], NULL,
1085                                  &err);
1086       g_assert_no_error (err);
1087       g_object_unref (connection);
1088
1089       status = close (pv[1]);
1090       g_assert_cmpint (status, ==, 0);
1091
1092       memset (buffer, 0xff, sizeof buffer);
1093       do
1094         len = read (pv[0], buffer, sizeof buffer);
1095       while (len == -1 && errno == EINTR);
1096
1097       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
1098       g_assert_cmpstr (buffer, ==, TEST_DATA);
1099
1100       waitpid (pid, &status, 0);
1101       g_assert (WIFEXITED (status));
1102       g_assert_cmpint (WEXITSTATUS (status), ==, 0);
1103     }
1104
1105   /* TODO: add test for g_unix_connection_send_credentials() and
1106    * g_unix_connection_receive_credentials().
1107    */
1108 }
1109 #endif /* G_OS_UNIX */
1110
1111 static void
1112 test_reuse_tcp (void)
1113 {
1114   GSocket *sock1, *sock2;
1115   GError *error = NULL;
1116   GInetAddress *iaddr;
1117   GSocketAddress *addr;
1118
1119   sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1120                         G_SOCKET_TYPE_STREAM,
1121                         G_SOCKET_PROTOCOL_DEFAULT,
1122                         &error);
1123   g_assert_no_error (error);
1124
1125   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1126   addr = g_inet_socket_address_new (iaddr, 0);
1127   g_object_unref (iaddr);
1128   g_socket_bind (sock1, addr, TRUE, &error);
1129   g_object_unref (addr);
1130   g_assert_no_error (error);
1131
1132   g_socket_listen (sock1, &error);
1133   g_assert_no_error (error);
1134
1135   sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1136                         G_SOCKET_TYPE_STREAM,
1137                         G_SOCKET_PROTOCOL_DEFAULT,
1138                         &error);
1139   g_assert_no_error (error);
1140
1141   addr = g_socket_get_local_address (sock1, &error);
1142   g_assert_no_error (error);
1143   g_socket_bind (sock2, addr, TRUE, &error);
1144   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_ADDRESS_IN_USE);
1145   g_clear_error (&error);
1146   g_object_unref (addr);
1147
1148   g_object_unref (sock1);
1149   g_object_unref (sock2);
1150 }
1151
1152 static void
1153 test_reuse_udp (void)
1154 {
1155   GSocket *sock1, *sock2;
1156   GError *error = NULL;
1157   GInetAddress *iaddr;
1158   GSocketAddress *addr;
1159
1160   sock1 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1161                         G_SOCKET_TYPE_DATAGRAM,
1162                         G_SOCKET_PROTOCOL_DEFAULT,
1163                         &error);
1164   g_assert_no_error (error);
1165
1166   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
1167   addr = g_inet_socket_address_new (iaddr, 0);
1168   g_object_unref (iaddr);
1169   g_socket_bind (sock1, addr, TRUE, &error);
1170   g_object_unref (addr);
1171   g_assert_no_error (error);
1172
1173   sock2 = g_socket_new (G_SOCKET_FAMILY_IPV4,
1174                         G_SOCKET_TYPE_DATAGRAM,
1175                         G_SOCKET_PROTOCOL_DEFAULT,
1176                         &error);
1177   g_assert_no_error (error);
1178
1179   addr = g_socket_get_local_address (sock1, &error);
1180   g_assert_no_error (error);
1181   g_socket_bind (sock2, addr, TRUE, &error);
1182   g_object_unref (addr);
1183   g_assert_no_error (error);
1184
1185   g_object_unref (sock1);
1186   g_object_unref (sock2);
1187 }
1188
1189 static void
1190 test_get_available (gconstpointer user_data)
1191 {
1192   GSocketType socket_type = GPOINTER_TO_UINT (user_data);
1193   GError *err = NULL;
1194   GSocket *listener, *server, *client;
1195   GInetAddress *addr;
1196   GSocketAddress *saddr;
1197   gchar data[] = "0123456789abcdef";
1198   gchar buf[34];
1199   gssize nread;
1200
1201   listener = g_socket_new (G_SOCKET_FAMILY_IPV4,
1202                            socket_type,
1203                            G_SOCKET_PROTOCOL_DEFAULT,
1204                            &err);
1205   g_assert_no_error (err);
1206   g_assert (G_IS_SOCKET (listener));
1207
1208   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
1209                          socket_type,
1210                          G_SOCKET_PROTOCOL_DEFAULT,
1211                          &err);
1212   g_assert_no_error (err);
1213   g_assert (G_IS_SOCKET (client));
1214
1215   if (socket_type == G_SOCKET_TYPE_STREAM)
1216     {
1217       g_socket_set_option (client, IPPROTO_TCP, TCP_NODELAY, TRUE, &err);
1218       g_assert_no_error (err);
1219     }
1220
1221   addr = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
1222   saddr = g_inet_socket_address_new (addr, 0);
1223
1224   g_socket_bind (listener, saddr, TRUE, &err);
1225   g_assert_no_error (err);
1226   g_object_unref (saddr);
1227   g_object_unref (addr);
1228
1229   saddr = g_socket_get_local_address (listener, &err);
1230   g_assert_no_error (err);
1231
1232   if (socket_type == G_SOCKET_TYPE_STREAM)
1233     {
1234       g_socket_listen (listener, &err);
1235       g_assert_no_error (err);
1236       g_socket_connect (client, saddr, NULL, &err);
1237       g_assert_no_error (err);
1238
1239       server = g_socket_accept (listener, NULL, &err);
1240       g_assert_no_error (err);
1241       g_socket_set_blocking (server, FALSE);
1242       g_object_unref (listener);
1243     }
1244   else
1245     server = listener;
1246
1247   g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1248   g_assert_no_error (err);
1249
1250   while (!g_socket_condition_wait (server, G_IO_IN, NULL, NULL))
1251     ;
1252   g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1253
1254   g_socket_send_to (client, saddr, data, sizeof (data), NULL, &err);
1255   g_assert_no_error (err);
1256
1257   /* We need to wait until the data has actually been copied into the
1258    * server socket's buffers, but g_socket_condition_wait() won't help
1259    * here since the socket is definitely already readable. So there's
1260    * a race condition in checking its available bytes. In the TCP
1261    * case, we poll for a bit until the new data shows up. In the UDP
1262    * case, there's not much we can do, but at least the failure mode
1263    * is passes-when-it-shouldn't, not fails-when-it-shouldn't.
1264    */
1265   if (socket_type == G_SOCKET_TYPE_STREAM)
1266     {
1267       int tries;
1268
1269       for (tries = 0; tries < 100; tries++)
1270         {
1271           if (g_socket_get_available_bytes (server) > sizeof (data))
1272             break;
1273           g_usleep (100000);
1274         }
1275
1276       g_assert_cmpint (g_socket_get_available_bytes (server), ==, 2 * sizeof (data));
1277     }
1278   else
1279     {
1280       g_usleep (100000);
1281       g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1282     }
1283
1284   g_assert_cmpint (sizeof (buf), >=, 2 * sizeof (data));
1285   nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1286   g_assert_no_error (err);
1287
1288   if (socket_type == G_SOCKET_TYPE_STREAM)
1289     {
1290       g_assert_cmpint (nread, ==, 2 * sizeof (data));
1291       g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1292     }
1293   else
1294     {
1295       g_assert_cmpint (nread, ==, sizeof (data));
1296       g_assert_cmpint (g_socket_get_available_bytes (server), ==, sizeof (data));
1297     }
1298
1299   nread = g_socket_receive (server, buf, sizeof (buf), NULL, &err);
1300   if (socket_type == G_SOCKET_TYPE_STREAM)
1301     {
1302       g_assert_cmpint (nread, ==, -1);
1303       g_assert_error (err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
1304       g_clear_error (&err);
1305     }
1306   else
1307     {
1308       g_assert_cmpint (nread, ==, sizeof (data));
1309       g_assert_no_error (err);
1310     }
1311
1312   g_assert_cmpint (g_socket_get_available_bytes (server), ==, 0);
1313
1314   g_socket_close (server, &err);
1315   g_assert_no_error (err);
1316
1317   g_object_unref (saddr);
1318   g_object_unref (server);
1319   g_object_unref (client);
1320 }
1321
1322 int
1323 main (int   argc,
1324       char *argv[])
1325 {
1326   GSocket *sock;
1327   GError *error = NULL;
1328
1329   g_test_init (&argc, &argv, NULL);
1330
1331   sock = g_socket_new (G_SOCKET_FAMILY_IPV6,
1332                        G_SOCKET_TYPE_STREAM,
1333                        G_SOCKET_PROTOCOL_DEFAULT,
1334                        &error);
1335   if (sock != NULL)
1336     {
1337       ipv6_supported = TRUE;
1338       g_object_unref (sock);
1339     }
1340   else
1341     {
1342       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1343       g_clear_error (&error);
1344     }
1345
1346   g_test_add_func ("/socket/ipv4_sync", test_ipv4_sync);
1347   g_test_add_func ("/socket/ipv4_async", test_ipv4_async);
1348   g_test_add_func ("/socket/ipv6_sync", test_ipv6_sync);
1349   g_test_add_func ("/socket/ipv6_async", test_ipv6_async);
1350   g_test_add_func ("/socket/ipv4_sync/datagram", test_ipv4_sync_dgram);
1351   g_test_add_func ("/socket/ipv6_sync/datagram", test_ipv6_sync_dgram);
1352 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
1353   g_test_add_func ("/socket/ipv6_v4mapped", test_ipv6_v4mapped);
1354 #endif
1355   g_test_add_func ("/socket/close_graceful", test_close_graceful);
1356   g_test_add_func ("/socket/timed_wait", test_timed_wait);
1357   g_test_add_func ("/socket/address", test_sockaddr);
1358 #ifdef G_OS_UNIX
1359   g_test_add_func ("/socket/unix-from-fd", test_unix_from_fd);
1360   g_test_add_func ("/socket/unix-connection", test_unix_connection);
1361   g_test_add_func ("/socket/unix-connection-ancillary-data", test_unix_connection_ancillary_data);
1362 #endif
1363   g_test_add_func ("/socket/reuse/tcp", test_reuse_tcp);
1364   g_test_add_func ("/socket/reuse/udp", test_reuse_udp);
1365   g_test_add_data_func ("/socket/get_available/datagram", GUINT_TO_POINTER (G_SOCKET_TYPE_DATAGRAM),
1366                         test_get_available);
1367   g_test_add_data_func ("/socket/get_available/stream", GUINT_TO_POINTER (G_SOCKET_TYPE_STREAM),
1368                         test_get_available);
1369
1370   return g_test_run();
1371 }
1372