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
36static void
37show_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
85typedef 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
100static void
101tree_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
124typedef 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
133static gboolean
134load_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
225static gboolean
226load_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
260static void*
261load_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
340static void
341start_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
358static void
359tree_window_set_service (TreeWindow *w,
360                         const char *service_name)
361{
362  start_load_from_service (w, w->connection, service_name);
363}
364
365static void
366name_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
387static void
388window_closed_callback (GtkWidget  *window,
389                        TreeWindow *w)
390{
391  g_assert (window == w->window);
392  w->window = NULL;
393  gtk_main_quit ();
394}
395
396static TreeWindow*
397tree_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
466static void
467usage (int ecode)
468{
469  fprintf (stderr, "dbus-viewer [--version] [--help]\n");
470  exit (ecode);
471}
472
473static void
474version (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
484int
485main (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
618