glib/test-thread-server.c

   1 #include <glib.h>
   2 #include "dbus-glib.h"
   3 #include <stdio.h>
   4 #include <string.h>
   5
   6 #include "test-thread.h"
   7
   8 typedef struct {
   9   guint32 counters[N_TEST_THREADS];
  10 } ThreadTestData;
  11
  12 static ThreadTestData *
  13 thread_test_data_new (void)
  14 {
  15   ThreadTestData *data;
  16
  17   data = g_new0 (ThreadTestData, 1);
  18
  19   return data;
  20 }
  21
  22 static void
  23 thread_test_data_free (ThreadTestData *data)
  24 {
  25   g_free (data);
  26 }
  27
  28 static DBusMessageHandler *disconnect_handler;
  29 static DBusMessageHandler *filter_handler;
  30 static int handler_slot;
  31
  32 static DBusHandlerResult
  33 handle_test_message (DBusMessageHandler *handler,
  34                      DBusConnection     *connection,
  35                      DBusMessage        *message,
  36                      void               *user_data)
  37 {
  38   ThreadTestData *data = user_data;
  39   DBusMessageIter iter;
  40   gint32 threadnr;
  41   guint32 counter;
  42   char *str, *expected_str;
  43   GString *counter_str;
  44   int i;
  45
  46   dbus_message_iter_init (message, &iter);
  47
  48   if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INT32)
  49     {
  50       g_print ("First arg not right type\n");
  51       goto out;
  52     }
  53   threadnr = dbus_message_iter_get_int32 (&iter);
  54   if (threadnr < 0 || threadnr >= N_TEST_THREADS)
  55     {
  56       g_print ("Invalid thread nr\n");
  57       goto out;
  58     }
  59
  60   if (! dbus_message_iter_next (&iter))
  61     {
  62       g_print ("Couldn't get second arg\n");
  63       goto out;
  64     }
  65
  66   if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_UINT32)
  67     {
  68       g_print ("Second arg not right type\n");
  69       goto out;
  70     }
  71
  72   counter = dbus_message_iter_get_uint32 (&iter);
  73
  74   if (counter != data->counters[threadnr])
  75     {
  76       g_print ("Thread %d, counter %d, expected %d\n", threadnr, counter, data->counters[threadnr]);
  77       goto out;
  78     }
  79   data->counters[threadnr]++;
  80
  81   if (! dbus_message_iter_next (&iter))
  82     {
  83       g_print ("Couldn't get third arg\n");
  84       goto out;
  85     }
  86
  87   if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING)
  88     {
  89       g_print ("Third arg not right type\n");
  90       goto out;
  91     }
  92
  93   str = dbus_message_iter_get_string (&iter);
  94
  95   if (str == NULL)
  96     {
  97       g_print ("No third arg\n");
  98       goto out;
  99     }
 100
 101   expected_str = g_strdup_printf ("Thread %d-%d\n", threadnr, counter);
 102   if (strcmp (expected_str, str) != 0)
 103     {
 104       g_print ("Wrong string '%s', expected '%s'\n", str, expected_str);
 105       goto out;
 106     }
 107   g_free (str);
 108   g_free (expected_str);
 109
 110   if (dbus_message_iter_next (&iter))
 111     {
 112       g_print ("Extra args on end of message\n");
 113       goto out;
 114     }
 115
 116   dbus_connection_flush (connection);
 117
 118   counter_str = g_string_new ("");
 119   for (i = 0; i < N_TEST_THREADS; i++)
 120     {
 121       g_string_append_printf (counter_str, "%d ", data->counters[i]);
 122     }
 123   g_print ("%s\r", counter_str->str);
 124   g_string_free (counter_str, TRUE);
 125
 126  out:
 127   return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
 128 }
 129
 130 static DBusHandlerResult
 131 handle_filter (DBusMessageHandler *handler,
 132                DBusConnection     *connection,
 133                DBusMessage        *message,
 134                void               *user_data)
 135 {
 136   return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
 137 }
 138
 139 static DBusHandlerResult
 140 handle_disconnect (DBusMessageHandler *handler,
 141                    DBusConnection     *connection,
 142                    DBusMessage        *message,
 143                    void               *user_data)
 144 {
 145   g_print ("connection disconnected\n");
 146   dbus_connection_unref (connection);
 147
 148   return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
 149 }
 150
 151
 152 static void
 153 new_connection_callback (DBusServer     *server,
 154                          DBusConnection *new_connection,
 155                          void           *user_data)
 156 {
 157   const char *test_messages[] = { "org.freedesktop.ThreadTest" };
 158   const char *disconnect_messages[] = { "org.freedesktop.Local.Disconnect" };
 159   DBusMessageHandler *test_message_handler;
 160   ThreadTestData * data;
 161
 162   g_print ("new_connection_callback\n");
 163
 164   dbus_connection_ref (new_connection);
 165   dbus_connection_setup_with_g_main (new_connection);
 166
 167   data = thread_test_data_new ();
 168
 169   test_message_handler =
 170     dbus_message_handler_new (handle_test_message,
 171                               data, (DBusFreeFunction)thread_test_data_free);
 172
 173   if (!dbus_connection_register_handler (new_connection,
 174                                          test_message_handler,
 175                                          test_messages, 1))
 176     goto nomem;
 177
 178   if (!dbus_connection_set_data (new_connection,
 179                                  handler_slot,
 180                                  test_message_handler,
 181                                  (DBusFreeFunction)dbus_message_handler_unref))
 182     goto nomem;
 183
 184   if (!dbus_connection_register_handler (new_connection,
 185                                          disconnect_handler,
 186                                          disconnect_messages, 1))
 187     goto nomem;
 188
 189   if (!dbus_connection_add_filter (new_connection,
 190                                    filter_handler))
 191     goto nomem;
 192
 193   return;
 194
 195  nomem:
 196   g_error ("no memory to setup new connection");
 197 }
 198
 199 int
 200 main (int argc, char *argv[])
 201 {
 202   GMainLoop *loop;
 203   DBusServer *server;
 204   DBusError error;
 205
 206   g_thread_init (NULL);
 207   dbus_gthread_init ();
 208
 209   if (argc < 2)
 210     {
 211       fprintf (stderr, "Give the server address as an argument\n");
 212       return 1;
 213     }
 214
 215   dbus_error_init (&error);
 216   server = dbus_server_listen (argv[1], &error);
 217   if (server == NULL)
 218     {
 219       fprintf (stderr, "Failed to start server on %s: %s\n",
 220                argv[1], error.message);
 221       dbus_error_free (&error);
 222       return 1;
 223     }
 224
 225   handler_slot = dbus_connection_allocate_data_slot ();
 226
 227   filter_handler =
 228     dbus_message_handler_new (handle_filter, NULL, NULL);
 229   if (filter_handler == NULL)
 230     g_error ("no memory for handler");
 231
 232   disconnect_handler =
 233     dbus_message_handler_new (handle_disconnect, NULL, NULL);
 234   if (disconnect_handler == NULL)
 235     g_error ("no memory for handler");
 236
 237   dbus_server_set_new_connection_function (server,
 238                                            new_connection_callback,
 239                                            NULL, NULL);
 240
 241   dbus_server_setup_with_g_main (server);
 242
 243   loop = g_main_loop_new (NULL, FALSE);
 244   g_main_run (loop);
 245
 246   return 0;
 247 }