gio/tests/send-data.c

   1 #include <gio/gio.h>
   2 #include <string.h>
   3 #include <stdio.h>
   4
   5 GMainLoop *loop;
   6
   7 int cancel_timeout = 0;
   8 int io_timeout = 0;
   9 gboolean async = FALSE;
  10 gboolean graceful = FALSE;
  11 gboolean verbose = FALSE;
  12 static GOptionEntry cmd_entries[] = {
  13   {"cancel", 'c', 0, G_OPTION_ARG_INT, &cancel_timeout,
  14    "Cancel any op after the specified amount of seconds", NULL},
  15   {"async", 'a', 0, G_OPTION_ARG_NONE, &async,
  16    "Use async ops", NULL},
  17   {"graceful-disconnect", 'g', 0, G_OPTION_ARG_NONE, &graceful,
  18    "Use graceful disconnect", NULL},
  19   {"timeout", 't', 0, G_OPTION_ARG_INT, &io_timeout,
  20    "Time out socket I/O after the specified number of seconds", NULL},
  21   {"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
  22    "Verbose debugging output", NULL},
  23   {NULL}
  24 };
  25
  26 static gpointer
  27 cancel_thread (gpointer data)
  28 {
  29   GCancellable *cancellable = data;
  30
  31   g_usleep (1000*1000*cancel_timeout);
  32   g_print ("Cancelling\n");
  33   g_cancellable_cancel (cancellable);
  34   return NULL;
  35 }
  36
  37 static char *
  38 socket_address_to_string (GSocketAddress *address)
  39 {
  40   GInetAddress *inet_address;
  41   char *str, *res;
  42   int port;
  43
  44   inet_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (address));
  45   str = g_inet_address_to_string (inet_address);
  46   port = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (address));
  47   res = g_strdup_printf ("%s:%d", str, port);
  48   g_free (str);
  49   return res;
  50 }
  51
  52 static void
  53 async_cb (GObject *source_object,
  54           GAsyncResult *res,
  55           gpointer user_data)
  56 {
  57   GAsyncResult **resp = user_data;
  58   *resp = g_object_ref (res);
  59   g_main_loop_quit (loop);
  60 }
  61
  62 static void
  63 socket_client_event (GSocketClient *client,
  64                      GSocketClientEvent event,
  65                      GSocketConnectable *connectable,
  66                      GSocketConnection *connection)
  67 {
  68   static GEnumClass *event_class;
  69   GTimeVal tv;
  70
  71   if (!event_class)
  72     event_class = g_type_class_ref (G_TYPE_SOCKET_CLIENT_EVENT);
  73
  74   g_get_current_time (&tv);
  75   printf ("% 12ld.%06ld GSocketClient => %s [%s]\n",
  76           tv.tv_sec, tv.tv_usec,
  77           g_enum_get_value (event_class, event)->value_nick,
  78           connection ? G_OBJECT_TYPE_NAME (connection) : "");
  79 }
  80
  81 int
  82 main (int argc, char *argv[])
  83 {
  84   GOptionContext *context;
  85   GSocketClient *client;
  86   GSocketConnection *connection;
  87   GSocketAddress *address;
  88   GCancellable *cancellable;
  89   GOutputStream *out;
  90   GError *error = NULL;
  91   char buffer[1000];
  92
  93   g_type_init ();
  94
  95   context = g_option_context_new (" <hostname>[:port] - send data to tcp host");
  96   g_option_context_add_main_entries (context, cmd_entries, NULL);
  97   if (!g_option_context_parse (context, &argc, &argv, &error))
  98     {
  99       g_printerr ("%s: %s\n", argv[0], error->message);
 100       return 1;
 101     }
 102
 103   if (argc != 2)
 104     {
 105       g_printerr ("%s: %s\n", argv[0], "Need to specify hostname");
 106       return 1;
 107     }
 108
 109   if (async)
 110     loop = g_main_loop_new (NULL, FALSE);
 111
 112   if (cancel_timeout)
 113     {
 114       GThread *thread;
 115       cancellable = g_cancellable_new ();
 116       thread = g_thread_new ("cancel", cancel_thread, cancellable);
 117       g_thread_unref (thread);
 118     }
 119   else
 120     {
 121       cancellable = NULL;
 122     }
 123
 124   client = g_socket_client_new ();
 125   if (io_timeout)
 126     g_socket_client_set_timeout (client, io_timeout);
 127   if (verbose)
 128     g_signal_connect (client, "event", G_CALLBACK (socket_client_event), NULL);
 129
 130   if (async)
 131     {
 132       GAsyncResult *res;
 133       g_socket_client_connect_to_host_async (client, argv[1], 7777,
 134                                              cancellable, async_cb, &res);
 135       g_main_loop_run (loop);
 136       connection = g_socket_client_connect_to_host_finish (client, res, &error);
 137       g_object_unref (res);
 138     }
 139   else
 140     {
 141       connection = g_socket_client_connect_to_host (client,
 142                                                     argv[1],
 143                                                     7777,
 144                                                     cancellable, &error);
 145     }
 146   if (connection == NULL)
 147     {
 148       g_printerr ("%s can't connect: %s\n", argv[0], error->message);
 149       return 1;
 150     }
 151   g_object_unref (client);
 152
 153   address = g_socket_connection_get_remote_address (connection, &error);
 154   if (!address)
 155     {
 156       g_printerr ("Error getting remote address: %s\n",
 157                   error->message);
 158       return 1;
 159     }
 160   g_print ("Connected to address: %s\n",
 161            socket_address_to_string (address));
 162   g_object_unref (address);
 163
 164   if (graceful)
 165     g_tcp_connection_set_graceful_disconnect (G_TCP_CONNECTION (connection), TRUE);
 166
 167   out = g_io_stream_get_output_stream (G_IO_STREAM (connection));
 168
 169   while (fgets(buffer, sizeof (buffer), stdin) != NULL)
 170     {
 171       /* FIXME if (async) */
 172       if (!g_output_stream_write_all (out, buffer, strlen (buffer),
 173                                       NULL, cancellable, &error))
 174         {
 175           g_warning ("send error: %s\n",  error->message);
 176           g_error_free (error);
 177           error = NULL;
 178         }
 179     }
 180
 181   g_print ("closing stream\n");
 182   if (async)
 183     {
 184       GAsyncResult *res;
 185       g_io_stream_close_async (G_IO_STREAM (connection),
 186                                0, cancellable, async_cb, &res);
 187       g_main_loop_run (loop);
 188       if (!g_io_stream_close_finish (G_IO_STREAM (connection),
 189                                      res, &error))
 190         {
 191           g_object_unref (res);
 192           g_warning ("close error: %s\n",  error->message);
 193           return 1;
 194         }
 195       g_object_unref (res);
 196     }
 197   else
 198     {
 199       if (!g_io_stream_close (G_IO_STREAM (connection), cancellable, &error))
 200         {
 201           g_warning ("close error: %s\n",  error->message);
 202           return 1;
 203         }
 204     }
 205
 206   g_object_unref (connection);
 207
 208   return 0;
 209 }