Merge remote branch 'gvdb/master'
[platform/upstream/glib.git] / gio / tests / gdbus-sessionbus.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, write to the
17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18  * Boston, MA 02111-1307, USA.
19  *
20  * Author: David Zeuthen <davidz@redhat.com>
21  */
22
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <errno.h>
27 #include <sys/types.h>
28 #include <sys/wait.h>
29 #include <signal.h>
30 #include <stdio.h>
31
32 #include <gio/gio.h>
33
34 #include "gdbus-sessionbus.h"
35
36 /* ---------------------------------------------------------------------------------------------------- */
37 /* Utilities for bringing up and tearing down session message bus instances */
38
39 static void
40 watch_parent (gint fd)
41 {
42   GPollFD fds[1];
43   gint num_events;
44   gchar buf[512];
45   guint bytes_read;
46   GArray *buses_to_kill_array;
47
48   fds[0].fd = fd;
49   fds[0].events = G_IO_HUP | G_IO_IN;
50   fds[0].revents = 0;
51
52   buses_to_kill_array = g_array_new (FALSE, TRUE, sizeof (guint));
53
54   do
55     {
56       guint pid;
57       guint n;
58
59       num_events = g_poll (fds, 1, -1);
60       if (num_events == 0)
61         continue;
62
63       if (fds[0].revents == G_IO_HUP)
64         {
65           for (n = 0; n < buses_to_kill_array->len; n++)
66             {
67               pid = g_array_index (buses_to_kill_array, guint, n);
68               g_print ("cleaning up bus with pid %d\n", pid);
69               kill (pid, SIGTERM);
70             }
71           g_array_free (buses_to_kill_array, TRUE);
72           exit (0);
73         }
74
75       //g_debug ("data from parent");
76
77       memset (buf, '\0', sizeof buf);
78     again:
79       bytes_read = read (fds[0].fd, buf, sizeof buf);
80       if (bytes_read < 0 && (errno == EAGAIN || errno == EINTR))
81         goto again;
82
83       if (sscanf (buf, "add %d\n", &pid) == 1)
84         {
85           g_array_append_val (buses_to_kill_array, pid);
86         }
87       else if (sscanf (buf, "remove %d\n", &pid) == 1)
88         {
89           for (n = 0; n < buses_to_kill_array->len; n++)
90             {
91               if (g_array_index (buses_to_kill_array, guint, n) == pid)
92                 {
93                   g_array_remove_index (buses_to_kill_array, n);
94                   pid = 0;
95                   break;
96                 }
97             }
98           if (pid != 0)
99             {
100               g_warning ("unknown pid %d to remove", pid);
101             }
102         }
103       else
104         {
105           g_warning ("unknown command from parent '%s'", buf);
106         }
107     }
108   while (TRUE);
109
110 }
111
112 static GHashTable *session_bus_address_to_pid = NULL;
113 static gint pipe_fds[2];
114
115 const gchar *
116 session_bus_up_with_address (const gchar *given_address)
117 {
118   gchar *address;
119   int stdout_fd;
120   GError *error;
121   gchar *argv[] = {"dbus-daemon", "--print-address", "--config-file=foo", NULL};
122   GPid pid;
123   gchar buf[512];
124   ssize_t bytes_read;
125   gchar *config_file_name;
126   gint config_file_fd;
127   GString *config_file_contents;
128
129   address = NULL;
130   error = NULL;
131   config_file_name = NULL;
132   config_file_fd = -1;
133   argv[2] = NULL;
134
135   config_file_fd = g_file_open_tmp ("g-dbus-tests-XXXXXX",
136                                     &config_file_name,
137                                     &error);
138   if (config_file_fd < 0)
139     {
140       g_warning ("Error creating temporary config file: %s", error->message);
141       g_error_free (error);
142       goto out;
143     }
144
145   config_file_contents = g_string_new (NULL);
146   g_string_append        (config_file_contents, "<busconfig>\n");
147   g_string_append        (config_file_contents, "  <type>session</type>\n");
148   g_string_append_printf (config_file_contents, "  <listen>%s</listen>\n", given_address);
149   g_string_append        (config_file_contents,
150                           "  <policy context=\"default\">\n"
151                           "    <!-- Allow everything to be sent -->\n"
152                           "    <allow send_destination=\"*\" eavesdrop=\"true\"/>\n"
153                           "    <!-- Allow everything to be received -->\n"
154                           "    <allow eavesdrop=\"true\"/>\n"
155                           "    <!-- Allow anyone to own anything -->\n"
156                           "    <allow own=\"*\"/>\n"
157                           "  </policy>\n");
158   g_string_append        (config_file_contents, "</busconfig>\n");
159
160   if (write (config_file_fd, config_file_contents->str, config_file_contents->len) != (gssize) config_file_contents->len)
161     {
162       g_warning ("Error writing %d bytes to config file: %m", (gint) config_file_contents->len);
163       g_string_free (config_file_contents, TRUE);
164       goto out;
165     }
166   g_string_free (config_file_contents, TRUE);
167
168   argv[2] = g_strdup_printf ("--config-file=%s", config_file_name);
169
170   if (session_bus_address_to_pid == NULL)
171     {
172       /* keep a mapping from session bus address to the pid */
173       session_bus_address_to_pid = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
174
175       /* fork a child to clean up session buses when we are killed */
176       if (pipe (pipe_fds) != 0)
177         {
178           g_warning ("pipe() failed: %m");
179           g_assert_not_reached ();
180         }
181       switch (fork ())
182         {
183         case -1:
184           g_warning ("fork() failed: %m");
185           g_assert_not_reached ();
186           break;
187
188         case 0:
189           /* child */
190           close (pipe_fds[1]);
191           watch_parent (pipe_fds[0]);
192           break;
193
194         default:
195           /* parent */
196           close (pipe_fds[0]);
197           break;
198         }
199
200       //atexit (cleanup_session_buses);
201       /* TODO: need to handle the cases where we crash */
202     }
203   else
204     {
205       /* check if we already have a bus running for this address */
206       if (g_hash_table_lookup (session_bus_address_to_pid, given_address) != NULL)
207         {
208           g_warning ("Already have a bus instance for the given address %s", given_address);
209           goto out;
210         }
211     }
212
213   if (!g_spawn_async_with_pipes (NULL,
214                                  argv,
215                                  NULL,
216                                  G_SPAWN_SEARCH_PATH,
217                                  NULL,
218                                  NULL,
219                                  &pid,
220                                  NULL,
221                                  &stdout_fd,
222                                  NULL,
223                                  &error))
224     {
225       g_warning ("Error spawning dbus-daemon: %s", error->message);
226       g_error_free (error);
227       goto out;
228     }
229
230   memset (buf, '\0', sizeof buf);
231  again:
232   bytes_read = read (stdout_fd, buf, sizeof buf);
233   if (bytes_read < 0 && (errno == EAGAIN || errno == EINTR))
234     goto again;
235   close (stdout_fd);
236
237   if (bytes_read == 0 || bytes_read == sizeof buf)
238     {
239       g_warning ("Error reading address from dbus daemon, %d bytes read", (gint) bytes_read);
240       kill (SIGTERM, pid);
241       goto out;
242     }
243
244   address = g_strdup (buf);
245   g_strstrip (address);
246
247   /* write the pid to the child so it can kill it when we die */
248   g_snprintf (buf, sizeof buf, "add %d\n", (guint) pid);
249   write (pipe_fds[1], buf, strlen (buf));
250
251   /* start dbus-monitor */
252   if (g_getenv ("G_DBUS_MONITOR") != NULL)
253     {
254       g_spawn_command_line_async ("dbus-monitor --session", NULL);
255       usleep (500 * 1000);
256     }
257
258   g_hash_table_insert (session_bus_address_to_pid, address, GUINT_TO_POINTER (pid));
259
260  out:
261   if (config_file_fd > 0)
262     {
263       if (close (config_file_fd) != 0)
264         {
265           g_warning ("Error closing fd for config file %s: %m", config_file_name);
266         }
267       g_assert (config_file_name != NULL);
268       if (unlink (config_file_name) != 0)
269         {
270           g_warning ("Error unlinking config file %s: %m", config_file_name);
271         }
272     }
273   g_free (argv[2]);
274   g_free (config_file_name);
275   return address;
276 }
277
278 void
279 session_bus_down_with_address (const gchar *address)
280 {
281   gpointer value;
282   GPid pid;
283   gchar buf[512];
284
285   g_assert (address != NULL);
286   g_assert (session_bus_address_to_pid != NULL);
287
288   value = g_hash_table_lookup (session_bus_address_to_pid, address);
289   g_assert (value != NULL);
290
291   pid = GPOINTER_TO_UINT (g_hash_table_lookup (session_bus_address_to_pid, address));
292
293   kill (pid, SIGTERM);
294
295   /* write the pid to the child so it won't kill it when we die */
296   g_snprintf (buf, sizeof buf, "remove %d\n", (guint) pid);
297   write (pipe_fds[1], buf, strlen (buf));
298
299   g_hash_table_remove (session_bus_address_to_pid, address);
300 }
301
302 static gchar *temporary_address = NULL;
303 static gchar *temporary_address_used_by_bus = NULL;
304
305 const gchar *
306 session_bus_get_temporary_address (void)
307 {
308   if (temporary_address == NULL)
309     {
310       temporary_address = g_strdup_printf ("unix:path=/tmp/g-dbus-tests-pid-%d", getpid ());
311     }
312
313   return temporary_address;
314 }
315
316 const gchar *
317 session_bus_up (void)
318 {
319   if (temporary_address_used_by_bus != NULL)
320     {
321       g_warning ("There is already a session bus up");
322       goto out;
323     }
324
325   temporary_address_used_by_bus = g_strdup (session_bus_up_with_address (session_bus_get_temporary_address ()));
326
327  out:
328   return temporary_address_used_by_bus;
329 }
330
331 void
332 session_bus_down (void)
333 {
334   if (temporary_address_used_by_bus == NULL)
335     {
336       g_warning ("There is not a session bus up");
337     }
338   else
339     {
340       session_bus_down_with_address (temporary_address_used_by_bus);
341       g_free (temporary_address_used_by_bus);
342       temporary_address_used_by_bus = NULL;
343     }
344 }