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 #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   g_object_unref (sock);
 454   return NULL;
 455 }
 456
 457 static void
 458 test_ipv6_v4mapped (void)
 459 {
 460   IPTestData *data;
 461   GError *error = NULL;
 462   GSocket *client;
 463   GSocketAddress *addr, *v4addr;
 464   GInetAddress *iaddr;
 465
 466   data = create_server (G_SOCKET_FAMILY_IPV6, v4mapped_server_thread, TRUE);
 467
 468   client = g_socket_new (G_SOCKET_FAMILY_IPV4,
 469                          G_SOCKET_TYPE_STREAM,
 470                          G_SOCKET_PROTOCOL_DEFAULT,
 471                          &error);
 472   g_assert_no_error (error);
 473
 474   g_socket_set_blocking (client, TRUE);
 475   g_socket_set_timeout (client, 1);
 476
 477   addr = g_socket_get_local_address (data->server, &error);
 478   iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
 479   v4addr = g_inet_socket_address_new (iaddr, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr)));
 480   g_object_unref (iaddr);
 481   g_object_unref (addr);
 482
 483   g_socket_connect (client, v4addr, NULL, &error);
 484   g_assert_no_error (error);
 485   g_assert (g_socket_is_connected (client));
 486
 487   g_thread_join (data->thread);
 488
 489   g_socket_close (client, &error);
 490   g_assert_no_error (error);
 491   g_socket_close (data->server, &error);
 492   g_assert_no_error (error);
 493
 494   g_object_unref (data->server);
 495   g_object_unref (client);
 496   g_object_unref (v4addr);
 497
 498   g_slice_free (IPTestData, data);
 499 }
 500 #endif
 501
 502 #ifdef G_OS_UNIX
 503 static void
 504 test_unix_from_fd (void)
 505 {
 506   gint fd;
 507   GError *error;
 508   GSocket *s;
 509
 510   fd = socket (AF_UNIX, SOCK_STREAM, 0);
 511   g_assert_cmpint (fd, !=, -1);
 512
 513   error = NULL;
 514   s = g_socket_new_from_fd (fd, &error);
 515   g_assert_no_error (error);
 516   g_assert_cmpint (g_socket_get_family (s), ==, G_SOCKET_FAMILY_UNIX);
 517   g_assert_cmpint (g_socket_get_socket_type (s), ==, G_SOCKET_TYPE_STREAM);
 518   g_assert_cmpint (g_socket_get_protocol (s), ==, G_SOCKET_PROTOCOL_DEFAULT);
 519   g_object_unref (s);
 520 }
 521
 522 static void
 523 test_unix_connection (void)
 524 {
 525   gint fd;
 526   GError *error;
 527   GSocket *s;
 528   GSocketConnection *c;
 529
 530   fd = socket (AF_UNIX, SOCK_STREAM, 0);
 531   g_assert_cmpint (fd, !=, -1);
 532
 533   error = NULL;
 534   s = g_socket_new_from_fd (fd, &error);
 535   g_assert_no_error (error);
 536   c = g_socket_connection_factory_create_connection (s);
 537   g_assert (G_IS_UNIX_CONNECTION (c));
 538   g_object_unref (c);
 539   g_object_unref (s);
 540 }
 541
 542 static GSocketConnection *
 543 create_connection_for_fd (int fd)
 544 {
 545   GError *err = NULL;
 546   GSocket *socket;
 547   GSocketConnection *connection;
 548
 549   socket = g_socket_new_from_fd (fd, &err);
 550   g_assert_no_error (err);
 551   g_assert (G_IS_SOCKET (socket));
 552   connection = g_socket_connection_factory_create_connection (socket);
 553   g_assert (G_IS_UNIX_CONNECTION (connection));
 554   g_object_unref (socket);
 555   return connection;
 556 }
 557
 558 #define TEST_DATA "failure to say failure to say 'i love gnome-panel!'."
 559
 560 static void
 561 test_unix_connection_ancillary_data (void)
 562 {
 563   GError *err = NULL;
 564   gint pv[2], sv[3];
 565   gint status, fd, len;
 566   char buffer[1024];
 567   pid_t pid;
 568
 569   status = pipe (pv);
 570   g_assert_cmpint (status, ==, 0);
 571
 572   status = socketpair (PF_UNIX, SOCK_STREAM, 0, sv);
 573   g_assert_cmpint (status, ==, 0);
 574
 575   pid = fork ();
 576   g_assert_cmpint (pid, >=, 0);
 577
 578   /* Child: close its copy of the write end of the pipe, receive it
 579    * again from the parent over the socket, and write some text to it.
 580    *
 581    * Parent: send the write end of the pipe (still open for the
 582    * parent) over the socket, close it, and read some text from the
 583    * read end of the pipe.
 584    */
 585   if (pid == 0)
 586     {
 587       GSocketConnection *connection;
 588
 589       close (sv[1]);
 590       connection = create_connection_for_fd (sv[0]);
 591
 592       status = close (pv[1]);
 593       g_assert_cmpint (status, ==, 0);
 594
 595       err = NULL;
 596       fd = g_unix_connection_receive_fd (G_UNIX_CONNECTION (connection), NULL,
 597                                          &err);
 598       g_assert_no_error (err);
 599       g_assert_cmpint (fd, >, -1);
 600       g_object_unref (connection);
 601
 602       do
 603         len = write (fd, TEST_DATA, sizeof (TEST_DATA));
 604       while (len == -1 && errno == EINTR);
 605       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
 606       exit (0);
 607     }
 608   else
 609     {
 610       GSocketConnection *connection;
 611
 612       close (sv[0]);
 613       connection = create_connection_for_fd (sv[1]);
 614
 615       err = NULL;
 616       g_unix_connection_send_fd (G_UNIX_CONNECTION (connection), pv[1], NULL,
 617                                  &err);
 618       g_assert_no_error (err);
 619       g_object_unref (connection);
 620
 621       status = close (pv[1]);
 622       g_assert_cmpint (status, ==, 0);
 623
 624       memset (buffer, 0xff, sizeof buffer);
 625       do
 626         len = read (pv[0], buffer, sizeof buffer);
 627       while (len == -1 && errno == EINTR);
 628
 629       g_assert_cmpint (len, ==, sizeof (TEST_DATA));
 630       g_assert_cmpstr (buffer, ==, TEST_DATA);
 631
 632       waitpid (pid, &status, 0);
 633       g_assert (WIFEXITED (status));
 634       g_assert_cmpint (WEXITSTATUS (status), ==, 0);
 635     }
 636
 637   /* TODO: add test for g_unix_connection_send_credentials() and
 638    * g_unix_connection_receive_credentials().
 639    */
 640 }
 641 #endif /* G_OS_UNIX */
 642
 643 int
 644 main (int   argc,
 645       char *argv[])
 646 {
 647   g_type_init ();
 648   g_test_init (&argc, &argv, NULL);
 649
 650   g_test_add_func ("/socket/ipv4_sync", test_ipv4_sync);
 651   g_test_add_func ("/socket/ipv4_async", test_ipv4_async);
 652   g_test_add_func ("/socket/ipv6_sync", test_ipv6_sync);
 653   g_test_add_func ("/socket/ipv6_async", test_ipv6_async);
 654 #if defined (IPPROTO_IPV6) && defined (IPV6_V6ONLY)
 655   g_test_add_func ("/socket/ipv6_v4mapped", test_ipv6_v4mapped);
 656 #endif
 657 #ifdef G_OS_UNIX
 658   g_test_add_func ("/socket/unix-from-fd", test_unix_from_fd);
 659   g_test_add_func ("/socket/unix-connection", test_unix_connection);
 660   g_test_add_func ("/socket/unix-connection-ancillary-data", test_unix_connection_ancillary_data);
 661 #endif
 662
 663   return g_test_run();
 664 }
 665