tools/dbus-viewer.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* dbus-viewer.c Graphical D-Bus frontend utility
   3  *
   4  * Copyright (C) 2003 Red Hat, Inc.
   5  *
   6  * Licensed under the Academic Free License version 2.1
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23 #include <config.h>
  24 #include <stdlib.h>
  25 #include <errno.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <gtk/gtk.h>
  29 #include "dbus-tree-view.h"
  30 #include "dbus-names-model.h"
  31 #include <glib/dbus-gparser.h>
  32 #include <glib/dbus-gutils.h>
  33 #include <dbus/dbus-glib.h>
  34 #include <glib/gi18n.h>
  35
  36 static void
  37 show_error_dialog (GtkWindow *transient_parent,
  38                    GtkWidget **weak_ptr,
  39                    const char *message_format,
  40                    ...)
  41 {
  42   char *message;
  43   va_list args;
  44
  45   if (message_format)
  46     {
  47       va_start (args, message_format);
  48       message = g_strdup_vprintf (message_format, args);
  49       va_end (args);
  50     }
  51   else
  52     message = NULL;
  53
  54   if (weak_ptr == NULL || *weak_ptr == NULL)
  55     {
  56       GtkWidget *dialog;
  57       dialog = gtk_message_dialog_new (transient_parent,
  58                                        GTK_DIALOG_DESTROY_WITH_PARENT,
  59                                        GTK_MESSAGE_ERROR,
  60                                        GTK_BUTTONS_CLOSE,
  61                                        message);
  62
  63       g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtk_widget_destroy), NULL);
  64
  65       if (weak_ptr != NULL)
  66         {
  67           *weak_ptr = dialog;
  68           g_object_add_weak_pointer (G_OBJECT (dialog), (void**)weak_ptr);
  69         }
  70
  71       gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
  72
  73       gtk_widget_show_all (dialog);
  74     }
  75   else
  76     {
  77       g_return_if_fail (GTK_IS_MESSAGE_DIALOG (*weak_ptr));
  78
  79       gtk_label_set_text (GTK_LABEL (GTK_MESSAGE_DIALOG (*weak_ptr)->label), message);
  80
  81       gtk_window_present (GTK_WINDOW (*weak_ptr));
  82     }
  83 }
  84
  85 typedef struct
  86 {
  87   DBusGConnection *connection;
  88
  89   GtkWidget *window;
  90   GtkWidget *treeview;
  91   GtkWidget *name_menu;
  92
  93   GtkTreeModel *names_model;
  94
  95   GtkWidget *error_dialog;
  96
  97 } TreeWindow;
  98
  99
 100 static void
 101 tree_window_set_node (TreeWindow *w,
 102                       NodeInfo   *node)
 103 {
 104   char **path;
 105   const char *name;
 106
 107   name = node_info_get_name (node);
 108   if (name == NULL ||
 109       name[0] != '/')
 110     {
 111       g_printerr (_("Assuming root node is at path /, since no absolute path is specified"));
 112       name = "/";
 113     }
 114
 115   path = _dbus_gutils_split_path (name);
 116
 117   dbus_tree_view_update (GTK_TREE_VIEW (w->treeview),
 118                          (const char**) path,
 119                          node);
 120
 121   g_strfreev (path);
 122 }
 123
 124 typedef struct
 125 {
 126   DBusGConnection *connection;
 127   char *service_name;
 128   GError *error;
 129   NodeInfo *node;
 130   TreeWindow *window; /* Not touched from child thread */
 131 } LoadFromServiceData;
 132
 133 static gboolean
 134 load_child_nodes (const char *service_name,
 135                   NodeInfo   *parent,
 136                   GString    *path,
 137                   GError    **error)
 138 {
 139   DBusGConnection *connection;
 140   GSList *tmp;
 141
 142   connection = dbus_g_bus_get (DBUS_BUS_SESSION, error);
 143   if (connection == NULL)
 144     return FALSE;
 145
 146   tmp = node_info_get_nodes (parent);
 147   while (tmp != NULL)
 148     {
 149       DBusGProxy *proxy;
 150       char *data;
 151       NodeInfo *child;
 152       NodeInfo *complete_child;
 153       int save_len;
 154
 155       complete_child = NULL;
 156
 157       child = tmp->data;
 158
 159       save_len = path->len;
 160
 161       if (save_len > 1)
 162         g_string_append (path, "/");
 163       g_string_append (path, base_info_get_name ((BaseInfo*)child));
 164
 165       if (*service_name == ':')
 166         {
 167           proxy = dbus_g_proxy_new_for_name (connection,
 168                                              service_name,
 169                                              path->str,
 170                                              DBUS_INTERFACE_INTROSPECTABLE);
 171           g_assert (proxy != NULL);
 172         }
 173       else
 174         {
 175           proxy = dbus_g_proxy_new_for_name_owner (connection,
 176                                                    service_name,
 177                                                    path->str,
 178                                                    DBUS_INTERFACE_INTROSPECTABLE,
 179                                                    error);
 180           if (proxy == NULL)
 181             goto done;
 182         }
 183
 184       if (!dbus_g_proxy_call (proxy, "Introspect", error,
 185                               G_TYPE_INVALID,
 186                               G_TYPE_STRING, &data,
 187                               G_TYPE_INVALID))
 188           goto done;
 189
 190       complete_child = description_load_from_string (data, -1, error);
 191       g_free (data);
 192       if (complete_child == NULL)
 193         {
 194           g_printerr ("%s\n", data);
 195           goto done;
 196         }
 197
 198     done:
 199       g_object_unref (proxy);
 200
 201       if (complete_child == NULL)
 202         return FALSE;
 203
 204       /* change complete_child's name to relative */
 205       base_info_set_name ((BaseInfo*)complete_child,
 206                           base_info_get_name ((BaseInfo*)child));
 207
 208       /* Stitch in complete_child rather than child */
 209       node_info_replace_node (parent, child, complete_child);
 210       node_info_unref (complete_child); /* ref still held by parent */
 211
 212       /* Now recurse */
 213       if (!load_child_nodes (service_name, complete_child, path, error))
 214         return FALSE;
 215
 216       /* restore path */
 217       g_string_set_size (path, save_len);
 218
 219       tmp = tmp->next;
 220     }
 221
 222   return TRUE;
 223 }
 224
 225 static gboolean
 226 load_from_service_complete_idle (void *data)
 227 {
 228   /* Called in main thread */
 229   GThread *thread = data;
 230   LoadFromServiceData *d;
 231   NodeInfo *node;
 232
 233   d = g_thread_join (thread);
 234
 235   node = d->node;
 236
 237   if (d->error)
 238     {
 239       g_assert (d->node == NULL);
 240       show_error_dialog (GTK_WINDOW (d->window->window), &d->window->error_dialog,
 241                          _("Unable to load \"%s\": %s\n"),
 242                          d->service_name, d->error->message);
 243       g_error_free (d->error);
 244     }
 245   else
 246     {
 247       g_assert (d->error == NULL);
 248
 249       tree_window_set_node (d->window, node);
 250       node_info_unref (node);
 251     }
 252
 253   g_free (d->service_name);
 254   dbus_g_connection_unref (d->connection);
 255   g_free (d);
 256
 257   return FALSE;
 258 }
 259
 260 static void*
 261 load_from_service_thread_func (void *thread_data)
 262 {
 263   DBusGProxy *root_proxy;
 264   const char *data;
 265   NodeInfo *node;
 266   GString *path;
 267   LoadFromServiceData *lfsd;
 268
 269   lfsd = thread_data;
 270
 271   node = NULL;
 272   path = NULL;
 273
 274 #if 1
 275   /* this will end up autolaunching the service when we introspect it */
 276   root_proxy = dbus_g_proxy_new_for_name (lfsd->connection,
 277                                           lfsd->service_name,
 278                                           "/",
 279                                           DBUS_INTERFACE_INTROSPECTABLE);
 280   g_assert (root_proxy != NULL);
 281 #else
 282   /* this will be an error if the service doesn't exist */
 283   root_proxy = dbus_g_proxy_new_for_name_owner (lfsd->connection,
 284                                                 lfsd->service_name,
 285                                                 "/",
 286                                                 DBUS_INTERFACE_INTROSPECTABLE,
 287                                                 &lfsd->error);
 288   if (root_proxy == NULL)
 289     {
 290       g_printerr ("Failed to get owner of '%s'\n", lfsd->service_name);
 291       return lfsd->data;
 292     }
 293 #endif
 294
 295   if (!dbus_g_proxy_call (root_proxy, "Introspect", &lfsd->error,
 296                           G_TYPE_INVALID,
 297                           G_TYPE_STRING, &data,
 298                           G_TYPE_INVALID))
 299     {
 300       g_printerr ("Failed to Introspect() %s\n",
 301                   dbus_g_proxy_get_bus_name (root_proxy));
 302       goto out;
 303     }
 304
 305   node = description_load_from_string (data, -1, &lfsd->error);
 306
 307   /* g_print ("%s\n", data); */
 308
 309   if (node == NULL)
 310     goto out;
 311
 312   base_info_set_name ((BaseInfo*)node, "/");
 313
 314   path = g_string_new ("/");
 315
 316   if (!load_child_nodes (dbus_g_proxy_get_bus_name (root_proxy),
 317                          node, path, &lfsd->error))
 318     {
 319       node_info_unref (node);
 320       node = NULL;
 321       goto out;
 322     }
 323
 324  out:
 325   g_object_unref (root_proxy);
 326
 327   if (path)
 328     g_string_free (path, TRUE);
 329
 330   lfsd->node = node;
 331   g_assert (lfsd->node || lfsd->error);
 332   g_assert (lfsd->node == NULL || lfsd->error == NULL);
 333
 334   /* Add idle to main thread that will join us back */
 335   g_idle_add (load_from_service_complete_idle, g_thread_self ());
 336
 337   return lfsd;
 338 }
 339
 340 static void
 341 start_load_from_service (TreeWindow      *w,
 342                          DBusGConnection *connection,
 343                          const char      *service_name)
 344 {
 345   LoadFromServiceData *d;
 346
 347   d = g_new0 (LoadFromServiceData, 1);
 348
 349   d->connection = dbus_g_connection_ref (connection);
 350   d->service_name = g_strdup (service_name);
 351   d->error = NULL;
 352   d->node = NULL;
 353   d->window = w;
 354
 355   g_thread_create (load_from_service_thread_func, d, TRUE, NULL);
 356 }
 357
 358 static void
 359 tree_window_set_service (TreeWindow *w,
 360                          const char *service_name)
 361 {
 362   start_load_from_service (w, w->connection, service_name);
 363 }
 364
 365 static void
 366 name_combo_changed_callback (GtkComboBox *combo,
 367                              TreeWindow  *w)
 368 {
 369   GtkTreeIter iter;
 370
 371   if (gtk_combo_box_get_active_iter (combo, &iter))
 372     {
 373       GtkTreeModel *model;
 374       char *text;
 375
 376       model = gtk_combo_box_get_model (combo);
 377       gtk_tree_model_get (model, &iter, 0, &text, -1);
 378
 379       if (text)
 380         {
 381           tree_window_set_service (w, text);
 382           g_free (text);
 383         }
 384     }
 385 }
 386
 387 static void
 388 window_closed_callback (GtkWidget  *window,
 389                         TreeWindow *w)
 390 {
 391   g_assert (window == w->window);
 392   w->window = NULL;
 393   gtk_main_quit ();
 394 }
 395
 396 static TreeWindow*
 397 tree_window_new (DBusGConnection *connection,
 398                  GtkTreeModel    *names_model)
 399 {
 400   TreeWindow *w;
 401   GtkWidget *sw;
 402   GtkWidget *vbox;
 403   GtkWidget *hbox;
 404   GtkWidget *combo;
 405
 406   /* Should use glade, blah */
 407
 408   w = g_new0 (TreeWindow, 1);
 409   w->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 410
 411   gtk_window_set_title (GTK_WINDOW (w->window), "D-Bus Viewer");
 412   gtk_window_set_default_size (GTK_WINDOW (w->window), 400, 500);
 413
 414   g_signal_connect (w->window, "destroy", G_CALLBACK (window_closed_callback),
 415                     w);
 416   gtk_container_set_border_width (GTK_CONTAINER (w->window), 6);
 417
 418   vbox = gtk_vbox_new (FALSE, 6);
 419   gtk_container_add (GTK_CONTAINER (w->window), vbox);
 420
 421   /* Create names option menu */
 422   if (connection)
 423     {
 424       GtkCellRenderer *cell;
 425
 426       w->connection = connection;
 427
 428       w->names_model = names_model;
 429
 430       combo = gtk_combo_box_new_with_model (w->names_model);
 431
 432       cell = gtk_cell_renderer_text_new ();
 433       gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE);
 434       gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell,
 435                                       "text", 0,
 436                                       NULL);
 437
 438       gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 0);
 439
 440       g_signal_connect (combo, "changed",
 441                         G_CALLBACK (name_combo_changed_callback),
 442                         w);
 443     }
 444
 445   /* Create tree view */
 446   hbox = gtk_hbox_new (FALSE, 6);
 447   gtk_container_add (GTK_CONTAINER (vbox), hbox);
 448
 449   sw = gtk_scrolled_window_new (NULL, NULL);
 450   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 451                                   GTK_POLICY_AUTOMATIC,
 452                                   GTK_POLICY_AUTOMATIC);
 453
 454   gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0);
 455
 456   w->treeview = dbus_tree_view_new ();
 457
 458   gtk_container_add (GTK_CONTAINER (sw), w->treeview);
 459
 460   /* Show everything */
 461   gtk_widget_show_all (w->window);
 462
 463   return w;
 464 }
 465
 466 static void
 467 usage (int ecode)
 468 {
 469   fprintf (stderr, "dbus-viewer [--version] [--help]\n");
 470   exit (ecode);
 471 }
 472
 473 static void
 474 version (void)
 475 {
 476   printf ("D-Bus Message Bus Viewer %s\n"
 477           "Copyright (C) 2003 Red Hat, Inc.\n"
 478           "This is free software; see the source for copying conditions.\n"
 479           "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n",
 480           VERSION);
 481   exit (0);
 482 }
 483
 484 int
 485 main (int argc, char **argv)
 486 {
 487   int i;
 488   GSList *files;
 489   gboolean end_of_args;
 490   GSList *tmp;
 491   gboolean services;
 492   DBusGConnection *connection;
 493   GError *error;
 494   GtkTreeModel *names_model;
 495
 496   g_thread_init (NULL);
 497   dbus_g_thread_init ();
 498
 499   bindtextdomain (GETTEXT_PACKAGE, DBUS_LOCALEDIR);
 500   bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
 501   textdomain (GETTEXT_PACKAGE);
 502
 503   gtk_init (&argc, &argv);
 504
 505   services = FALSE;
 506   end_of_args = FALSE;
 507   files = NULL;
 508   i = 1;
 509   while (i < argc)
 510     {
 511       const char *arg = argv[i];
 512
 513       if (!end_of_args)
 514         {
 515           if (strcmp (arg, "--help") == 0 ||
 516               strcmp (arg, "-h") == 0 ||
 517               strcmp (arg, "-?") == 0)
 518             usage (0);
 519           else if (strcmp (arg, "--version") == 0)
 520             version ();
 521           else if (strcmp (arg, "--services") == 0)
 522             services = TRUE;
 523           else if (arg[0] == '-' &&
 524                    arg[1] == '-' &&
 525                    arg[2] == '\0')
 526             end_of_args = TRUE;
 527           else if (arg[0] == '-')
 528             {
 529               usage (1);
 530             }
 531           else
 532             {
 533               files = g_slist_prepend (files, (char*) arg);
 534             }
 535         }
 536       else
 537         files = g_slist_prepend (files, (char*) arg);
 538
 539       ++i;
 540     }
 541
 542   if (services || files == NULL)
 543     {
 544       error = NULL;
 545       connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
 546       if (connection == NULL)
 547         {
 548           g_printerr ("Could not open bus connection: %s\n",
 549                       error->message);
 550           g_error_free (error);
 551           exit (1);
 552         }
 553
 554       g_assert (connection == dbus_g_bus_get (DBUS_BUS_SESSION, NULL));
 555
 556       names_model = names_model_new (connection);
 557     }
 558   else
 559     {
 560       connection = NULL;
 561       names_model = NULL;
 562     }
 563
 564   if (files == NULL)
 565     {
 566       TreeWindow *w;
 567
 568       w = tree_window_new (connection, names_model);
 569     }
 570
 571   files = g_slist_reverse (files);
 572
 573   tmp = files;
 574   while (tmp != NULL)
 575     {
 576       const char *filename;
 577       TreeWindow *w;
 578
 579       filename = tmp->data;
 580
 581       if (services)
 582         {
 583           w = tree_window_new (connection, names_model);
 584           tree_window_set_service (w, filename);
 585         }
 586       else
 587         {
 588           NodeInfo *node;
 589
 590           error = NULL;
 591           node = description_load_from_file (filename,
 592                                              &error);
 593
 594           if (node == NULL)
 595             {
 596               g_assert (error != NULL);
 597               show_error_dialog (NULL, NULL,
 598                                  _("Unable to load \"%s\": %s\n"),
 599                                  filename, error->message);
 600               g_error_free (error);
 601             }
 602           else
 603             {
 604               w = tree_window_new (connection, names_model);
 605               tree_window_set_node (w, node);
 606               node_info_unref (node);
 607             }
 608         }
 609
 610       tmp = tmp->next;
 611     }
 612
 613   gtk_main ();
 614
 615   return 0;
 616 }
 617