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, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <gio/gio.h>
  22
  23 #ifdef G_OS_UNIX
  24 #include <errno.h>
  25 #include <sys/types.h>
  26 #include <sys/socket.h>
  27 #include <sys/wait.h>
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <gio/gunixconnection.h>
  31 #endif
  32
  33 #include "gnetworkingprivate.h"
  34
  35 typedef struct {
  36   GSocket *server;
  37   GSocket *client;
  38   GSocketFamily family;
  39   GThread *thread;
  40   GMainLoop *loop;
  41 } IPTestData;
  42
  43 static gpointer
  44 echo_server_thread (gpointer user_data)
  45 {
  46   IPTestData *data = user_data;
  47   GSocket *sock;
  48   GError *error = NULL;
  49   gssize nread, nwrote;
  50   gchar buf[128];
  51
  52   sock = g_socket_accept (data->server, NULL, &error);
  53   g_assert_no_error (error);
  54
  55   while (TRUE)
  56     {
  57       nread = g_socket_receive (sock, buf, sizeof (buf), NULL, &error);
  58       g_assert_no_error (error);
  59       g_assert_cmpint (nread, >=, 0);
  60
  61       if (nread == 0)
  62         break;
  63
  64       nwrote = g_socket_send (sock, buf, nread, NULL, &error);
  65       g_assert_no_error (error);
  66       g_assert_cmpint (nwrote, ==, nread);
  67     }
  68
  69   g_socket_close (sock, &error);
  70   g_assert_no_error (error);
  71   g_object_unref (sock);
  72   return NULL;
  73 }
  74
  75 static IPTestData *
  76 create_server (GSocketFamily family,
  77                GThreadFunc   server_thread,
  78                gboolean      v4mapped)
  79 {
  80   IPTestData *data;
  81   GSocket *server;
  82   GError *error = NULL;
  83   GSocketAddress *addr;
  84   GInetAddress *iaddr;
  85
  86   data = g_slice_new (IPTestData);
  87   data->family = family;
  88
  89   data->server = server = g_socket_new (family,
  90                                         G_SOCKET_TYPE_STREAM,
  91                                         G_SOCKET_PROTOCOL_DEFAULT,
  92                                         &error);
  93   g_assert_no_error (error);
  94
  95   g_assert_cmpint (g_socket_get_family (server), ==, family);
  96   g_assert_cmpint (g_socket_get_socket_type (server), ==, G_SOCKET_TYPE_STREAM);
  97   g_assert_cmpint (g_socket_get_protocol (server), ==, G_SOCKET_PROTOCOL_DEFAULT);
  98
  99   g_socket_set_blocking (server, TRUE);
 100
 101 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
 102   if (v4mapped)
 103     {
 104       int fd, v6_only;
 105
 106       fd = g_socket_get_fd (server);
 107       v6_only = 0;
 108       setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, &v6_only, sizeof (v6_only));
 109     }
 110 #endif
 111
 112   if (v4mapped)
 113     iaddr = g_inet_address_new_any (family);
 114   else
 115     iaddr = g_inet_address_new_loopback (family);
 116   addr = g_inet_socket_address_new (iaddr, 0);
 117   g_object_unref (iaddr);
 118
 119   g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), ==, 0);
 120   g_socket_bind (server, addr, TRUE, &error);
 121   g_assert_no_error (error);
 122   g_object_unref (addr);
 123
 124   addr = g_socket_get_local_address (server, &error);
 125   g_assert_no_error (error);
 126   g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), !=, 0);
 127   g_object_unref (addr);
 128
 129   g_socket_listen (server, &error);
 130   g_assert_no_error (error);
 131
 132   data->thread = g_thread_new ("server", server_thread, data);
 133
 134   return data;
 135 }
 136
 137 static const gchar *testbuf = "0123456789abcdef";
 138
 139 static gboolean
 140 test_ip_async_read_ready (GSocket      *client,
 141                           GIOCondition  cond,
 142                           gpointer      user_data)
 143 {
 144   IPTestData *data = user_data;
 145   GError *error = NULL;
 146   gssize len;
 147   gchar buf[128];
 148
 149   g_assert_cmpint (cond, ==, G_IO_IN);
 150
 151   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 152   g_assert_no_error (error);
 153   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 154
 155   g_assert_cmpstr (testbuf, ==, buf);
 156
 157   g_main_loop_quit (data->loop);
 158
 159   return FALSE;
 160 }
 161
 162 static gboolean
 163 test_ip_async_write_ready (GSocket      *client,
 164                            GIOCondition  cond,
 165                            gpointer      user_data)
 166 {
 167   IPTestData *data = user_data;
 168   GError *error = NULL;
 169   GSource *source;
 170   gssize len;
 171
 172   g_assert_cmpint (cond, ==, G_IO_OUT);
 173
 174   len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
 175   g_assert_no_error (error);
 176   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 177
 178   source = g_socket_create_source (client, G_IO_IN, NULL);
 179   g_source_set_callback (source, (GSourceFunc)test_ip_async_read_ready,
 180                          data, NULL);
 181   g_source_attach (source, NULL);
 182   g_source_unref (source);
 183
 184   return FALSE;
 185 }
 186
 187 static gboolean
 188 test_ip_async_timed_out (GSocket      *client,
 189                          GIOCondition  cond,
 190                          gpointer      user_data)
 191 {
 192   IPTestData *data = user_data;
 193   GError *error = NULL;
 194   GSource *source;
 195   gssize len;
 196   gchar buf[128];
 197
 198   if (data->family == G_SOCKET_FAMILY_IPV4)
 199     {
 200       g_assert_cmpint (cond, ==, G_IO_IN);
 201       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 202       g_assert_cmpint (len, ==, -1);
 203       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
 204       g_clear_error (&error);
 205     }
 206
 207   source = g_socket_create_source (client, G_IO_OUT, NULL);
 208   g_source_set_callback (source, (GSourceFunc)test_ip_async_write_ready,
 209                          data, NULL);
 210   g_source_attach (source, NULL);
 211   g_source_unref (source);
 212
 213   return FALSE;
 214 }
 215
 216 static gboolean
 217 test_ip_async_connected (GSocket      *client,
 218                          GIOCondition  cond,
 219                          gpointer      user_data)
 220 {
 221   IPTestData *data = user_data;
 222   GError *error = NULL;
 223   GSource *source;
 224   gssize len;
 225   gchar buf[128];
 226
 227   g_socket_check_connect_result (client, &error);
 228   g_assert_no_error (error);
 229   /* We do this after the check_connect_result, since that will give a
 230    * more useful assertion in case of error.
 231    */
 232   g_assert_cmpint (cond, ==, G_IO_OUT);
 233
 234   g_assert (g_socket_is_connected (client));
 235
 236   /* This adds 1 second to "make check", so let's just only do it once. */
 237   if (data->family == G_SOCKET_FAMILY_IPV4)
 238     {
 239       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 240       g_assert_cmpint (len, ==, -1);
 241       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
 242       g_clear_error (&error);
 243
 244       source = g_socket_create_source (client, G_IO_IN, NULL);
 245       g_source_set_callback (source, (GSourceFunc)test_ip_async_timed_out,
 246                              data, NULL);
 247       g_source_attach (source, NULL);
 248       g_source_unref (source);
 249     }
 250   else
 251     test_ip_async_timed_out (client, 0, data);
 252
 253   return FALSE;
 254 }
 255
 256 static gboolean
 257 idle_test_ip_async_connected (gpointer user_data)
 258 {
 259   IPTestData *data = user_data;
 260
 261   return test_ip_async_connected (data->client, G_IO_OUT, data);
 262 }
 263
 264 static void
 265 test_ip_async (GSocketFamily family)
 266 {
 267   IPTestData *data;
 268   GError *error = NULL;
 269   GSocket *client;
 270   GSocketAddress *addr;
 271   GSource *source;
 272   gssize len;
 273   gchar buf[128];
 274
 275   data = create_server (family, echo_server_thread, FALSE);
 276   addr = g_socket_get_local_address (data->server, &error);
 277
 278   client = g_socket_new (family,
 279                          G_SOCKET_TYPE_STREAM,
 280                          G_SOCKET_PROTOCOL_DEFAULT,
 281                          &error);
 282   g_assert_no_error (error);
 283   data->client = client;
 284
 285   g_assert_cmpint (g_socket_get_family (client), ==, family);
 286   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
 287   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 288
 289   g_socket_set_blocking (client, FALSE);
 290   g_socket_set_timeout (client, 1);
 291
 292   if (g_socket_connect (client, addr, NULL, &error))
 293     {
 294       g_assert_no_error (error);
 295       g_idle_add (idle_test_ip_async_connected, data);
 296     }
 297   else
 298     {
 299       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_PENDING);
 300       g_clear_error (&error);
 301       source = g_socket_create_source (client, G_IO_OUT, NULL);
 302       g_source_set_callback (source, (GSourceFunc)test_ip_async_connected,
 303                              data, NULL);
 304       g_source_attach (source, NULL);
 305       g_source_unref (source);
 306     }
 307   g_object_unref (addr);
 308
 309   data->loop = g_main_loop_new (NULL, TRUE);
 310   g_main_loop_run (data->loop);
 311   g_main_loop_unref (data->loop);
 312
 313   g_socket_shutdown (client, FALSE, TRUE, &error);
 314   g_assert_no_error (error);
 315
 316   g_thread_join (data->thread);
 317
 318   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 319   g_assert_no_error (error);
 320   g_assert_cmpint (len, ==, 0);
 321
 322   g_socket_close (client, &error);
 323   g_assert_no_error (error);
 324   g_socket_close (data->server, &error);
 325   g_assert_no_error (error);
 326
 327   g_object_unref (data->server);
 328   g_object_unref (client);
 329
 330   g_slice_free (IPTestData, data);
 331 }
 332
 333 static void
 334 test_ipv4_async (void)
 335 {
 336   test_ip_async (G_SOCKET_FAMILY_IPV4);
 337 }
 338
 339 static void
 340 test_ipv6_async (void)
 341 {
 342   test_ip_async (G_SOCKET_FAMILY_IPV6);
 343 }
 344
 345 static void
 346 test_ip_sync (GSocketFamily family)
 347 {
 348   IPTestData *data;
 349   GError *error = NULL;
 350   GSocket *client;
 351   GSocketAddress *addr;
 352   gssize len;
 353   gchar buf[128];
 354
 355   data = create_server (family, echo_server_thread, FALSE);
 356   addr = g_socket_get_local_address (data->server, &error);
 357
 358   client = g_socket_new (family,
 359                          G_SOCKET_TYPE_STREAM,
 360                          G_SOCKET_PROTOCOL_DEFAULT,
 361                          &error);
 362   g_assert_no_error (error);
 363
 364   g_assert_cmpint (g_socket_get_family (client), ==, family);
 365   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
 366   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 367
 368   g_socket_set_blocking (client, TRUE);
 369   g_socket_set_timeout (client, 1);
 370
 371   g_socket_connect (client, addr, NULL, &error);
 372   g_assert_no_error (error);
 373   g_assert (g_socket_is_connected (client));
 374   g_object_unref (addr);
 375
 376   /* This adds 1 second to "make check", so let's just only do it once. */
 377   if (family == G_SOCKET_FAMILY_IPV4)
 378     {
 379       len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 380       g_assert_cmpint (len, ==, -1);
 381       g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
 382       g_clear_error (&error);
 383     }
 384
 385   len = g_socket_send (client, testbuf, strlen (testbuf) + 1, NULL, &error);
 386   g_assert_no_error (error);
 387   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 388
 389   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 390   g_assert_no_error (error);
 391   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 392
 393   g_assert_cmpstr (testbuf, ==, buf);
 394
 395   g_socket_shutdown (client, FALSE, TRUE, &error);
 396   g_assert_no_error (error);
 397
 398   g_thread_join (data->thread);
 399
 400   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 401   g_assert_no_error (error);
 402   g_assert_cmpint (len, ==, 0);
 403
 404   g_socket_close (client, &error);
 405   g_assert_no_error (error);
 406   g_socket_close (data->server, &error);
 407   g_assert_no_error (error);
 408
 409   g_object_unref (data->server);
 410   g_object_unref (client);
 411
 412   g_slice_free (IPTestData, data);
 413 }
 414
 415 static void
 416 test_ipv4_sync (void)
 417 {
 418   test_ip_sync (G_SOCKET_FAMILY_IPV4);
 419 }
 420
 421 static void
 422 test_ipv6_sync (void)
 423 {
 424   test_ip_sync (G_SOCKET_FAMILY_IPV6);
 425 }
 426
 427 static gpointer
 428 graceful_server_thread (gpointer user_data)
 429 {
 430   IPTestData *data = user_data;
 431   GSocket *sock;
 432   GError *error = NULL;
 433   gssize len;
 434
 435   sock = g_socket_accept (data->server, NULL, &error);
 436   g_assert_no_error (error);
 437
 438   len = g_socket_send (sock, testbuf, strlen (testbuf) + 1, NULL, &error);
 439   g_assert_no_error (error);
 440   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 441
 442   return sock;
 443 }
 444
 445 static void
 446 test_close_graceful (void)
 447 {
 448   GSocketFamily family = G_SOCKET_FAMILY_IPV4;
 449   IPTestData *data;
 450   GError *error = NULL;
 451   GSocket *client, *server;
 452   GSocketAddress *addr;
 453   gssize len;
 454   gchar buf[128];
 455
 456   data = create_server (family, graceful_server_thread, FALSE);
 457   addr = g_socket_get_local_address (data->server, &error);
 458
 459   client = g_socket_new (family,
 460                          G_SOCKET_TYPE_STREAM,
 461                          G_SOCKET_PROTOCOL_DEFAULT,
 462                          &error);
 463   g_assert_no_error (error);
 464
 465   g_assert_cmpint (g_socket_get_family (client), ==, family);
 466   g_assert_cmpint (g_socket_get_socket_type (client), ==, G_SOCKET_TYPE_STREAM);
 467   g_assert_cmpint (g_socket_get_protocol (client), ==, G_SOCKET_PROTOCOL_DEFAULT);
 468
 469   g_socket_set_blocking (client, TRUE);
 470   g_socket_set_timeout (client, 1);
 471
 472   g_socket_connect (client, addr, NULL, &error);
 473   g_assert_no_error (error);
 474   g_assert (g_socket_is_connected (client));
 475   g_object_unref (addr);
 476
 477   server = g_thread_join (data->thread);
 478
 479   /* similar to g_tcp_connection_set_graceful_disconnect(), but explicit */
 480   g_socket_shutdown (server, FALSE, TRUE, &error);
 481   g_assert_no_error (error);
 482
 483   /* we must timeout */
 484   g_socket_condition_wait (client, G_IO_HUP, NULL, &error);
 485   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
 486   g_clear_error (&error);
 487
 488   /* check that the remaining data is received */
 489   len = g_socket_receive (client, buf, strlen (testbuf) + 1, NULL, &error);
 490   g_assert_no_error (error);
 491   g_assert_cmpint (len, ==, strlen (testbuf) + 1);
 492
 493   /* and only then the connection is closed */
 494   len = g_socket_receive (client, buf, sizeof (buf), NULL, &error);
 495   g_assert_no_error (error);
 496   g_assert_cmpint (len, ==, 0);
 497
 498   g_socket_close (server, &error);
 499   g_assert_no_error (error);
 500
 501   g_socket_close (client, &error);
 502   g_assert_no_error (error);
 503
 504   g_object_unref (server);
 505   g_object_unref (data->server);
 506   g_object_unref (client);
 507
 508   g_slice_free (IPTestData, data);
 509 }
 510
 511 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
 512 static gpointer
 513 v4mapped_server_thread (gpointer user_data)
 514 {
 515   IPTestData *data = user_data;
 516   GSocket *sock;
 517   GError *error = NULL;
 518   GSocketAddress *addr;
 519
 520   sock = g_socket_accept (data->server, NULL, &error);
 521   g_assert_no_error (error);
 522
 523   g_assert_cmpint (g_socket_get_family (sock), ==, G_SOCKET_FAMILY_IPV6);
 524
 525   addr = g_socket_get_local_address (sock, &error);
 526   g_assert_no_error (error);
 527   g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
 528   g_object_unref (addr);
 529
 530   addr = g_socket_get_remote_address (sock, &error);
 531   g_assert_no_error (error);
 532   g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
 533   g_object_unref (addr);
 534
 535   g_socket_close (sock, &error);
 536   g_assert_no_error (error);
 537   g_object_unref (sock);
 538   return NULL;
 539 }
 540
 541 static void
 542 test_ipv6_v4mapped (void)
 543 {
 544   IPTestData *data;
 545   GError *error = NULL;
 546   GSocket *client;
 547   GSocketAddress *addr, *v4addr;
 548   GInetAddress *iaddr;
 549
 550   data = create_server (G_SOCKET_FAMILY_IPV6, v4mapped_server_thread, TRUE);
 551
 552   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
 553                          G_SOCKET_TYPE_STREAM,
 554                          G_SOCKET_PROTOCOL_DEFAULT,
 555                          &error);
 556   g_assert_no_error (error);
 557
 558   g_socket_set_blocking (client, TRUE);
 559   g_socket_set_timeout (client, 1);
 560
 561   addr = g_socket_get_local_address (data->server, &error);
 562   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
 563   v4addr = g_inet_socket_address_new (iaddr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)));
 564   g_object_unref (iaddr);
 565   g_object_unref (addr);
 566
 567   g_socket_connect (client, v4addr, NULL, &error);
 568   g_assert_no_error (error);
 569   g_assert (g_socket_is_connected (client));
 570
 571   g_thread_join (data->thread);
 572
 573   g_socket_close (client, &error);
 574   g_assert_no_error (error);
 575   g_socket_close (data->server, &error);
 576   g_assert_no_error (error);
 577
 578   g_object_unref (data->server);
 579   g_object_unref (client);
 580   g_object_unref (v4addr);
 581
 582   g_slice_free (IPTestData, data);
 583 }
 584 #endif
 585
 586 static void
 587 test_sockaddr (void)
 588 {
 589   struct sockaddr_in6 sin6, gsin6;
 590   GSocketAddress *saddr;
 591   GInetSocketAddress *isaddr;
 592   GInetAddress *iaddr;
 593   GError *error = NULL;
 594
 595   memset (&sin6, 0, sizeof (sin6));
 596   sin6.sin6_family = AF_INET6;
 597   sin6.sin6_addr = in6addr_loopback;
 598   sin6.sin6_port = g_htons (42);
 599   sin6.sin6_scope_id = g_htonl (17);
 600   sin6.sin6_flowinfo = g_htonl (1729);
 601
 602   saddr = g_socket_address_new_from_native (&sin6, sizeof (sin6));
 603   g_assert (G_IS_INET_SOCKET_ADDRESS (saddr));
 604
 605   isaddr = G_INET_SOCKET_ADDRESS (saddr);
 606   iaddr = g_inet_socket_address_get_address (isaddr);
 607   g_assert_cmpint (g_inet_address_get_family (iaddr), ==, G_SOCKET_FAMILY_IPV6);
 608   g_assert (g_inet_address_get_is_loopback (iaddr));
 609
 610   g_assert_cmpint (g_inet_socket_address_get_port (isaddr), ==, 42);
 611   g_assert_cmpint (g_inet_socket_address_get_scope_id (isaddr), ==, 17);
 612   g_assert_cmpint (g_inet_socket_address_get_flowinfo (isaddr), ==, 1729);
 613
 614   g_socket_address_to_native (saddr, &gsin6, sizeof (gsin6), &error);
 615   g_assert_no_error (error);
 616
 617   g_assert (memcmp (&sin6.sin6_addr, &gsin6.sin6_addr, sizeof (struct in6_addr)) == 0);
 618   g_assert_cmpint (sin6.sin6_port, ==, gsin6.sin6_port);
 619   g_assert_cmpint (sin6.sin6_scope_id, ==, gsin6.sin6_scope_id);
 620   g_assert_cmpint (sin6.sin6_flowinfo, ==, gsin6.sin6_flowinfo);
 621
 622   g_object_unref (saddr);
 623 }
 624
 625 #ifdef G_OS_UNIX
 626 static void
 627 test_unix_from_fd (void)
 628 {
 629   gint fd;
 630   GError *error;
 631   GSocket *s;
 632
 633   fd = socket (AF_UNIX, SOCK_STREAM, 0);
 634   g_assert_cmpint (fd, !=, -1);
 635
 636   error = NULL;
 637   s = g_socket_new_from_fd (fd, &error);
 638   g_assert_no_error (error);
 639   g_assert_cmpint (g_socket_get_family (s), ==, G_SOCKET_FAMILY_UNIX);
 640   g_assert_cmpint (g_socket_get_socket_type (s), ==, G_SOCKET_TYPE_STREAM);
 641   g_assert_cmpint (g_socket_get_protocol (s), ==, G_SOCKET_PROTOCOL_DEFAULT);
 642   g_object_unref (s);
 643 }
 644
 645 static void
 646 test_unix_connection (void)
 647 {
 648   gint fd;
 649   GError *error;
 650   GSocket *s;
 651   GSocketConnection *c;
 652
 653   fd = socket (AF_UNIX, SOCK_STREAM, 0);
 654   g_assert_cmpint (fd, !=, -1);
 655
 656   error = NULL;
 657   s = g_socket_new_from_fd (fd, &error);
 658   g_assert_no_error (error);
 659   c = g_socket_connection_factory_create_connection (s);
 660   g_assert (G_IS_UNIX_CONNECTION (c));
 661   g_object_unref (c);
 662   g_object_unref (s);
 663 }
 664
 665 static GSocketConnection *
 666 create_connection_for_fd (int fd)
 667 {
 668   GError *err = NULL;
 669   GSocket *socket;
 670   GSocketConnection *connection;
 671
 672   socket = g_socket_new_from_fd (fd, &err);
 673   g_assert_no_error (err);
 674   g_assert (G_IS_SOCKET (socket));
 675   connection = g_socket_connection_factory_create_connection (socket);
 676   g_assert (G_IS_UNIX_CONNECTION (connection));
 677   g_object_unref (socket);
 678   return connection;
 679 }
 680
 681 #define TEST_DATA "failure to say failure to say 'i love gnome-panel!'."
 682
 683 static void
 684 test_unix_connection_ancillary_data (void)
 685 {
 686   GError *err = NULL;
 687   gint pv[2], sv[3];
 688   gint status, fd, len;
 689   char buffer[1024];
 690   pid_t pid;
 691
 692   status = pipe (pv);
 693   g_assert_cmpint (status, ==, 0);
 694
 695   status = socketpair (PF_UNIX, SOCK_STREAM, 0, sv);
 696   g_assert_cmpint (status, ==, 0);
 697
 698   pid = fork ();
 699   g_assert_cmpint (pid, >=, 0);
 700
 701   /* Child: close its copy of the write end of the pipe, receive it
 702    * again from the parent over the socket, and write some text to it.
 703    *
 704    * Parent: send the write end of the pipe (still open for the
 705    * parent) over the socket, close it, and read some text from the
 706    * read end of the pipe.
 707    */
 708   if (pid == 0)
 709     {
 710       GSocketConnection *connection;
 711
 712       close (sv[1]);
 713       connection = create_connection_for_fd (sv[0]);
 714
 715       status = close (pv[1]);
 716       g_assert_cmpint (status, ==, 0);
 717
 718       err = NULL;
 719       fd = g_unix_connection_receive_fd (G_UNIX_CONNECTION (connection), NULL,
 720                                          &err);
 721       g_assert_no_error (err);
 722       g_assert_cmpint (fd, >, -1);
 723       g_object_unref (connection);
 724
 725       do
 726         len = write (fd, TEST_DATA, sizeof (TEST_DATA));
 727       while (len == -1 && errno == EINTR);
 728       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
 729       exit (0);
 730     }
 731   else
 732     {
 733       GSocketConnection *connection;
 734
 735       close (sv[0]);
 736       connection = create_connection_for_fd (sv[1]);
 737
 738       err = NULL;
 739       g_unix_connection_send_fd (G_UNIX_CONNECTION (connection), pv[1], NULL,
 740                                  &err);
 741       g_assert_no_error (err);
 742       g_object_unref (connection);
 743
 744       status = close (pv[1]);
 745       g_assert_cmpint (status, ==, 0);
 746
 747       memset (buffer, 0xff, sizeof buffer);
 748       do
 749         len = read (pv[0], buffer, sizeof buffer);
 750       while (len == -1 && errno == EINTR);
 751
 752       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
 753       g_assert_cmpstr (buffer, ==, TEST_DATA);
 754
 755       waitpid (pid, &status, 0);
 756       g_assert (WIFEXITED (status));
 757       g_assert_cmpint (WEXITSTATUS (status), ==, 0);
 758     }
 759
 760   /* TODO: add test for g_unix_connection_send_credentials() and
 761    * g_unix_connection_receive_credentials().
 762    */
 763 }
 764 #endif /* G_OS_UNIX */
 765
 766 int
 767 main (int   argc,
 768       char *argv[])
 769 {
 770   g_type_init ();
 771   g_test_init (&argc, &argv, NULL);
 772
 773   g_test_add_func ("/socket/ipv4_sync", test_ipv4_sync);
 774   g_test_add_func ("/socket/ipv4_async", test_ipv4_async);
 775   g_test_add_func ("/socket/ipv6_sync", test_ipv6_sync);
 776   g_test_add_func ("/socket/ipv6_async", test_ipv6_async);
 777   g_test_add_func ("/socket/close_graceful", test_close_graceful);
 778 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
 779   g_test_add_func ("/socket/ipv6_v4mapped", test_ipv6_v4mapped);
 780 #endif
 781   g_test_add_func ("/socket/address", test_sockaddr);
 782 #ifdef G_OS_UNIX
 783   g_test_add_func ("/socket/unix-from-fd", test_unix_from_fd);
 784   g_test_add_func ("/socket/unix-connection", test_unix_connection);
 785   g_test_add_func ("/socket/unix-connection-ancillary-data", test_unix_connection_ancillary_data);
 786 #endif
 787
 788   return g_test_run();
 789 }
 790