gio/tests/socket-server.c

   1 #include <gio/gio.h>
   2 #include <glib.h>
   3 #include <stdlib.h>
   4
   5 GMainLoop *loop;
   6
   7 int port = 7777;
   8 gboolean verbose = FALSE;
   9 gboolean dont_reuse_address = FALSE;
  10 gboolean non_blocking = FALSE;
  11 gboolean use_udp = FALSE;
  12 gboolean use_source = FALSE;
  13 int cancel_timeout = 0;
  14
  15 static GOptionEntry cmd_entries[] = {
  16   {"port", 'p', 0, G_OPTION_ARG_INT, &port,
  17    "Local port to bind to", NULL},
  18   {"cancel", 'c', 0, G_OPTION_ARG_INT, &cancel_timeout,
  19    "Cancel any op after the specified amount of seconds", NULL},
  20   {"udp", 'u', 0, G_OPTION_ARG_NONE, &use_udp,
  21    "Use udp instead of tcp", NULL},
  22   {"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
  23    "Be verbose", NULL},
  24   {"no-reuse", 0, 0, G_OPTION_ARG_NONE, &dont_reuse_address,
  25    "Don't SOADDRREUSE", NULL},
  26   {"non-blocking", 'n', 0, G_OPTION_ARG_NONE, &non_blocking,
  27    "Enable non-blocking i/o", NULL},
  28   {"use-source", 's', 0, G_OPTION_ARG_NONE, &use_source,
  29    "Use GSource to wait for non-blocking i/o", NULL},
  30   {NULL}
  31 };
  32
  33 static char *
  34 socket_address_to_string (GSocketAddress *address)
  35 {
  36   GInetAddress *inet_address;
  37   char *str, *res;
  38   int the_port;
  39
  40   inet_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (address));
  41   str = g_inet_address_to_string (inet_address);
  42   the_port = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (address));
  43   res = g_strdup_printf ("%s:%d", str, the_port);
  44   g_free (str);
  45   return res;
  46 }
  47
  48 static gboolean
  49 source_ready (gpointer data,
  50               GIOCondition condition)
  51 {
  52   g_main_loop_quit (loop);
  53   return FALSE;
  54 }
  55
  56 static void
  57 ensure_condition (GSocket *socket,
  58                   const char *where,
  59                   GCancellable *cancellable,
  60                   GIOCondition condition)
  61 {
  62   GError *error = NULL;
  63   GSource *source;
  64
  65   if (!non_blocking)
  66     return;
  67
  68   if (use_source)
  69     {
  70       source = g_socket_create_source (socket,
  71                                        condition,
  72                                        cancellable);
  73       g_source_set_callback (source,
  74                              (GSourceFunc) source_ready,
  75                              NULL, NULL);
  76       g_source_attach (source, NULL);
  77       g_source_unref (source);
  78       g_main_loop_run (loop);
  79     }
  80   else
  81     {
  82       if (!g_socket_condition_wait (socket, condition, cancellable, &error))
  83         {
  84           g_printerr ("condition wait error for %s: %s\n",
  85                       where,
  86                       error->message);
  87           exit (1);
  88         }
  89     }
  90 }
  91
  92 static gpointer
  93 cancel_thread (gpointer data)
  94 {
  95   GCancellable *cancellable = data;
  96
  97   g_usleep (1000*1000*cancel_timeout);
  98   g_print ("Cancelling\n");
  99   g_cancellable_cancel (cancellable);
 100   return NULL;
 101 }
 102
 103 int
 104 main (int argc,
 105       char *argv[])
 106 {
 107   GSocket *socket, *new_socket, *recv_socket;
 108   GSocketAddress *src_address;
 109   GSocketAddress *address;
 110   GSocketType socket_type;
 111   GError *error = NULL;
 112   GOptionContext *context;
 113   GCancellable *cancellable;
 114
 115   g_thread_init (NULL);
 116
 117   g_type_init ();
 118
 119   context = g_option_context_new (" - Test GSocket server stuff");
 120   g_option_context_add_main_entries (context, cmd_entries, NULL);
 121   if (!g_option_context_parse (context, &argc, &argv, &error))
 122     {
 123       g_printerr ("%s: %s\n", argv[0], error->message);
 124       return 1;
 125     }
 126
 127   if (cancel_timeout)
 128     {
 129       cancellable = g_cancellable_new ();
 130       g_thread_create (cancel_thread, cancellable, FALSE, NULL);
 131     }
 132   else
 133     {
 134       cancellable = NULL;
 135     }
 136
 137   loop = g_main_loop_new (NULL, FALSE);
 138
 139   if (use_udp)
 140     socket_type = G_SOCKET_TYPE_DATAGRAM;
 141   else
 142     socket_type = G_SOCKET_TYPE_STREAM;
 143
 144   socket = g_socket_new (G_SOCKET_FAMILY_IPV4, socket_type, 0, &error);
 145
 146   if (socket == NULL)
 147     {
 148       g_printerr ("%s: %s\n", argv[0], error->message);
 149       return 1;
 150     }
 151
 152   if (non_blocking)
 153     g_socket_set_blocking (socket, FALSE);
 154
 155   src_address = g_inet_socket_address_new (g_inet_address_new_any (G_SOCKET_FAMILY_IPV4), port);
 156   if (!g_socket_bind (socket, src_address, !dont_reuse_address, &error))
 157     {
 158       g_printerr ("Can't bind socket: %s\n", error->message);
 159       return 1;
 160     }
 161   g_object_unref (src_address);
 162
 163   if (!use_udp)
 164     {
 165       if (!g_socket_listen (socket, &error))
 166         {
 167           g_printerr ("Can't listen on socket: %s\n", error->message);
 168           return 1;
 169         }
 170
 171       g_print ("listening on port %d...\n", port);
 172
 173       ensure_condition (socket, "accept", cancellable, G_IO_IN);
 174       new_socket = g_socket_accept (socket, cancellable, &error);
 175       if (!new_socket)
 176         {
 177           g_printerr ("Error accepting socket: %s\n",
 178                       error->message);
 179           return 1;
 180         }
 181
 182       if (non_blocking)
 183         g_socket_set_blocking (new_socket, FALSE);
 184
 185       address = g_socket_get_remote_address (new_socket, &error);
 186       if (!address)
 187         {
 188           g_printerr ("Error getting remote address: %s\n",
 189                       error->message);
 190           return 1;
 191         }
 192
 193       g_print ("got a new connection from %s\n",
 194                socket_address_to_string (address));
 195       g_object_unref (address);
 196
 197       recv_socket = new_socket;
 198     }
 199   else
 200     {
 201       recv_socket = socket;
 202       new_socket = NULL;
 203     }
 204
 205
 206   while (TRUE)
 207     {
 208       gchar buffer[4096] = { };
 209       gssize size;
 210       gsize to_send;
 211
 212       ensure_condition (recv_socket, "receive", cancellable, G_IO_IN);
 213       if (use_udp)
 214         size = g_socket_receive_from (recv_socket, &address,
 215                                       buffer, sizeof buffer,
 216                                       cancellable, &error);
 217       else
 218         size = g_socket_receive (recv_socket, buffer, sizeof buffer,
 219                                  cancellable, &error);
 220
 221       if (size < 0)
 222         {
 223           g_printerr ("Error receiving from socket: %s\n",
 224                       error->message);
 225           return 1;
 226         }
 227
 228       if (size == 0)
 229         break;
 230
 231       g_print ("received %" G_GSSIZE_FORMAT " bytes of data", size);
 232       if (use_udp)
 233         g_print (" from %s", socket_address_to_string (address));
 234       g_print ("\n");
 235
 236       if (verbose)
 237         g_print ("-------------------------\n"
 238                  "%.*s\n"
 239                  "-------------------------\n",
 240                  (int)size, buffer);
 241
 242       to_send = size;
 243
 244       while (to_send > 0)
 245         {
 246           ensure_condition (recv_socket, "send", cancellable, G_IO_OUT);
 247           if (use_udp)
 248             size = g_socket_send_to (recv_socket, address,
 249                                      buffer, to_send, cancellable, &error);
 250           else
 251             size = g_socket_send (recv_socket, buffer, to_send,
 252                                   cancellable, &error);
 253
 254           if (size < 0)
 255             {
 256               if (g_error_matches (error,
 257                                    G_IO_ERROR,
 258                                    G_IO_ERROR_WOULD_BLOCK))
 259                 {
 260                   g_print ("socket send would block, handling\n");
 261                   g_error_free (error);
 262                   error = NULL;
 263                   continue;
 264                 }
 265               else
 266                 {
 267                   g_printerr ("Error sending to socket: %s\n",
 268                               error->message);
 269                   return 1;
 270                 }
 271             }
 272
 273           g_print ("sent %" G_GSSIZE_FORMAT " bytes of data\n", size);
 274
 275           if (size == 0)
 276             {
 277               g_printerr ("Unexpected short write\n");
 278               return 1;
 279             }
 280
 281           to_send -= size;
 282         }
 283     }
 284
 285   g_print ("connection closed\n");
 286
 287   if (new_socket)
 288     {
 289       if (!g_socket_close (new_socket, &error))
 290         {
 291           g_printerr ("Error closing connection socket: %s\n",
 292                       error->message);
 293           return 1;
 294         }
 295
 296       g_object_unref (G_OBJECT (new_socket));
 297     }
 298
 299   if (!g_socket_close (socket, &error))
 300     {
 301       g_printerr ("Error closing master socket: %s\n",
 302                   error->message);
 303       return 1;
 304     }
 305
 306   g_object_unref (G_OBJECT (socket));
 307
 308   return 0;
 309 }