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