test/test-service.c

   1
   2 #include "test-utils.h"
   3
   4 static DBusLoop *loop;
   5 static dbus_bool_t already_quit = FALSE;
   6 static dbus_bool_t hello_from_self_reply_received = FALSE;
   7
   8 static void
   9 quit (void)
  10 {
  11   if (!already_quit)
  12     {
  13       _dbus_loop_quit (loop);
  14       already_quit = TRUE;
  15     }
  16 }
  17
  18 static void
  19 die (const char *message)
  20 {
  21   fprintf (stderr, "*** test-service: %s", message);
  22   exit (1);
  23 }
  24
  25 static void
  26 check_hello_from_self_reply (DBusPendingCall *pcall,
  27                              void *user_data)
  28 {
  29   DBusMessage *reply;
  30   DBusMessage *echo_message, *echo_reply = NULL;
  31   DBusError error;
  32   DBusConnection *connection;
  33
  34   int type;
  35
  36   dbus_error_init (&error);
  37
  38   connection = dbus_bus_get (DBUS_BUS_STARTER, &error);
  39   if (connection == NULL)
  40     {
  41       fprintf (stderr, "*** Failed to open connection to activating message bus: %s\n",
  42                error.message);
  43       dbus_error_free (&error);
  44       die("no memory");
  45     }
  46
  47
  48   echo_message = (DBusMessage *)user_data;
  49
  50   reply = dbus_pending_call_steal_reply (pcall);
  51
  52   type = dbus_message_get_type (reply);
  53
  54   if (type == DBUS_MESSAGE_TYPE_METHOD_RETURN)
  55     {
  56       const char *s;
  57       printf ("Reply from HelloFromSelf received\n");
  58
  59       if (!dbus_message_get_args (echo_message,
  60                               &error,
  61                               DBUS_TYPE_STRING, &s,
  62                               DBUS_TYPE_INVALID))
  63         {
  64             echo_reply = dbus_message_new_error (echo_message,
  65                                       error.name,
  66                                       error.message);
  67
  68             if (echo_reply == NULL)
  69               die ("No memory\n");
  70
  71         }
  72       else
  73         {
  74           echo_reply = dbus_message_new_method_return (echo_message);
  75           if (echo_reply == NULL)
  76             die ("No memory\n");
  77
  78           if (!dbus_message_append_args (echo_reply,
  79                                  DBUS_TYPE_STRING, &s,
  80                                  DBUS_TYPE_INVALID))
  81             die ("No memory");
  82         }
  83
  84       if (!dbus_connection_send (connection, echo_reply, NULL))
  85         die ("No memory\n");
  86
  87       dbus_message_unref (echo_reply);
  88     }
  89   else if (type == DBUS_MESSAGE_TYPE_ERROR)
  90     {
  91       dbus_set_error_from_message (&error, reply);
  92       printf ("Error type in reply: %s\n", error.message);
  93
  94       if (strcmp (error.name, DBUS_ERROR_NO_MEMORY) != 0)
  95         {
  96             echo_reply = dbus_message_new_error (echo_reply,
  97                                       error.name,
  98                                       error.message);
  99
 100             if (echo_reply == NULL)
 101               die ("No memory\n");
 102
 103             if (!dbus_connection_send (connection, echo_reply, NULL))
 104               die ("No memory\n");
 105
 106             dbus_message_unref (echo_reply);
 107         }
 108       dbus_error_free (&error);
 109     }
 110   else
 111      _dbus_assert_not_reached ("Unexpected message received\n");
 112
 113   hello_from_self_reply_received = TRUE;
 114
 115   dbus_message_unref (reply);
 116   dbus_message_unref (echo_message);
 117   dbus_pending_call_unref (pcall);
 118   dbus_connection_unref (connection);
 119 }
 120
 121 static DBusHandlerResult
 122 handle_run_hello_from_self (DBusConnection     *connection,
 123                                                DBusMessage        *message)
 124 {
 125   DBusError error;
 126   DBusMessage *reply, *self_message;
 127   DBusPendingCall *pcall;
 128   char *s;
 129
 130   _dbus_verbose ("sending reply to Echo method\n");
 131
 132   dbus_error_init (&error);
 133
 134   if (!dbus_message_get_args (message,
 135                               &error,
 136                               DBUS_TYPE_STRING, &s,
 137                               DBUS_TYPE_INVALID))
 138     {
 139       reply = dbus_message_new_error (message,
 140                                       error.name,
 141                                       error.message);
 142
 143       if (reply == NULL)
 144         die ("No memory\n");
 145
 146       if (!dbus_connection_send (connection, reply, NULL))
 147         die ("No memory\n");
 148
 149       dbus_message_unref (reply);
 150
 151       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 152     }
 153     printf ("Sending HelloFromSelf\n");
 154
 155  _dbus_verbose ("*** Sending message to self\n");
 156  self_message = dbus_message_new_method_call ("org.freedesktop.DBus.TestSuiteEchoService",
 157                                           "/org/freedesktop/TestSuite",
 158                                           "org.freedesktop.TestSuite",
 159                                           "HelloFromSelf");
 160
 161   if (self_message == NULL)
 162     die ("No memory");
 163
 164   if (!dbus_connection_send_with_reply (connection, self_message, &pcall, -1))
 165     die("No memory");
 166
 167   dbus_message_ref (message);
 168   if (!dbus_pending_call_set_notify (pcall, check_hello_from_self_reply, (void *)message, NULL))
 169     die("No memory");
 170
 171   printf ("Sent HelloFromSelf\n");
 172   return DBUS_HANDLER_RESULT_HANDLED;
 173 }
 174
 175 static DBusHandlerResult
 176 handle_echo (DBusConnection     *connection,
 177              DBusMessage        *message)
 178 {
 179   DBusError error;
 180   DBusMessage *reply;
 181   char *s;
 182
 183   _dbus_verbose ("sending reply to Echo method\n");
 184
 185   dbus_error_init (&error);
 186
 187   if (!dbus_message_get_args (message,
 188                               &error,
 189                               DBUS_TYPE_STRING, &s,
 190                               DBUS_TYPE_INVALID))
 191     {
 192       reply = dbus_message_new_error (message,
 193                                       error.name,
 194                                       error.message);
 195
 196       if (reply == NULL)
 197         die ("No memory\n");
 198
 199       if (!dbus_connection_send (connection, reply, NULL))
 200         die ("No memory\n");
 201
 202       dbus_message_unref (reply);
 203
 204       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 205     }
 206
 207   reply = dbus_message_new_method_return (message);
 208   if (reply == NULL)
 209     die ("No memory\n");
 210
 211   if (!dbus_message_append_args (reply,
 212                                  DBUS_TYPE_STRING, &s,
 213                                  DBUS_TYPE_INVALID))
 214     die ("No memory");
 215
 216   if (!dbus_connection_send (connection, reply, NULL))
 217     die ("No memory\n");
 218
 219   fprintf (stderr, "Echo service echoed string: \"%s\"\n", s);
 220
 221   dbus_message_unref (reply);
 222
 223   return DBUS_HANDLER_RESULT_HANDLED;
 224 }
 225
 226 static void
 227 path_unregistered_func (DBusConnection  *connection,
 228                         void            *user_data)
 229 {
 230   /* connection was finalized */
 231 }
 232
 233 static DBusHandlerResult
 234 path_message_func (DBusConnection  *connection,
 235                    DBusMessage     *message,
 236                    void            *user_data)
 237 {
 238   if (dbus_message_is_method_call (message,
 239                                    "org.freedesktop.TestSuite",
 240                                    "Echo"))
 241     return handle_echo (connection, message);
 242   else if (dbus_message_is_method_call (message,
 243                                         "org.freedesktop.TestSuite",
 244                                         "Exit"))
 245     {
 246       quit ();
 247       return DBUS_HANDLER_RESULT_HANDLED;
 248     }
 249   else if (dbus_message_is_method_call (message,
 250                                         "org.freedesktop.TestSuite",
 251                                         "EmitFoo"))
 252     {
 253       /* Emit the Foo signal */
 254       DBusMessage *signal;
 255       double v_DOUBLE;
 256
 257       _dbus_verbose ("emitting signal Foo\n");
 258
 259       signal = dbus_message_new_signal ("/org/freedesktop/TestSuite",
 260                                         "org.freedesktop.TestSuite",
 261                                         "Foo");
 262       if (signal == NULL)
 263         die ("No memory\n");
 264
 265       v_DOUBLE = 42.6;
 266       if (!dbus_message_append_args (signal,
 267                                      DBUS_TYPE_DOUBLE, &v_DOUBLE,
 268                                      DBUS_TYPE_INVALID))
 269         die ("No memory");
 270
 271       if (!dbus_connection_send (connection, signal, NULL))
 272         die ("No memory\n");
 273
 274       return DBUS_HANDLER_RESULT_HANDLED;
 275     }
 276
 277   else if (dbus_message_is_method_call (message,
 278                                    "org.freedesktop.TestSuite",
 279                                    "RunHelloFromSelf"))
 280     {
 281       return handle_run_hello_from_self (connection, message);
 282     }
 283   else if (dbus_message_is_method_call (message,
 284                                         "org.freedesktop.TestSuite",
 285                                         "HelloFromSelf"))
 286     {
 287         DBusMessage *reply;
 288         printf ("Received the HelloFromSelf message\n");
 289
 290         reply = dbus_message_new_method_return (message);
 291         if (reply == NULL)
 292           die ("No memory");
 293
 294         if (!dbus_connection_send (connection, reply, NULL))
 295           die ("No memory");
 296
 297         return DBUS_HANDLER_RESULT_HANDLED;
 298     }
 299   else
 300     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 301 }
 302
 303 static DBusObjectPathVTable
 304 echo_vtable = {
 305   path_unregistered_func,
 306   path_message_func,
 307   NULL,
 308 };
 309
 310
 311 static const char* echo_path = "/org/freedesktop/TestSuite" ;
 312
 313 static DBusHandlerResult
 314 filter_func (DBusConnection     *connection,
 315              DBusMessage        *message,
 316              void               *user_data)
 317 {
 318   if (dbus_message_is_signal (message,
 319                               DBUS_INTERFACE_LOCAL,
 320                               "Disconnected"))
 321     {
 322       quit ();
 323       return DBUS_HANDLER_RESULT_HANDLED;
 324     }
 325   else
 326     {
 327       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 328     }
 329 }
 330
 331 int
 332 main (int    argc,
 333       char **argv)
 334 {
 335   DBusError error;
 336   int result;
 337   DBusConnection *connection;
 338
 339   dbus_error_init (&error);
 340   connection = dbus_bus_get (DBUS_BUS_STARTER, &error);
 341   if (connection == NULL)
 342     {
 343       fprintf (stderr, "*** Failed to open connection to activating message bus: %s\n",
 344                error.message);
 345       dbus_error_free (&error);
 346       return 1;
 347     }
 348
 349   loop = _dbus_loop_new ();
 350   if (loop == NULL)
 351     die ("No memory\n");
 352
 353   if (!test_connection_setup (loop, connection))
 354     die ("No memory\n");
 355
 356   if (!dbus_connection_add_filter (connection,
 357                                    filter_func, NULL, NULL))
 358     die ("No memory");
 359
 360   if (!dbus_connection_register_object_path (connection,
 361                                              echo_path,
 362                                              &echo_vtable,
 363                                              (void*) 0xdeadbeef))
 364     die ("No memory");
 365
 366   {
 367     void *d;
 368     if (!dbus_connection_get_object_path_data (connection, echo_path, &d))
 369       die ("No memory");
 370     if (d != (void*) 0xdeadbeef)
 371       die ("dbus_connection_get_object_path_data() doesn't seem to work right\n");
 372   }
 373
 374   result = dbus_bus_request_name (connection, "org.freedesktop.DBus.TestSuiteEchoService",
 375                                   0, &error);
 376   if (dbus_error_is_set (&error))
 377     {
 378       fprintf (stderr, "Error %s\n", error.message);
 379       _dbus_verbose ("*** Failed to acquire service: %s\n",
 380                      error.message);
 381       dbus_error_free (&error);
 382       exit (1);
 383     }
 384
 385   _dbus_verbose ("*** Test service entering main loop\n");
 386   _dbus_loop_run (loop);
 387
 388   test_connection_shutdown (loop, connection);
 389
 390   dbus_connection_remove_filter (connection, filter_func, NULL);
 391
 392   dbus_connection_unref (connection);
 393
 394   _dbus_loop_unref (loop);
 395   loop = NULL;
 396
 397   dbus_shutdown ();
 398
 399   _dbus_verbose ("*** Test service exiting\n");
 400
 401   return 0;
 402 }