gio/tests/gdbus-peer.c

   1 /* GLib testing framework examples and tests
   2  *
   3  * Copyright (C) 2008-2010 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, see <http://www.gnu.org/licenses/>.
  17  *
  18  * Author: David Zeuthen <davidz@redhat.com>
  19  */
  20
  21 #include "config.h"
  22
  23 #include <gio/gio.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26
  27 /* for open(2) */
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <fcntl.h>
  31 #include <string.h>
  32
  33 /* for g_unlink() */
  34 #include <glib/gstdio.h>
  35
  36 #include <gio/gnetworking.h>
  37 #include <gio/gunixsocketaddress.h>
  38 #include <gio/gunixfdlist.h>
  39 #include <gio/gcredentialsprivate.h>
  40
  41 #ifdef G_OS_UNIX
  42 #include <gio/gunixconnection.h>
  43 #include <errno.h>
  44 #endif
  45
  46 #include "gdbus-tests.h"
  47
  48 #include "gdbus-object-manager-example/gdbus-example-objectmanager-generated.h"
  49
  50 #ifdef G_OS_UNIX
  51 static gboolean is_unix = TRUE;
  52 #else
  53 static gboolean is_unix = FALSE;
  54 #endif
  55
  56 static gchar *tmp_address = NULL;
  57 static gchar *test_guid = NULL;
  58 static GMutex service_loop_lock;
  59 static GCond service_loop_cond;
  60 static GMainLoop *service_loop = NULL;
  61 static GDBusServer *server = NULL;
  62 static GMainLoop *loop = NULL;
  63
  64 /* ---------------------------------------------------------------------------------------------------- */
  65 /* Test that peer-to-peer connections work */
  66 /* ---------------------------------------------------------------------------------------------------- */
  67
  68
  69 typedef struct
  70 {
  71   gboolean accept_connection;
  72   gint num_connection_attempts;
  73   GPtrArray *current_connections;
  74   guint num_method_calls;
  75   gboolean signal_received;
  76 } PeerData;
  77
  78 static const gchar *test_interface_introspection_xml =
  79   "<node>"
  80   "  <interface name='org.gtk.GDBus.PeerTestInterface'>"
  81   "    <method name='HelloPeer'>"
  82   "      <arg type='s' name='greeting' direction='in'/>"
  83   "      <arg type='s' name='response' direction='out'/>"
  84   "    </method>"
  85   "    <method name='EmitSignal'/>"
  86   "    <method name='EmitSignalWithNameSet'/>"
  87   "    <method name='OpenFile'>"
  88   "      <arg type='s' name='path' direction='in'/>"
  89   "    </method>"
  90   "    <signal name='PeerSignal'>"
  91   "      <arg type='s' name='a_string'/>"
  92   "    </signal>"
  93   "    <property type='s' name='PeerProperty' access='read'/>"
  94   "  </interface>"
  95   "</node>";
  96 static GDBusInterfaceInfo *test_interface_introspection_data = NULL;
  97
  98 static void
  99 test_interface_method_call (GDBusConnection       *connection,
 100                             const gchar           *sender,
 101                             const gchar           *object_path,
 102                             const gchar           *interface_name,
 103                             const gchar           *method_name,
 104                             GVariant              *parameters,
 105                             GDBusMethodInvocation *invocation,
 106                             gpointer               user_data)
 107 {
 108   PeerData *data = user_data;
 109   const GDBusMethodInfo *info;
 110
 111   data->num_method_calls++;
 112
 113   g_assert_cmpstr (object_path, ==, "/org/gtk/GDBus/PeerTestObject");
 114   g_assert_cmpstr (interface_name, ==, "org.gtk.GDBus.PeerTestInterface");
 115
 116   info = g_dbus_method_invocation_get_method_info (invocation);
 117   g_assert_cmpstr (info->name, ==, method_name);
 118
 119   if (g_strcmp0 (method_name, "HelloPeer") == 0)
 120     {
 121       const gchar *greeting;
 122       gchar *response;
 123
 124       g_variant_get (parameters, "(&s)", &greeting);
 125
 126       response = g_strdup_printf ("You greeted me with '%s'.",
 127                                   greeting);
 128       g_dbus_method_invocation_return_value (invocation,
 129                                              g_variant_new ("(s)", response));
 130       g_free (response);
 131     }
 132   else if (g_strcmp0 (method_name, "EmitSignal") == 0)
 133     {
 134       GError *error;
 135
 136       error = NULL;
 137       g_dbus_connection_emit_signal (connection,
 138                                      NULL,
 139                                      "/org/gtk/GDBus/PeerTestObject",
 140                                      "org.gtk.GDBus.PeerTestInterface",
 141                                      "PeerSignal",
 142                                      NULL,
 143                                      &error);
 144       g_assert_no_error (error);
 145       g_dbus_method_invocation_return_value (invocation, NULL);
 146     }
 147   else if (g_strcmp0 (method_name, "EmitSignalWithNameSet") == 0)
 148     {
 149       GError *error;
 150       gboolean ret;
 151       GDBusMessage *message;
 152
 153       message = g_dbus_message_new_signal ("/org/gtk/GDBus/PeerTestObject",
 154                                            "org.gtk.GDBus.PeerTestInterface",
 155                                            "PeerSignalWithNameSet");
 156       g_dbus_message_set_sender (message, ":1.42");
 157
 158       error = NULL;
 159       ret = g_dbus_connection_send_message (connection, message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, &error);
 160       g_assert_no_error (error);
 161       g_assert (ret);
 162       g_object_unref (message);
 163
 164       g_dbus_method_invocation_return_value (invocation, NULL);
 165     }
 166   else if (g_strcmp0 (method_name, "OpenFile") == 0)
 167     {
 168 #ifdef G_OS_UNIX
 169       const gchar *path;
 170       GDBusMessage *reply;
 171       GError *error;
 172       gint fd;
 173       GUnixFDList *fd_list;
 174
 175       g_variant_get (parameters, "(&s)", &path);
 176
 177       fd_list = g_unix_fd_list_new ();
 178
 179       error = NULL;
 180
 181       fd = g_open (path, O_RDONLY, 0);
 182       g_assert (fd != -1);
 183       g_unix_fd_list_append (fd_list, fd, &error);
 184       g_assert_no_error (error);
 185       close (fd);
 186
 187       reply = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
 188       g_dbus_message_set_unix_fd_list (reply, fd_list);
 189       g_object_unref (fd_list);
 190       g_object_unref (invocation);
 191
 192       error = NULL;
 193       g_dbus_connection_send_message (connection,
 194                                       reply,
 195                                       G_DBUS_SEND_MESSAGE_FLAGS_NONE,
 196                                       NULL, /* out_serial */
 197                                       &error);
 198       g_assert_no_error (error);
 199       g_object_unref (reply);
 200 #else
 201       g_dbus_method_invocation_return_dbus_error (invocation,
 202                                                   "org.gtk.GDBus.NotOnUnix",
 203                                                   "Your OS does not support file descriptor passing");
 204 #endif
 205     }
 206   else
 207     {
 208       g_assert_not_reached ();
 209     }
 210 }
 211
 212 static GVariant *
 213 test_interface_get_property (GDBusConnection  *connection,
 214                              const gchar      *sender,
 215                              const gchar      *object_path,
 216                              const gchar      *interface_name,
 217                              const gchar      *property_name,
 218                              GError          **error,
 219                              gpointer          user_data)
 220 {
 221   g_assert_cmpstr (object_path, ==, "/org/gtk/GDBus/PeerTestObject");
 222   g_assert_cmpstr (interface_name, ==, "org.gtk.GDBus.PeerTestInterface");
 223   g_assert_cmpstr (property_name, ==, "PeerProperty");
 224
 225   return g_variant_new_string ("ThePropertyValue");
 226 }
 227
 228
 229 static const GDBusInterfaceVTable test_interface_vtable =
 230 {
 231   test_interface_method_call,
 232   test_interface_get_property,
 233   NULL  /* set_property */
 234 };
 235
 236 static void
 237 on_proxy_signal_received (GDBusProxy *proxy,
 238                           gchar      *sender_name,
 239                           gchar      *signal_name,
 240                           GVariant   *parameters,
 241                           gpointer    user_data)
 242 {
 243   PeerData *data = user_data;
 244
 245   data->signal_received = TRUE;
 246
 247   g_assert (sender_name == NULL);
 248   g_assert_cmpstr (signal_name, ==, "PeerSignal");
 249   g_main_loop_quit (loop);
 250 }
 251
 252 static void
 253 on_proxy_signal_received_with_name_set (GDBusProxy *proxy,
 254                                         gchar      *sender_name,
 255                                         gchar      *signal_name,
 256                                         GVariant   *parameters,
 257                                         gpointer    user_data)
 258 {
 259   PeerData *data = user_data;
 260
 261   data->signal_received = TRUE;
 262
 263   g_assert_cmpstr (sender_name, ==, ":1.42");
 264   g_assert_cmpstr (signal_name, ==, "PeerSignalWithNameSet");
 265   g_main_loop_quit (loop);
 266 }
 267
 268 /* ---------------------------------------------------------------------------------------------------- */
 269
 270 static gboolean
 271 on_authorize_authenticated_peer (GDBusAuthObserver *observer,
 272                                  GIOStream         *stream,
 273                                  GCredentials      *credentials,
 274                                  gpointer           user_data)
 275 {
 276   PeerData *data = user_data;
 277   gboolean authorized;
 278
 279   data->num_connection_attempts++;
 280
 281   authorized = TRUE;
 282   if (!data->accept_connection)
 283     {
 284       authorized = FALSE;
 285       g_main_loop_quit (loop);
 286     }
 287
 288   return authorized;
 289 }
 290
 291 /* Runs in thread we created GDBusServer in (since we didn't pass G_DBUS_SERVER_FLAGS_RUN_IN_THREAD) */
 292 static gboolean
 293 on_new_connection (GDBusServer *server,
 294                    GDBusConnection *connection,
 295                    gpointer user_data)
 296 {
 297   PeerData *data = user_data;
 298   GError *error;
 299   guint reg_id;
 300
 301   //g_printerr ("Client connected.\n"
 302   //         "Negotiated capabilities: unix-fd-passing=%d\n",
 303   //         g_dbus_connection_get_capabilities (connection) & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING);
 304
 305   g_ptr_array_add (data->current_connections, g_object_ref (connection));
 306
 307 #if G_CREDENTIALS_SUPPORTED
 308     {
 309       GCredentials *credentials;
 310
 311       credentials = g_dbus_connection_get_peer_credentials (connection);
 312
 313       g_assert (credentials != NULL);
 314       g_assert_cmpuint (g_credentials_get_unix_user (credentials, NULL), ==,
 315                         getuid ());
 316       g_assert_cmpuint (g_credentials_get_unix_pid (credentials, NULL), ==,
 317                         getpid ());
 318     }
 319 #endif
 320
 321   /* export object on the newly established connection */
 322   error = NULL;
 323   reg_id = g_dbus_connection_register_object (connection,
 324                                               "/org/gtk/GDBus/PeerTestObject",
 325                                               test_interface_introspection_data,
 326                                               &test_interface_vtable,
 327                                               data,
 328                                               NULL, /* GDestroyNotify for data */
 329                                               &error);
 330   g_assert_no_error (error);
 331   g_assert (reg_id > 0);
 332
 333   g_main_loop_quit (loop);
 334
 335   return TRUE;
 336 }
 337
 338 /* We don't tell the main thread about the new GDBusServer until it has
 339  * had a chance to start listening. */
 340 static gboolean
 341 idle_in_service_loop (gpointer loop)
 342 {
 343   g_assert (service_loop == NULL);
 344   g_mutex_lock (&service_loop_lock);
 345   service_loop = loop;
 346   g_cond_broadcast (&service_loop_cond);
 347   g_mutex_unlock (&service_loop_lock);
 348
 349   return G_SOURCE_REMOVE;
 350 }
 351
 352 static void
 353 run_service_loop (GMainContext *service_context)
 354 {
 355   GMainLoop *loop;
 356   GSource *source;
 357
 358   g_assert (service_loop == NULL);
 359
 360   loop = g_main_loop_new (service_context, FALSE);
 361   source = g_idle_source_new ();
 362   g_source_set_callback (source, idle_in_service_loop, loop, NULL);
 363   g_source_attach (source, service_context);
 364   g_source_unref (source);
 365   g_main_loop_run (loop);
 366 }
 367
 368 static void
 369 teardown_service_loop (void)
 370 {
 371   g_mutex_lock (&service_loop_lock);
 372   g_clear_pointer (&service_loop, g_main_loop_unref);
 373   g_mutex_unlock (&service_loop_lock);
 374 }
 375
 376 static void
 377 await_service_loop (void)
 378 {
 379   g_mutex_lock (&service_loop_lock);
 380   while (service_loop == NULL)
 381     g_cond_wait (&service_loop_cond, &service_loop_lock);
 382   g_mutex_unlock (&service_loop_lock);
 383 }
 384
 385 static gpointer
 386 service_thread_func (gpointer user_data)
 387 {
 388   PeerData *data = user_data;
 389   GMainContext *service_context;
 390   GDBusAuthObserver *observer, *o;
 391   GError *error;
 392   GDBusServerFlags f;
 393   gchar *a, *g;
 394   gboolean b;
 395
 396   service_context = g_main_context_new ();
 397   g_main_context_push_thread_default (service_context);
 398
 399   error = NULL;
 400   observer = g_dbus_auth_observer_new ();
 401   server = g_dbus_server_new_sync (tmp_address,
 402                                    G_DBUS_SERVER_FLAGS_NONE,
 403                                    test_guid,
 404                                    observer,
 405                                    NULL, /* cancellable */
 406                                    &error);
 407   g_assert_no_error (error);
 408
 409   g_signal_connect (server,
 410                     "new-connection",
 411                     G_CALLBACK (on_new_connection),
 412                     data);
 413   g_signal_connect (observer,
 414                     "authorize-authenticated-peer",
 415                     G_CALLBACK (on_authorize_authenticated_peer),
 416                     data);
 417
 418   g_assert_cmpint (g_dbus_server_get_flags (server), ==, G_DBUS_SERVER_FLAGS_NONE);
 419   g_assert_cmpstr (g_dbus_server_get_guid (server), ==, test_guid);
 420   g_object_get (server,
 421                 "flags", &f,
 422                 "address", &a,
 423                 "guid", &g,
 424                 "active", &b,
 425                 "authentication-observer", &o,
 426                 NULL);
 427   g_assert_cmpint (f, ==, G_DBUS_SERVER_FLAGS_NONE);
 428   g_assert_cmpstr (a, ==, tmp_address);
 429   g_assert_cmpstr (g, ==, test_guid);
 430   g_assert (!b);
 431   g_assert (o == observer);
 432   g_free (a);
 433   g_free (g);
 434   g_object_unref (o);
 435
 436   g_object_unref (observer);
 437
 438   g_dbus_server_start (server);
 439
 440   run_service_loop (service_context);
 441
 442   g_main_context_pop_thread_default (service_context);
 443
 444   teardown_service_loop ();
 445   g_main_context_unref (service_context);
 446
 447   /* test code specifically unrefs the server - see below */
 448   g_assert (server == NULL);
 449
 450   return NULL;
 451 }
 452
 453 #if 0
 454 static gboolean
 455 on_incoming_connection (GSocketService     *service,
 456                         GSocketConnection  *socket_connection,
 457                         GObject            *source_object,
 458                         gpointer           user_data)
 459 {
 460   PeerData *data = user_data;
 461
 462   if (data->accept_connection)
 463     {
 464       GError *error;
 465       guint reg_id;
 466       GDBusConnection *connection;
 467
 468       error = NULL;
 469       connection = g_dbus_connection_new_sync (G_IO_STREAM (socket_connection),
 470                                                test_guid,
 471                                                G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER,
 472                                                NULL, /* cancellable */
 473                                                &error);
 474       g_assert_no_error (error);
 475
 476       g_ptr_array_add (data->current_connections, connection);
 477
 478       /* export object on the newly established connection */
 479       error = NULL;
 480       reg_id = g_dbus_connection_register_object (connection,
 481                                                   "/org/gtk/GDBus/PeerTestObject",
 482                                                   &test_interface_introspection_data,
 483                                                   &test_interface_vtable,
 484                                                   data,
 485                                                   NULL, /* GDestroyNotify for data */
 486                                                   &error);
 487       g_assert_no_error (error);
 488       g_assert (reg_id > 0);
 489
 490     }
 491   else
 492     {
 493       /* don't do anything */
 494     }
 495
 496   data->num_connection_attempts++;
 497
 498   g_main_loop_quit (loop);
 499
 500   /* stops other signal handlers from being invoked */
 501   return TRUE;
 502 }
 503
 504 static gpointer
 505 service_thread_func (gpointer data)
 506 {
 507   GMainContext *service_context;
 508   gchar *socket_path;
 509   GSocketAddress *address;
 510   GError *error;
 511
 512   service_context = g_main_context_new ();
 513   g_main_context_push_thread_default (service_context);
 514
 515   socket_path = g_strdup_printf ("/tmp/gdbus-test-pid-%d", getpid ());
 516   address = g_unix_socket_address_new (socket_path);
 517
 518   service = g_socket_service_new ();
 519   error = NULL;
 520   g_socket_listener_add_address (G_SOCKET_LISTENER (service),
 521                                  address,
 522                                  G_SOCKET_TYPE_STREAM,
 523                                  G_SOCKET_PROTOCOL_DEFAULT,
 524                                  NULL, /* source_object */
 525                                  NULL, /* effective_address */
 526                                  &error);
 527   g_assert_no_error (error);
 528   g_signal_connect (service,
 529                     "incoming",
 530                     G_CALLBACK (on_incoming_connection),
 531                     data);
 532   g_socket_service_start (service);
 533
 534   run_service_loop (service_context);
 535
 536   g_main_context_pop_thread_default (service_context);
 537
 538   teardown_service_loop ();
 539   g_main_context_unref (service_context);
 540
 541   g_object_unref (address);
 542   g_free (socket_path);
 543   return NULL;
 544 }
 545 #endif
 546
 547 /* ---------------------------------------------------------------------------------------------------- */
 548
 549 #if 0
 550 static gboolean
 551 check_connection (gpointer user_data)
 552 {
 553   PeerData *data = user_data;
 554   guint n;
 555
 556   for (n = 0; n < data->current_connections->len; n++)
 557     {
 558       GDBusConnection *c;
 559       GIOStream *stream;
 560
 561       c = G_DBUS_CONNECTION (data->current_connections->pdata[n]);
 562       stream = g_dbus_connection_get_stream (c);
 563
 564       g_debug ("In check_connection for %d: connection %p, stream %p", n, c, stream);
 565       g_debug ("closed = %d", g_io_stream_is_closed (stream));
 566
 567       GSocket *socket;
 568       socket = g_socket_connection_get_socket (G_SOCKET_CONNECTION (stream));
 569       g_debug ("socket_closed = %d", g_socket_is_closed (socket));
 570       g_debug ("socket_condition_check = %d", g_socket_condition_check (socket, G_IO_IN|G_IO_OUT|G_IO_ERR|G_IO_HUP));
 571
 572       gchar buf[128];
 573       GError *error;
 574       gssize num_read;
 575       error = NULL;
 576       num_read = g_input_stream_read (g_io_stream_get_input_stream (stream),
 577                                       buf,
 578                                       128,
 579                                       NULL,
 580                                       &error);
 581       if (num_read < 0)
 582         {
 583           g_debug ("error: %s", error->message);
 584           g_error_free (error);
 585         }
 586       else
 587         {
 588           g_debug ("no error, read %d bytes", (gint) num_read);
 589         }
 590     }
 591
 592   return FALSE;
 593 }
 594
 595 static gboolean
 596 on_do_disconnect_in_idle (gpointer data)
 597 {
 598   GDBusConnection *c = G_DBUS_CONNECTION (data);
 599   g_debug ("GDC %p has ref_count %d", c, G_OBJECT (c)->ref_count);
 600   g_dbus_connection_disconnect (c);
 601   g_object_unref (c);
 602   return FALSE;
 603 }
 604 #endif
 605
 606 #ifdef G_OS_UNIX
 607 static gchar *
 608 read_all_from_fd (gint fd, gsize *out_len, GError **error)
 609 {
 610   GString *str;
 611   gchar buf[64];
 612   gssize num_read;
 613
 614   str = g_string_new (NULL);
 615
 616   do
 617     {
 618       num_read = read (fd, buf, sizeof (buf));
 619       if (num_read == -1)
 620         {
 621           if (errno == EAGAIN || errno == EWOULDBLOCK)
 622             continue;
 623           g_set_error (error,
 624                        G_IO_ERROR,
 625                        g_io_error_from_errno (errno),
 626                        "Failed reading %d bytes into offset %d: %s",
 627                        (gint) sizeof (buf),
 628                        (gint) str->len,
 629                        strerror (errno));
 630           goto error;
 631         }
 632       else if (num_read > 0)
 633         {
 634           g_string_append_len (str, buf, num_read);
 635         }
 636       else if (num_read == 0)
 637         {
 638           break;
 639         }
 640     }
 641   while (TRUE);
 642
 643   if (out_len != NULL)
 644     *out_len = str->len;
 645   return g_string_free (str, FALSE);
 646
 647  error:
 648   if (out_len != NULL)
 649     *out_len = 0;
 650   g_string_free (str, TRUE);
 651   return NULL;
 652 }
 653 #endif
 654
 655 static void
 656 test_peer (void)
 657 {
 658   GDBusConnection *c;
 659   GDBusConnection *c2;
 660   GDBusProxy *proxy;
 661   GError *error;
 662   PeerData data;
 663   GVariant *value;
 664   GVariant *result;
 665   const gchar *s;
 666   GThread *service_thread;
 667   gulong signal_handler_id;
 668
 669   memset (&data, '\0', sizeof (PeerData));
 670   data.current_connections = g_ptr_array_new_with_free_func (g_object_unref);
 671
 672   /* first try to connect when there is no server */
 673   error = NULL;
 674   c = g_dbus_connection_new_for_address_sync (is_unix ? "unix:path=/tmp/gdbus-test-does-not-exist-pid" :
 675                                               /* NOTE: Even if something is listening on port 12345 the connection
 676                                                * will fail because the nonce file doesn't exist */
 677                                               "nonce-tcp:host=localhost,port=12345,noncefile=this-does-not-exist-gdbus",
 678                                               G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
 679                                               NULL, /* GDBusAuthObserver */
 680                                               NULL, /* cancellable */
 681                                               &error);
 682   _g_assert_error_domain (error, G_IO_ERROR);
 683   g_assert (!g_dbus_error_is_remote_error (error));
 684   g_clear_error (&error);
 685   g_assert (c == NULL);
 686
 687   /* bring up a server - we run the server in a different thread to avoid deadlocks */
 688   service_thread = g_thread_new ("test_peer",
 689                                  service_thread_func,
 690                                  &data);
 691   await_service_loop ();
 692   g_assert (server != NULL);
 693
 694   /* bring up a connection and accept it */
 695   data.accept_connection = TRUE;
 696   error = NULL;
 697   c = g_dbus_connection_new_for_address_sync (g_dbus_server_get_client_address (server),
 698                                               G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
 699                                               NULL, /* GDBusAuthObserver */
 700                                               NULL, /* cancellable */
 701                                               &error);
 702   g_assert_no_error (error);
 703   g_assert (c != NULL);
 704   while (data.current_connections->len < 1)
 705     g_main_loop_run (loop);
 706   g_assert_cmpint (data.current_connections->len, ==, 1);
 707   g_assert_cmpint (data.num_connection_attempts, ==, 1);
 708   g_assert (g_dbus_connection_get_unique_name (c) == NULL);
 709   g_assert_cmpstr (g_dbus_connection_get_guid (c), ==, test_guid);
 710
 711   /* check that we create a proxy, read properties, receive signals and invoke
 712    * the HelloPeer() method. Since the server runs in another thread it's fine
 713    * to use synchronous blocking API here.
 714    */
 715   error = NULL;
 716   proxy = g_dbus_proxy_new_sync (c,
 717                                  G_DBUS_PROXY_FLAGS_NONE,
 718                                  NULL,
 719                                  NULL, /* bus_name */
 720                                  "/org/gtk/GDBus/PeerTestObject",
 721                                  "org.gtk.GDBus.PeerTestInterface",
 722                                  NULL, /* GCancellable */
 723                                  &error);
 724   g_assert_no_error (error);
 725   g_assert (proxy != NULL);
 726   error = NULL;
 727   value = g_dbus_proxy_get_cached_property (proxy, "PeerProperty");
 728   g_assert_cmpstr (g_variant_get_string (value, NULL), ==, "ThePropertyValue");
 729
 730   /* try invoking a method */
 731   error = NULL;
 732   result = g_dbus_proxy_call_sync (proxy,
 733                                    "HelloPeer",
 734                                    g_variant_new ("(s)", "Hey Peer!"),
 735                                    G_DBUS_CALL_FLAGS_NONE,
 736                                    -1,
 737                                    NULL,  /* GCancellable */
 738                                    &error);
 739   g_assert_no_error (error);
 740   g_variant_get (result, "(&s)", &s);
 741   g_assert_cmpstr (s, ==, "You greeted me with 'Hey Peer!'.");
 742   g_variant_unref (result);
 743   g_assert_cmpint (data.num_method_calls, ==, 1);
 744
 745   /* make the other peer emit a signal - catch it */
 746   signal_handler_id = g_signal_connect (proxy,
 747                                         "g-signal",
 748                                         G_CALLBACK (on_proxy_signal_received),
 749                                         &data);
 750   g_assert (!data.signal_received);
 751   g_dbus_proxy_call (proxy,
 752                      "EmitSignal",
 753                      NULL,  /* no arguments */
 754                      G_DBUS_CALL_FLAGS_NONE,
 755                      -1,
 756                      NULL,  /* GCancellable */
 757                      NULL,  /* GAsyncReadyCallback - we don't care about the result */
 758                      NULL); /* user_data */
 759   g_main_loop_run (loop);
 760   g_assert (data.signal_received);
 761   g_assert_cmpint (data.num_method_calls, ==, 2);
 762   g_signal_handler_disconnect (proxy, signal_handler_id);
 763
 764   /* Also ensure that messages with the sender header-field set gets
 765    * delivered to the proxy - note that this doesn't really make sense
 766    * e.g. names are meaning-less in a peer-to-peer case... but we
 767    * support it because it makes sense in certain bridging
 768    * applications - see e.g. #623815.
 769    */
 770   signal_handler_id = g_signal_connect (proxy,
 771                                         "g-signal",
 772                                         G_CALLBACK (on_proxy_signal_received_with_name_set),
 773                                         &data);
 774   data.signal_received = FALSE;
 775   g_dbus_proxy_call (proxy,
 776                      "EmitSignalWithNameSet",
 777                      NULL,  /* no arguments */
 778                      G_DBUS_CALL_FLAGS_NONE,
 779                      -1,
 780                      NULL,  /* GCancellable */
 781                      NULL,  /* GAsyncReadyCallback - we don't care about the result */
 782                      NULL); /* user_data */
 783   g_main_loop_run (loop);
 784   g_assert (data.signal_received);
 785   g_assert_cmpint (data.num_method_calls, ==, 3);
 786   g_signal_handler_disconnect (proxy, signal_handler_id);
 787
 788   /* check for UNIX fd passing */
 789 #ifdef G_OS_UNIX
 790   {
 791     GDBusMessage *method_call_message;
 792     GDBusMessage *method_reply_message;
 793     GUnixFDList *fd_list;
 794     gint fd;
 795     gchar *buf;
 796     gsize len;
 797     gchar *buf2;
 798     gsize len2;
 799     const char *testfile = g_test_get_filename (G_TEST_DIST, "file.c", NULL);
 800
 801     method_call_message = g_dbus_message_new_method_call (NULL, /* name */
 802                                                           "/org/gtk/GDBus/PeerTestObject",
 803                                                           "org.gtk.GDBus.PeerTestInterface",
 804                                                           "OpenFile");
 805     g_dbus_message_set_body (method_call_message, g_variant_new ("(s)", testfile));
 806     error = NULL;
 807     method_reply_message = g_dbus_connection_send_message_with_reply_sync (c,
 808                                                                            method_call_message,
 809                                                                            G_DBUS_SEND_MESSAGE_FLAGS_NONE,
 810                                                                            -1,
 811                                                                            NULL, /* out_serial */
 812                                                                            NULL, /* cancellable */
 813                                                                            &error);
 814     g_assert_no_error (error);
 815     g_assert (g_dbus_message_get_message_type (method_reply_message) == G_DBUS_MESSAGE_TYPE_METHOD_RETURN);
 816     fd_list = g_dbus_message_get_unix_fd_list (method_reply_message);
 817     g_assert (fd_list != NULL);
 818     g_assert_cmpint (g_unix_fd_list_get_length (fd_list), ==, 1);
 819     error = NULL;
 820     fd = g_unix_fd_list_get (fd_list, 0, &error);
 821     g_assert_no_error (error);
 822     g_object_unref (method_call_message);
 823     g_object_unref (method_reply_message);
 824
 825     error = NULL;
 826     len = 0;
 827     buf = read_all_from_fd (fd, &len, &error);
 828     g_assert_no_error (error);
 829     g_assert (buf != NULL);
 830     close (fd);
 831
 832     error = NULL;
 833     g_file_get_contents (testfile,
 834                          &buf2,
 835                          &len2,
 836                          &error);
 837     g_assert_no_error (error);
 838     g_assert_cmpmem (buf, len, buf2, len2);
 839     g_free (buf2);
 840     g_free (buf);
 841   }
 842 #else
 843   error = NULL;
 844   result = g_dbus_proxy_call_sync (proxy,
 845                                    "OpenFile",
 846                                    g_variant_new ("(s)", "boo"),
 847                                    G_DBUS_CALL_FLAGS_NONE,
 848                                    -1,
 849                                    NULL,  /* GCancellable */
 850                                    &error);
 851   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_DBUS_ERROR);
 852   g_assert (result == NULL);
 853   g_error_free (error);
 854 #endif /* G_OS_UNIX */
 855
 856   /* Check that g_socket_get_credentials() work - (though this really
 857    * should be in socket.c)
 858    */
 859   {
 860     GSocket *socket;
 861     GCredentials *credentials;
 862     socket = g_socket_connection_get_socket (G_SOCKET_CONNECTION (g_dbus_connection_get_stream (c)));
 863     g_assert (G_IS_SOCKET (socket));
 864     error = NULL;
 865     credentials = g_socket_get_credentials (socket, &error);
 866
 867 #if G_CREDENTIALS_SOCKET_GET_CREDENTIALS_SUPPORTED
 868     g_assert_no_error (error);
 869     g_assert (G_IS_CREDENTIALS (credentials));
 870
 871     g_assert_cmpuint (g_credentials_get_unix_user (credentials, NULL), ==,
 872                       getuid ());
 873     g_assert_cmpuint (g_credentials_get_unix_pid (credentials, NULL), ==,
 874                       getpid ());
 875 #else
 876     g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
 877     g_assert (credentials == NULL);
 878 #endif
 879   }
 880
 881
 882   /* bring up a connection - don't accept it - this should fail
 883    */
 884   data.accept_connection = FALSE;
 885   error = NULL;
 886   c2 = g_dbus_connection_new_for_address_sync (g_dbus_server_get_client_address (server),
 887                                                G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
 888                                                NULL, /* GDBusAuthObserver */
 889                                                NULL, /* cancellable */
 890                                                &error);
 891   _g_assert_error_domain (error, G_IO_ERROR);
 892   g_error_free (error);
 893   g_assert (c2 == NULL);
 894
 895 #if 0
 896   /* TODO: THIS TEST DOESN'T WORK YET */
 897
 898   /* bring up a connection - accept it.. then disconnect from the client side - check
 899    * that the server side gets the disconnect signal.
 900    */
 901   error = NULL;
 902   data.accept_connection = TRUE;
 903   c2 = g_dbus_connection_new_for_address_sync (g_dbus_server_get_client_address (server),
 904                                                G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
 905                                                NULL, /* GDBusAuthObserver */
 906                                                NULL, /* cancellable */
 907                                                &error);
 908   g_assert_no_error (error);
 909   g_assert (c2 != NULL);
 910   g_assert (!g_dbus_connection_get_is_disconnected (c2));
 911   while (data.num_connection_attempts < 3)
 912     g_main_loop_run (loop);
 913   g_assert_cmpint (data.current_connections->len, ==, 2);
 914   g_assert_cmpint (data.num_connection_attempts, ==, 3);
 915   g_assert (!g_dbus_connection_get_is_disconnected (G_DBUS_CONNECTION (data.current_connections->pdata[1])));
 916   g_idle_add (on_do_disconnect_in_idle, c2);
 917   g_debug ("==================================================");
 918   g_debug ("==================================================");
 919   g_debug ("==================================================");
 920   g_debug ("waiting for disconnect on connection %p, stream %p",
 921            data.current_connections->pdata[1],
 922            g_dbus_connection_get_stream (data.current_connections->pdata[1]));
 923
 924   g_timeout_add (2000, check_connection, &data);
 925   //_g_assert_signal_received (G_DBUS_CONNECTION (data.current_connections->pdata[1]), "closed");
 926   g_main_loop_run (loop);
 927   g_assert (g_dbus_connection_get_is_disconnected (G_DBUS_CONNECTION (data.current_connections->pdata[1])));
 928   g_ptr_array_set_size (data.current_connections, 1); /* remove disconnected connection object */
 929 #endif
 930
 931   /* unref the server and stop listening for new connections
 932    *
 933    * This won't bring down the established connections - check that c is still connected
 934    * by invoking a method
 935    */
 936   //g_socket_service_stop (service);
 937   //g_object_unref (service);
 938   g_dbus_server_stop (server);
 939   g_object_unref (server);
 940   server = NULL;
 941
 942   error = NULL;
 943   result = g_dbus_proxy_call_sync (proxy,
 944                                    "HelloPeer",
 945                                    g_variant_new ("(s)", "Hey Again Peer!"),
 946                                    G_DBUS_CALL_FLAGS_NONE,
 947                                    -1,
 948                                    NULL,  /* GCancellable */
 949                                    &error);
 950   g_assert_no_error (error);
 951   g_variant_get (result, "(&s)", &s);
 952   g_assert_cmpstr (s, ==, "You greeted me with 'Hey Again Peer!'.");
 953   g_variant_unref (result);
 954   g_assert_cmpint (data.num_method_calls, ==, 5);
 955
 956 #if 0
 957   /* TODO: THIS TEST DOESN'T WORK YET */
 958
 959   /* now disconnect from the server side - check that the client side gets the signal */
 960   g_assert_cmpint (data.current_connections->len, ==, 1);
 961   g_assert (G_DBUS_CONNECTION (data.current_connections->pdata[0]) != c);
 962   g_dbus_connection_disconnect (G_DBUS_CONNECTION (data.current_connections->pdata[0]));
 963   if (!g_dbus_connection_get_is_disconnected (c))
 964     _g_assert_signal_received (c, "closed");
 965   g_assert (g_dbus_connection_get_is_disconnected (c));
 966 #endif
 967
 968   g_object_unref (c);
 969   g_ptr_array_unref (data.current_connections);
 970   g_object_unref (proxy);
 971
 972   g_main_loop_quit (service_loop);
 973   g_thread_join (service_thread);
 974 }
 975
 976 /* ---------------------------------------------------------------------------------------------------- */
 977
 978 typedef struct
 979 {
 980   GDBusServer *server;
 981   GMainContext *context;
 982   GMainLoop *loop;
 983
 984   GList *connections;
 985 } DmpData;
 986
 987 static void
 988 dmp_data_free (DmpData *data)
 989 {
 990   g_main_loop_unref (data->loop);
 991   g_main_context_unref (data->context);
 992   g_object_unref (data->server);
 993   g_list_free_full (data->connections, g_object_unref);
 994   g_free (data);
 995 }
 996
 997 static void
 998 dmp_on_method_call (GDBusConnection       *connection,
 999                     const gchar           *sender,
1000                     const gchar           *object_path,
1001                     const gchar           *interface_name,
1002                     const gchar           *method_name,
1003                     GVariant              *parameters,
1004                     GDBusMethodInvocation *invocation,
1005                     gpointer               user_data)
1006 {
1007   //DmpData *data = user_data;
1008   gint32 first;
1009   gint32 second;
1010   g_variant_get (parameters,
1011                  "(ii)",
1012                  &first,
1013                  &second);
1014   g_dbus_method_invocation_return_value (invocation,
1015                                          g_variant_new ("(i)", first + second));
1016 }
1017
1018 static const GDBusInterfaceVTable dmp_interface_vtable =
1019 {
1020   dmp_on_method_call,
1021   NULL,  /* get_property */
1022   NULL   /* set_property */
1023 };
1024
1025
1026 /* Runs in thread we created GDBusServer in (since we didn't pass G_DBUS_SERVER_FLAGS_RUN_IN_THREAD) */
1027 static gboolean
1028 dmp_on_new_connection (GDBusServer     *server,
1029                        GDBusConnection *connection,
1030                        gpointer         user_data)
1031 {
1032   DmpData *data = user_data;
1033   GDBusNodeInfo *node;
1034   GError *error;
1035
1036   /* accept the connection */
1037   data->connections = g_list_prepend (data->connections, g_object_ref (connection));
1038
1039   error = NULL;
1040   node = g_dbus_node_info_new_for_xml ("<node>"
1041                                        "  <interface name='org.gtk.GDBus.DmpInterface'>"
1042                                        "    <method name='AddPair'>"
1043                                        "      <arg type='i' name='first' direction='in'/>"
1044                                        "      <arg type='i' name='second' direction='in'/>"
1045                                        "      <arg type='i' name='sum' direction='out'/>"
1046                                        "    </method>"
1047                                        "  </interface>"
1048                                        "</node>",
1049                                        &error);
1050   g_assert_no_error (error);
1051
1052   /* sleep 100ms before exporting an object - this is to test that
1053    * G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING really works
1054    * (GDBusServer uses this feature).
1055    */
1056   usleep (100 * 1000);
1057
1058   /* export an object */
1059   error = NULL;
1060   g_dbus_connection_register_object (connection,
1061                                      "/dmp/test",
1062                                      node->interfaces[0],
1063                                      &dmp_interface_vtable,
1064                                      data,
1065                                      NULL,
1066                                      &error);
1067   g_dbus_node_info_unref (node);
1068
1069   return TRUE;
1070 }
1071
1072 static gpointer
1073 dmp_thread_func (gpointer user_data)
1074 {
1075   DmpData *data = user_data;
1076   GError *error;
1077   gchar *guid;
1078
1079   data->context = g_main_context_new ();
1080   g_main_context_push_thread_default (data->context);
1081
1082   error = NULL;
1083   guid = g_dbus_generate_guid ();
1084   data->server = g_dbus_server_new_sync (tmp_address,
1085                                          G_DBUS_SERVER_FLAGS_NONE,
1086                                          guid,
1087                                          NULL, /* GDBusAuthObserver */
1088                                          NULL, /* GCancellable */
1089                                          &error);
1090   g_assert_no_error (error);
1091   g_signal_connect (data->server,
1092                     "new-connection",
1093                     G_CALLBACK (dmp_on_new_connection),
1094                     data);
1095
1096   g_dbus_server_start (data->server);
1097
1098   data->loop = g_main_loop_new (data->context, FALSE);
1099   g_main_loop_run (data->loop);
1100
1101   g_main_context_pop_thread_default (data->context);
1102
1103   g_free (guid);
1104   return NULL;
1105 }
1106
1107 static void
1108 delayed_message_processing (void)
1109 {
1110   GError *error;
1111   DmpData *data;
1112   GThread *service_thread;
1113   guint n;
1114
1115   data = g_new0 (DmpData, 1);
1116
1117   service_thread = g_thread_new ("dmp",
1118                                  dmp_thread_func,
1119                                  data);
1120   while (data->server == NULL || !g_dbus_server_is_active (data->server))
1121     g_thread_yield ();
1122
1123   for (n = 0; n < 5; n++)
1124     {
1125       GDBusConnection *c;
1126       GVariant *res;
1127       gint32 val;
1128
1129       error = NULL;
1130       c = g_dbus_connection_new_for_address_sync (g_dbus_server_get_client_address (data->server),
1131                                                   G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
1132                                                   NULL, /* GDBusAuthObserver */
1133                                                   NULL, /* GCancellable */
1134                                                   &error);
1135       g_assert_no_error (error);
1136
1137       error = NULL;
1138       res = g_dbus_connection_call_sync (c,
1139                                          NULL,    /* bus name */
1140                                          "/dmp/test",
1141                                          "org.gtk.GDBus.DmpInterface",
1142                                          "AddPair",
1143                                          g_variant_new ("(ii)", 2, n),
1144                                          G_VARIANT_TYPE ("(i)"),
1145                                          G_DBUS_CALL_FLAGS_NONE,
1146                                          -1, /* timeout_msec */
1147                                          NULL, /* GCancellable */
1148                                          &error);
1149       g_assert_no_error (error);
1150       g_variant_get (res, "(i)", &val);
1151       g_assert_cmpint (val, ==, 2 + n);
1152       g_variant_unref (res);
1153       g_object_unref (c);
1154   }
1155
1156   g_main_loop_quit (data->loop);
1157   g_thread_join (service_thread);
1158   dmp_data_free (data);
1159 }
1160
1161 /* ---------------------------------------------------------------------------------------------------- */
1162
1163 static gboolean
1164 nonce_tcp_on_authorize_authenticated_peer (GDBusAuthObserver *observer,
1165                                            GIOStream         *stream,
1166                                            GCredentials      *credentials,
1167                                            gpointer           user_data)
1168 {
1169   PeerData *data = user_data;
1170   gboolean authorized;
1171
1172   data->num_connection_attempts++;
1173
1174   authorized = TRUE;
1175   if (!data->accept_connection)
1176     {
1177       authorized = FALSE;
1178       g_main_loop_quit (loop);
1179     }
1180
1181   return authorized;
1182 }
1183
1184 /* Runs in thread we created GDBusServer in (since we didn't pass G_DBUS_SERVER_FLAGS_RUN_IN_THREAD) */
1185 static gboolean
1186 nonce_tcp_on_new_connection (GDBusServer *server,
1187                              GDBusConnection *connection,
1188                              gpointer user_data)
1189 {
1190   PeerData *data = user_data;
1191
1192   g_ptr_array_add (data->current_connections, g_object_ref (connection));
1193
1194   g_main_loop_quit (loop);
1195
1196   return TRUE;
1197 }
1198
1199 static gpointer
1200 nonce_tcp_service_thread_func (gpointer user_data)
1201 {
1202   PeerData *data = user_data;
1203   GMainContext *service_context;
1204   GDBusAuthObserver *observer;
1205   GError *error;
1206
1207   service_context = g_main_context_new ();
1208   g_main_context_push_thread_default (service_context);
1209
1210   error = NULL;
1211   observer = g_dbus_auth_observer_new ();
1212   server = g_dbus_server_new_sync ("nonce-tcp:",
1213                                    G_DBUS_SERVER_FLAGS_NONE,
1214                                    test_guid,
1215                                    observer,
1216                                    NULL, /* cancellable */
1217                                    &error);
1218   g_assert_no_error (error);
1219
1220   g_signal_connect (server,
1221                     "new-connection",
1222                     G_CALLBACK (nonce_tcp_on_new_connection),
1223                     data);
1224   g_signal_connect (observer,
1225                     "authorize-authenticated-peer",
1226                     G_CALLBACK (nonce_tcp_on_authorize_authenticated_peer),
1227                     data);
1228   g_object_unref (observer);
1229
1230   g_dbus_server_start (server);
1231
1232   run_service_loop (service_context);
1233
1234   g_main_context_pop_thread_default (service_context);
1235
1236   teardown_service_loop ();
1237   g_main_context_unref (service_context);
1238
1239   /* test code specifically unrefs the server - see below */
1240   g_assert (server == NULL);
1241
1242   return NULL;
1243 }
1244
1245 static void
1246 test_nonce_tcp (void)
1247 {
1248   PeerData data;
1249   GError *error;
1250   GThread *service_thread;
1251   GDBusConnection *c;
1252   gchar *s;
1253   gchar *nonce_file;
1254   gboolean res;
1255   const gchar *address;
1256
1257   memset (&data, '\0', sizeof (PeerData));
1258   data.current_connections = g_ptr_array_new_with_free_func (g_object_unref);
1259
1260   error = NULL;
1261   server = NULL;
1262   service_thread = g_thread_new ("nonce-tcp-service",
1263                                  nonce_tcp_service_thread_func,
1264                                  &data);
1265   await_service_loop ();
1266   g_assert (server != NULL);
1267
1268   /* bring up a connection and accept it */
1269   data.accept_connection = TRUE;
1270   error = NULL;
1271   c = g_dbus_connection_new_for_address_sync (g_dbus_server_get_client_address (server),
1272                                               G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
1273                                               NULL, /* GDBusAuthObserver */
1274                                               NULL, /* cancellable */
1275                                               &error);
1276   g_assert_no_error (error);
1277   g_assert (c != NULL);
1278   while (data.current_connections->len < 1)
1279     g_thread_yield ();
1280   g_assert_cmpint (data.current_connections->len, ==, 1);
1281   g_assert_cmpint (data.num_connection_attempts, ==, 1);
1282   g_assert (g_dbus_connection_get_unique_name (c) == NULL);
1283   g_assert_cmpstr (g_dbus_connection_get_guid (c), ==, test_guid);
1284   g_object_unref (c);
1285
1286   /* now, try to subvert the nonce file (this assumes noncefile is the last key/value pair)
1287    */
1288
1289   address = g_dbus_server_get_client_address (server);
1290
1291   s = strstr (address, "noncefile=");
1292   g_assert (s != NULL);
1293   s += sizeof "noncefile=" - 1;
1294   nonce_file = g_strdup (s);
1295
1296   /* First try invalid data in the nonce file - this will actually
1297    * make the client send this and the server will reject it. The way
1298    * it works is that if the nonce doesn't match, the server will
1299    * simply close the connection. So, from the client point of view,
1300    * we can see a variety of errors.
1301    */
1302   error = NULL;
1303   res = g_file_set_contents (nonce_file,
1304                              "0123456789012345",
1305                              -1,
1306                              &error);
1307   g_assert_no_error (error);
1308   g_assert (res);
1309   c = g_dbus_connection_new_for_address_sync (address,
1310                                               G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
1311                                               NULL, /* GDBusAuthObserver */
1312                                               NULL, /* cancellable */
1313                                               &error);
1314   _g_assert_error_domain (error, G_IO_ERROR);
1315   g_error_free (error);
1316   g_assert (c == NULL);
1317
1318   /* Then try with a nonce-file of incorrect length - this will make
1319    * the client complain - we won't even try connecting to the server
1320    * for this
1321    */
1322   error = NULL;
1323   res = g_file_set_contents (nonce_file,
1324                              "0123456789012345_",
1325                              -1,
1326                              &error);
1327   g_assert_no_error (error);
1328   g_assert (res);
1329   c = g_dbus_connection_new_for_address_sync (address,
1330                                               G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
1331                                               NULL, /* GDBusAuthObserver */
1332                                               NULL, /* cancellable */
1333                                               &error);
1334   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
1335   g_error_free (error);
1336   g_assert (c == NULL);
1337
1338   /* Finally try with no nonce-file at all */
1339   g_assert_cmpint (g_unlink (nonce_file), ==, 0);
1340   error = NULL;
1341   c = g_dbus_connection_new_for_address_sync (address,
1342                                               G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
1343                                               NULL, /* GDBusAuthObserver */
1344                                               NULL, /* cancellable */
1345                                               &error);
1346   g_assert_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT);
1347   g_error_free (error);
1348   g_assert (c == NULL);
1349
1350   g_free (nonce_file);
1351
1352   g_dbus_server_stop (server);
1353   g_object_unref (server);
1354   server = NULL;
1355
1356   g_main_loop_quit (service_loop);
1357   g_thread_join (service_thread);
1358 }
1359
1360 static void
1361 test_credentials (void)
1362 {
1363   GCredentials *c1, *c2;
1364   GError *error;
1365   gchar *desc;
1366
1367   c1 = g_credentials_new ();
1368   c2 = g_credentials_new ();
1369
1370   error = NULL;
1371   if (g_credentials_set_unix_user (c2, getuid (), &error))
1372     g_assert_no_error (error);
1373
1374   g_clear_error (&error);
1375   g_assert (g_credentials_is_same_user (c1, c2, &error));
1376   g_assert_no_error (error);
1377
1378   desc = g_credentials_to_string (c1);
1379   g_assert (desc != NULL);
1380   g_free (desc);
1381
1382   g_object_unref (c1);
1383   g_object_unref (c2);
1384 }
1385
1386 /* ---------------------------------------------------------------------------------------------------- */
1387
1388 static gboolean
1389 tcp_anonymous_on_new_connection (GDBusServer     *server,
1390                                  GDBusConnection *connection,
1391                                  gpointer         user_data)
1392 {
1393   gboolean *seen_connection = user_data;
1394   *seen_connection = TRUE;
1395   return TRUE;
1396 }
1397
1398 static gpointer
1399 tcp_anonymous_service_thread_func (gpointer user_data)
1400 {
1401   gboolean *seen_connection = user_data;
1402   GMainContext *service_context;
1403   GError *error;
1404
1405   service_context = g_main_context_new ();
1406   g_main_context_push_thread_default (service_context);
1407
1408   error = NULL;
1409   server = g_dbus_server_new_sync ("tcp:",
1410                                    G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS,
1411                                    test_guid,
1412                                    NULL, /* GDBusObserver* */
1413                                    NULL, /* GCancellable* */
1414                                    &error);
1415   g_assert_no_error (error);
1416
1417   g_signal_connect (server,
1418                     "new-connection",
1419                     G_CALLBACK (tcp_anonymous_on_new_connection),
1420                     seen_connection);
1421
1422   g_dbus_server_start (server);
1423
1424   run_service_loop (service_context);
1425
1426   g_main_context_pop_thread_default (service_context);
1427
1428   teardown_service_loop ();
1429   g_main_context_unref (service_context);
1430
1431   return NULL;
1432 }
1433
1434 static void
1435 test_tcp_anonymous (void)
1436 {
1437   gboolean seen_connection;
1438   GThread *service_thread;
1439   GDBusConnection *connection;
1440   GError *error;
1441
1442   seen_connection = FALSE;
1443   service_thread = g_thread_new ("tcp-anon-service",
1444                                  tcp_anonymous_service_thread_func,
1445                                  &seen_connection);
1446   await_service_loop ();
1447   g_assert (server != NULL);
1448
1449   error = NULL;
1450   connection = g_dbus_connection_new_for_address_sync (g_dbus_server_get_client_address (server),
1451                                                        G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
1452                                                        NULL, /* GDBusAuthObserver* */
1453                                                        NULL, /* GCancellable */
1454                                                        &error);
1455   g_assert_no_error (error);
1456   g_assert (connection != NULL);
1457
1458   while (!seen_connection)
1459     g_thread_yield ();
1460
1461   g_object_unref (connection);
1462
1463   g_main_loop_quit (service_loop);
1464   g_dbus_server_stop (server);
1465   g_object_unref (server);
1466   server = NULL;
1467
1468   g_thread_join (service_thread);
1469 }
1470
1471 /* ---------------------------------------------------------------------------------------------------- */
1472
1473 static GDBusServer *codegen_server = NULL;
1474
1475 static gboolean
1476 codegen_on_animal_poke (ExampleAnimal          *animal,
1477                         GDBusMethodInvocation  *invocation,
1478                         gboolean                make_sad,
1479                         gboolean                make_happy,
1480                         gpointer                user_data)
1481 {
1482   if ((make_sad && make_happy) || (!make_sad && !make_happy))
1483     {
1484       g_main_loop_quit (service_loop);
1485
1486       g_dbus_method_invocation_return_dbus_error (invocation,
1487                                                   "org.gtk.GDBus.Examples.ObjectManager.Error.Failed",
1488                                                   "Exactly one of make_sad or make_happy must be TRUE");
1489       goto out;
1490     }
1491
1492   if (make_sad)
1493     {
1494       if (g_strcmp0 (example_animal_get_mood (animal), "Sad") == 0)
1495         {
1496           g_dbus_method_invocation_return_dbus_error (invocation,
1497                                                       "org.gtk.GDBus.Examples.ObjectManager.Error.SadAnimalIsSad",
1498                                                       "Sad animal is already sad");
1499           goto out;
1500         }
1501
1502       example_animal_set_mood (animal, "Sad");
1503       example_animal_complete_poke (animal, invocation);
1504       goto out;
1505     }
1506
1507   if (make_happy)
1508     {
1509       if (g_strcmp0 (example_animal_get_mood (animal), "Happy") == 0)
1510         {
1511           g_dbus_method_invocation_return_dbus_error (invocation,
1512                                                       "org.gtk.GDBus.Examples.ObjectManager.Error.HappyAnimalIsHappy",
1513                                                       "Happy animal is already happy");
1514           goto out;
1515         }
1516
1517       example_animal_set_mood (animal, "Happy");
1518       example_animal_complete_poke (animal, invocation);
1519       goto out;
1520     }
1521
1522   g_assert_not_reached ();
1523
1524  out:
1525   return TRUE; /* to indicate that the method was handled */
1526 }
1527
1528 /* Runs in thread we created GDBusServer in (since we didn't pass G_DBUS_SERVER_FLAGS_RUN_IN_THREAD) */
1529 static gboolean
1530 codegen_on_new_connection (GDBusServer *server,
1531                            GDBusConnection *connection,
1532                            gpointer user_data)
1533 {
1534   ExampleAnimal *animal = user_data;
1535   GError        *error = NULL;
1536
1537   /* g_printerr ("Client connected.\n" */
1538   /*          "Negotiated capabilities: unix-fd-passing=%d\n", */
1539   /*          g_dbus_connection_get_capabilities (connection) & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING); */
1540
1541   g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (animal), connection,
1542                                     "/Example/Animals/000", &error);
1543   g_assert_no_error (error);
1544
1545   return TRUE;
1546 }
1547
1548 static gpointer
1549 codegen_service_thread_func (gpointer user_data)
1550 {
1551   GMainContext   *service_context;
1552   ExampleAnimal  *animal;
1553   GError         *error = NULL;
1554
1555   service_context = g_main_context_new ();
1556   g_main_context_push_thread_default (service_context);
1557
1558   /* Create the animal in the right thread context */
1559   animal = example_animal_skeleton_new ();
1560
1561   /* Handle Poke() D-Bus method invocations on the .Animal interface */
1562   g_signal_connect (animal, "handle-poke",
1563                     G_CALLBACK (codegen_on_animal_poke),
1564                     NULL); /* user_data */
1565
1566   codegen_server = g_dbus_server_new_sync (tmp_address,
1567                                            G_DBUS_SERVER_FLAGS_NONE,
1568                                            test_guid,
1569                                            NULL, /* observer */
1570                                            NULL, /* cancellable */
1571                                            &error);
1572   g_assert_no_error (error);
1573   g_dbus_server_start (codegen_server);
1574
1575   g_signal_connect (codegen_server, "new-connection",
1576                     G_CALLBACK (codegen_on_new_connection),
1577                     animal);
1578
1579   run_service_loop (service_context);
1580
1581   g_object_unref (animal);
1582
1583   g_main_context_pop_thread_default (service_context);
1584
1585   teardown_service_loop ();
1586   g_main_context_unref (service_context);
1587
1588   g_dbus_server_stop (codegen_server);
1589   g_object_unref (codegen_server);
1590   codegen_server = NULL;
1591
1592   return NULL;
1593 }
1594
1595
1596 static gboolean
1597 codegen_quit_mainloop_timeout (gpointer data)
1598 {
1599   g_main_loop_quit (loop);
1600   return FALSE;
1601 }
1602
1603 static void
1604 codegen_test_peer (void)
1605 {
1606   GDBusConnection     *connection;
1607   ExampleAnimal       *animal1, *animal2;
1608   GThread             *service_thread;
1609   GError              *error = NULL;
1610   GVariant            *value;
1611   const gchar         *s;
1612
1613   /* bring up a server - we run the server in a different thread to avoid deadlocks */
1614   service_thread = g_thread_new ("codegen_test_peer",
1615                                  codegen_service_thread_func,
1616                                  NULL);
1617   await_service_loop ();
1618   g_assert (codegen_server != NULL);
1619
1620   /* Get an animal 1 ...  */
1621   connection = g_dbus_connection_new_for_address_sync (g_dbus_server_get_client_address (codegen_server),
1622                                                        G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
1623                                                        NULL, /* GDBusAuthObserver */
1624                                                        NULL, /* cancellable */
1625                                                        &error);
1626   g_assert_no_error (error);
1627   g_assert (connection != NULL);
1628
1629   animal1 = example_animal_proxy_new_sync (connection, 0, NULL,
1630                                            "/Example/Animals/000", NULL, &error);
1631   g_assert_no_error (error);
1632   g_assert (animal1 != NULL);
1633   g_object_unref (connection);
1634
1635   /* Get animal 2 ...  */
1636   connection = g_dbus_connection_new_for_address_sync (g_dbus_server_get_client_address (codegen_server),
1637                                                        G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
1638                                                        NULL, /* GDBusAuthObserver */
1639                                                        NULL, /* cancellable */
1640                                                        &error);
1641   g_assert_no_error (error);
1642   g_assert (connection != NULL);
1643
1644   animal2 = example_animal_proxy_new_sync (connection, 0, NULL,
1645                                            "/Example/Animals/000", NULL, &error);
1646   g_assert_no_error (error);
1647   g_assert (animal2 != NULL);
1648   g_object_unref (connection);
1649
1650   /* Make animal sad via animal1  */
1651   example_animal_call_poke_sync (animal1, TRUE, FALSE, NULL, &error);
1652   g_assert_no_error (error);
1653
1654   /* Poke server and make sure animal is updated */
1655   value = g_dbus_proxy_call_sync (G_DBUS_PROXY (animal1),
1656                                   "org.freedesktop.DBus.Peer.Ping",
1657                                   NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1658                                   NULL, &error);
1659   g_assert_no_error (error);
1660   g_assert (value != NULL);
1661   g_variant_unref (value);
1662
1663   /* Give the proxies a chance to refresh in the defaul main loop */
1664   g_timeout_add (100, codegen_quit_mainloop_timeout, NULL);
1665   g_main_loop_run (loop);
1666
1667   /* Assert animals are sad */
1668   g_assert_cmpstr (example_animal_get_mood (animal1), ==, "Sad");
1669   g_assert_cmpstr (example_animal_get_mood (animal2), ==, "Sad");
1670
1671   /* Make animal happy via animal2  */
1672   example_animal_call_poke_sync (animal2, FALSE, TRUE, NULL, &error);
1673   g_assert_no_error (error);
1674
1675   /* Some random unrelated call, just to get some test coverage */
1676   value = g_dbus_proxy_call_sync (G_DBUS_PROXY (animal2),
1677                                   "org.freedesktop.DBus.Peer.GetMachineId",
1678                                   NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1679                                   NULL, &error);
1680   g_assert_no_error (error);
1681   g_variant_get (value, "(&s)", &s);
1682   g_assert (g_dbus_is_guid (s));
1683   g_variant_unref (value);
1684
1685   /* Poke server and make sure animal is updated */
1686   value = g_dbus_proxy_call_sync (G_DBUS_PROXY (animal2),
1687                                   "org.freedesktop.DBus.Peer.Ping",
1688                                   NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1689                                   NULL, &error);
1690   g_assert_no_error (error);
1691   g_assert (value != NULL);
1692   g_variant_unref (value);
1693
1694   /* Give the proxies a chance to refresh in the defaul main loop */
1695   g_timeout_add (1000, codegen_quit_mainloop_timeout, NULL);
1696   g_main_loop_run (loop);
1697
1698   /* Assert animals are happy */
1699   g_assert_cmpstr (example_animal_get_mood (animal1), ==, "Happy");
1700   g_assert_cmpstr (example_animal_get_mood (animal2), ==, "Happy");
1701
1702   /* This final call making the animal happy and sad will cause
1703    * the server to quit, when the server quits we dont get property
1704    * change notifications anyway because those are done from an idle handler
1705    */
1706   example_animal_call_poke_sync (animal2, TRUE, TRUE, NULL, &error);
1707
1708   g_object_unref (animal1);
1709   g_object_unref (animal2);
1710   g_thread_join (service_thread);
1711 }
1712
1713 /* ---------------------------------------------------------------------------------------------------- */
1714
1715
1716 int
1717 main (int   argc,
1718       char *argv[])
1719 {
1720   gint ret;
1721   GDBusNodeInfo *introspection_data = NULL;
1722   gchar *tmpdir = NULL;
1723
1724   g_test_init (&argc, &argv, NULL);
1725
1726   introspection_data = g_dbus_node_info_new_for_xml (test_interface_introspection_xml, NULL);
1727   g_assert (introspection_data != NULL);
1728   test_interface_introspection_data = introspection_data->interfaces[0];
1729
1730   test_guid = g_dbus_generate_guid ();
1731
1732   if (is_unix)
1733     {
1734       if (g_unix_socket_address_abstract_names_supported ())
1735         tmp_address = g_strdup ("unix:tmpdir=/tmp/gdbus-test-");
1736       else
1737         {
1738           tmpdir = g_dir_make_tmp ("gdbus-test-XXXXXX", NULL);
1739           tmp_address = g_strdup_printf ("unix:tmpdir=%s", tmpdir);
1740         }
1741     }
1742   else
1743     tmp_address = g_strdup ("nonce-tcp:");
1744
1745   /* all the tests rely on a shared main loop */
1746   loop = g_main_loop_new (NULL, FALSE);
1747
1748   g_test_add_func ("/gdbus/peer-to-peer", test_peer);
1749   g_test_add_func ("/gdbus/delayed-message-processing", delayed_message_processing);
1750   g_test_add_func ("/gdbus/nonce-tcp", test_nonce_tcp);
1751
1752   g_test_add_func ("/gdbus/tcp-anonymous", test_tcp_anonymous);
1753   g_test_add_func ("/gdbus/credentials", test_credentials);
1754   g_test_add_func ("/gdbus/codegen-peer-to-peer", codegen_test_peer);
1755
1756   ret = g_test_run();
1757
1758   g_main_loop_unref (loop);
1759   g_free (test_guid);
1760   g_dbus_node_info_unref (introspection_data);
1761   if (is_unix)
1762     g_free (tmp_address);
1763   if (tmpdir)
1764     {
1765       g_rmdir (tmpdir);
1766       g_free (tmpdir);
1767     }
1768
1769   return ret;
1770 }