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   return NULL;
  72 }
  73
  74 static IPTestData *
  75 create_server (GSocketFamily family,
  76                GThreadFunc   server_thread,
  77                gboolean      v4mapped)
  78 {
  79   IPTestData *data;
  80   GSocket *server;
  81   GError *error = NULL;
  82   GSocketAddress *addr;
  83   GInetAddress *iaddr;
  84
  85   data = g_slice_new (IPTestData);
  86   data->family = family;
  87
  88   data->server = server = g_socket_new (family,
  89                                         G_SOCKET_TYPE_STREAM,
  90                                         G_SOCKET_PROTOCOL_DEFAULT,
  91                                         &error);
  92   g_assert_no_error (error);
  93
  94   g_assert_cmpint (g_socket_get_family (server), ==, family);
  95   g_assert_cmpint (g_socket_get_socket_type (server), ==, G_SOCKET_TYPE_STREAM);
  96   g_assert_cmpint (g_socket_get_protocol (server), ==, G_SOCKET_PROTOCOL_DEFAULT);
  97
  98   g_socket_set_blocking (server, TRUE);
  99
 100 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
 101   if (v4mapped)
 102     {
 103       int fd, v6_only;
 104
 105       fd = g_socket_get_fd (server);
 106       v6_only = 0;
 107       setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, &v6_only, sizeof (v6_only));
 108     }
 109 #endif
 110
 111   if (v4mapped)
 112     iaddr = g_inet_address_new_any (family);
 113   else
 114     iaddr = g_inet_address_new_loopback (family);
 115   addr = g_inet_socket_address_new (iaddr, 0);
 116   g_object_unref (iaddr);
 117
 118   g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), ==, 0);
 119   g_socket_bind (server, addr, TRUE, &error);
 120   g_assert_no_error (error);
 121   g_object_unref (addr);
 122
 123   addr = g_socket_get_local_address (server, &error);
 124   g_assert_no_error (error);
 125   g_assert_cmpint (g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)), !=, 0);
 126   g_object_unref (addr);
 127
 128   g_socket_listen (server, &error);
 129   g_assert_no_error (error);
 130
 131   data->thread = g_thread_new ("server", server_thread, data, &error);
 132   g_assert_no_error (error);
 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 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
 428 static gpointer
 429 v4mapped_server_thread (gpointer user_data)
 430 {
 431   IPTestData *data = user_data;
 432   GSocket *sock;
 433   GError *error = NULL;
 434   GSocketAddress *addr;
 435
 436   sock = g_socket_accept (data->server, NULL, &error);
 437   g_assert_no_error (error);
 438
 439   g_assert_cmpint (g_socket_get_family (sock), ==, G_SOCKET_FAMILY_IPV6);
 440
 441   addr = g_socket_get_local_address (sock, &error);
 442   g_assert_no_error (error);
 443   g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
 444   g_object_unref (addr);
 445
 446   addr = g_socket_get_remote_address (sock, &error);
 447   g_assert_no_error (error);
 448   g_assert_cmpint (g_socket_address_get_family (addr), ==, G_SOCKET_FAMILY_IPV4);
 449   g_object_unref (addr);
 450
 451   g_socket_close (sock, &error);
 452   g_assert_no_error (error);
 453   return NULL;
 454 }
 455
 456 static void
 457 test_ipv6_v4mapped (void)
 458 {
 459   IPTestData *data;
 460   GError *error = NULL;
 461   GSocket *client;
 462   GSocketAddress *addr, *v4addr;
 463   GInetAddress *iaddr;
 464
 465   data = create_server (G_SOCKET_FAMILY_IPV6, v4mapped_server_thread, TRUE);
 466
 467   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
 468                          G_SOCKET_TYPE_STREAM,
 469                          G_SOCKET_PROTOCOL_DEFAULT,
 470                          &error);
 471   g_assert_no_error (error);
 472
 473   g_socket_set_blocking (client, TRUE);
 474   g_socket_set_timeout (client, 1);
 475
 476   addr = g_socket_get_local_address (data->server, &error);
 477   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
 478   v4addr = g_inet_socket_address_new (iaddr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)));
 479   g_object_unref (iaddr);
 480   g_object_unref (addr);
 481
 482   g_socket_connect (client, v4addr, NULL, &error);
 483   g_assert_no_error (error);
 484   g_assert (g_socket_is_connected (client));
 485
 486   g_thread_join (data->thread);
 487
 488   g_socket_close (client, &error);
 489   g_assert_no_error (error);
 490   g_socket_close (data->server, &error);
 491   g_assert_no_error (error);
 492
 493   g_object_unref (data->server);
 494   g_object_unref (client);
 495
 496   g_slice_free (IPTestData, data);
 497 }
 498 #endif
 499
 500 #ifdef G_OS_UNIX
 501 static void
 502 test_unix_from_fd (void)
 503 {
 504   gint fd;
 505   GError *error;
 506   GSocket *s;
 507
 508   fd = socket (AF_UNIX, SOCK_STREAM, 0);
 509   g_assert_cmpint (fd, !=, -1);
 510
 511   error = NULL;
 512   s = g_socket_new_from_fd (fd, &error);
 513   g_assert_no_error (error);
 514   g_assert_cmpint (g_socket_get_family (s), ==, G_SOCKET_FAMILY_UNIX);
 515   g_assert_cmpint (g_socket_get_socket_type (s), ==, G_SOCKET_TYPE_STREAM);
 516   g_assert_cmpint (g_socket_get_protocol (s), ==, G_SOCKET_PROTOCOL_DEFAULT);
 517   g_object_unref (s);
 518 }
 519
 520 static void
 521 test_unix_connection (void)
 522 {
 523   gint fd;
 524   GError *error;
 525   GSocket *s;
 526   GSocketConnection *c;
 527
 528   fd = socket (AF_UNIX, SOCK_STREAM, 0);
 529   g_assert_cmpint (fd, !=, -1);
 530
 531   error = NULL;
 532   s = g_socket_new_from_fd (fd, &error);
 533   g_assert_no_error (error);
 534   c = g_socket_connection_factory_create_connection (s);
 535   g_assert (G_IS_UNIX_CONNECTION (c));
 536   g_object_unref (c);
 537   g_object_unref (s);
 538 }
 539
 540 static GSocketConnection *
 541 create_connection_for_fd (int fd)
 542 {
 543   GError *err = NULL;
 544   GSocket *socket;
 545   GSocketConnection *connection;
 546
 547   socket = g_socket_new_from_fd (fd, &err);
 548   g_assert_no_error (err);
 549   g_assert (G_IS_SOCKET (socket));
 550   connection = g_socket_connection_factory_create_connection (socket);
 551   g_assert (G_IS_UNIX_CONNECTION (connection));
 552   g_object_unref (socket);
 553   return connection;
 554 }
 555
 556 #define TEST_DATA "failure to say failure to say 'i love gnome-panel!'."
 557
 558 static void
 559 test_unix_connection_ancillary_data (void)
 560 {
 561   GError *err = NULL;
 562   gint pv[2], sv[3];
 563   gint status, fd, len;
 564   char buffer[1024];
 565   pid_t pid;
 566
 567   status = pipe (pv);
 568   g_assert_cmpint (status, ==, 0);
 569
 570   status = socketpair (PF_UNIX, SOCK_STREAM, 0, sv);
 571   g_assert_cmpint (status, ==, 0);
 572
 573   pid = fork ();
 574   g_assert_cmpint (pid, >=, 0);
 575
 576   /* Child: close its copy of the write end of the pipe, receive it
 577    * again from the parent over the socket, and write some text to it.
 578    *
 579    * Parent: send the write end of the pipe (still open for the
 580    * parent) over the socket, close it, and read some text from the
 581    * read end of the pipe.
 582    */
 583   if (pid == 0)
 584     {
 585       GSocketConnection *connection;
 586
 587       close (sv[1]);
 588       connection = create_connection_for_fd (sv[0]);
 589
 590       status = close (pv[1]);
 591       g_assert_cmpint (status, ==, 0);
 592
 593       err = NULL;
 594       fd = g_unix_connection_receive_fd (G_UNIX_CONNECTION (connection), NULL,
 595                                          &err);
 596       g_assert_no_error (err);
 597       g_assert_cmpint (fd, >, -1);
 598       g_object_unref (connection);
 599
 600       do
 601         len = write (fd, TEST_DATA, sizeof (TEST_DATA));
 602       while (len == -1 && errno == EINTR);
 603       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
 604       exit (0);
 605     }
 606   else
 607     {
 608       GSocketConnection *connection;
 609
 610       close (sv[0]);
 611       connection = create_connection_for_fd (sv[1]);
 612
 613       err = NULL;
 614       g_unix_connection_send_fd (G_UNIX_CONNECTION (connection), pv[1], NULL,
 615                                  &err);
 616       g_assert_no_error (err);
 617       g_object_unref (connection);
 618
 619       status = close (pv[1]);
 620       g_assert_cmpint (status, ==, 0);
 621
 622       memset (buffer, 0xff, sizeof buffer);
 623       do
 624         len = read (pv[0], buffer, sizeof buffer);
 625       while (len == -1 && errno == EINTR);
 626
 627       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
 628       g_assert_cmpstr (buffer, ==, TEST_DATA);
 629
 630       waitpid (pid, &status, 0);
 631       g_assert (WIFEXITED (status));
 632       g_assert_cmpint (WEXITSTATUS (status), ==, 0);
 633     }
 634
 635   /* TODO: add test for g_unix_connection_send_credentials() and
 636    * g_unix_connection_receive_credentials().
 637    */
 638 }
 639 #endif /* G_OS_UNIX */
 640
 641 int
 642 main (int   argc,
 643       char *argv[])
 644 {
 645   g_type_init ();
 646   g_test_init (&argc, &argv, NULL);
 647
 648   g_test_add_func ("/socket/ipv4_sync", test_ipv4_sync);
 649   g_test_add_func ("/socket/ipv4_async", test_ipv4_async);
 650   g_test_add_func ("/socket/ipv6_sync", test_ipv6_sync);
 651   g_test_add_func ("/socket/ipv6_async", test_ipv6_async);
 652 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
 653   g_test_add_func ("/socket/ipv6_v4mapped", test_ipv6_v4mapped);
 654 #endif
 655 #ifdef G_OS_UNIX
 656   g_test_add_func ("/socket/unix-from-fd", test_unix_from_fd);
 657   g_test_add_func ("/socket/unix-connection", test_unix_connection);
 658   g_test_add_func ("/socket/unix-connection-ancillary-data", test_unix_connection_ancillary_data);
 659 #endif
 660
 661   return g_test_run();
 662 }
 663