821cb4afcea7ab4e45c729eb80028d0f18359a0b
[platform/upstream/dbus.git] / bus / services.c
1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* services.c  Service management
3  *
4  * Copyright (C) 2003  Red Hat, Inc.
5  * Copyright (C) 2003  CodeFactory AB
6  *
7  * Licensed under the Academic Free License version 1.2
8  * 
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  * 
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  *
23  */
24 #include <dbus/dbus-hash.h>
25 #include <dbus/dbus-list.h>
26 #include <dbus/dbus-mempool.h>
27
28 #include "driver.h"
29 #include "services.h"
30 #include "connection.h"
31 #include "utils.h"
32 #include "activation.h"
33
34 struct BusService
35 {
36   BusRegistry *registry;
37   char *name;
38   DBusList *owners;
39   
40   unsigned int prohibit_replacement : 1;
41 };
42
43 struct BusRegistry
44 {
45   int refcount;
46
47   BusContext *context;
48   
49   DBusHashTable *service_hash;
50   DBusMemPool   *service_pool;
51 };
52
53 BusRegistry*
54 bus_registry_new (BusContext *context)
55 {
56   BusRegistry *registry;
57
58   registry = dbus_new0 (BusRegistry, 1);
59   if (registry == NULL)
60     return NULL;
61
62   registry->refcount = 1;
63   registry->context = context;
64   
65   registry->service_hash = _dbus_hash_table_new (DBUS_HASH_STRING,
66                                                  NULL, NULL);
67   if (registry->service_hash == NULL)
68     goto failed;
69   
70   registry->service_pool = _dbus_mem_pool_new (sizeof (BusService),
71                                                TRUE);
72   if (registry->service_pool == NULL)
73     goto failed;
74
75   return registry;
76
77  failed:
78   bus_registry_unref (registry);
79   return NULL;
80 }
81
82 void
83 bus_registry_ref (BusRegistry *registry)
84 {
85   _dbus_assert (registry->refcount > 0);
86   registry->refcount += 1;
87 }
88
89 void
90 bus_registry_unref  (BusRegistry *registry)
91 {
92   _dbus_assert (registry->refcount > 0);
93   registry->refcount -= 1;
94
95   if (registry->refcount == 0)
96     {
97       if (registry->service_hash)
98         _dbus_hash_table_unref (registry->service_hash);
99       if (registry->service_pool)
100         _dbus_mem_pool_free (registry->service_pool);
101
102       dbus_free (registry);
103     }
104 }
105
106 BusService*
107 bus_registry_lookup (BusRegistry      *registry,
108                      const DBusString *service_name)
109 {
110   const char *c_name;
111   BusService *service;
112   
113   _dbus_string_get_const_data (service_name, &c_name);
114
115   service = _dbus_hash_table_lookup_string (registry->service_hash,
116                                             c_name);
117
118   return service;
119 }
120
121 BusService*
122 bus_registry_ensure (BusRegistry               *registry,
123                      const DBusString          *service_name,
124                      DBusConnection            *owner_if_created,
125                      BusTransaction            *transaction,
126                      DBusError                 *error)
127 {
128   const char *c_name;
129   BusService *service;
130
131   _dbus_assert (owner_if_created != NULL);
132   _dbus_assert (transaction != NULL);
133   
134   _dbus_string_get_const_data (service_name, &c_name);
135
136   service = _dbus_hash_table_lookup_string (registry->service_hash,
137                                             c_name);
138   if (service != NULL)
139     return service;
140   
141   service = _dbus_mem_pool_alloc (registry->service_pool);
142   if (service == NULL)
143     {
144       BUS_SET_OOM (error);
145       return NULL;
146     }
147
148   service->registry = registry;  
149
150   service->name = _dbus_strdup (c_name);
151   if (service->name == NULL)
152     {
153       _dbus_mem_pool_dealloc (registry->service_pool, service);
154       BUS_SET_OOM (error);
155       return NULL;
156     }
157
158   if (!bus_driver_send_service_created (service->name, transaction, error))
159     {
160       dbus_free (service->name);
161       _dbus_mem_pool_dealloc (registry->service_pool, service);
162       return NULL;
163     }
164
165   if (!bus_activation_service_created (bus_context_get_activation (registry->context),
166                                        service->name, error))
167     {
168       dbus_free (service->name);
169       _dbus_mem_pool_dealloc (registry->service_pool, service);
170       return NULL;
171     }
172   
173   if (!bus_service_add_owner (service, owner_if_created,
174                               transaction, error))
175     {
176       dbus_free (service->name);
177       _dbus_mem_pool_dealloc (registry->service_pool, service);
178       return NULL;
179     }
180   
181   if (!_dbus_hash_table_insert_string (registry->service_hash,
182                                        service->name,
183                                        service))
184     {
185       bus_connection_remove_owned_service (owner_if_created,
186                                            service);
187       _dbus_list_clear (&service->owners);
188       dbus_free (service->name);
189       _dbus_mem_pool_dealloc (registry->service_pool, service);
190       BUS_SET_OOM (error);
191       return NULL;
192     }
193   
194   return service;
195 }
196
197 void
198 bus_registry_foreach (BusRegistry               *registry,
199                       BusServiceForeachFunction  function,
200                       void                      *data)
201 {
202   DBusHashIter iter;
203   
204   _dbus_hash_iter_init (registry->service_hash, &iter);
205   while (_dbus_hash_iter_next (&iter))
206     {
207       BusService *service = _dbus_hash_iter_get_value (&iter);
208
209       (* function) (service, data);
210     }
211 }
212
213 dbus_bool_t
214 bus_registry_list_services (BusRegistry *registry,
215                             char      ***listp,
216                             int         *array_len)
217 {
218   int i, j, len;
219   char **retval;
220   DBusHashIter iter;
221    
222   len = _dbus_hash_table_get_n_entries (registry->service_hash);
223   retval = dbus_new (char *, len + 1);
224
225   if (retval == NULL)
226     return FALSE;
227
228   _dbus_hash_iter_init (registry->service_hash, &iter);
229   i = 0;
230   while (_dbus_hash_iter_next (&iter))
231     {
232       BusService *service = _dbus_hash_iter_get_value (&iter);
233
234       retval[i] = _dbus_strdup (service->name);
235       if (retval[i] == NULL)
236         goto error;
237
238       i++;
239     }
240
241   retval[i] = NULL;
242   
243   if (array_len)
244     *array_len = len;
245   
246   *listp = retval;
247   return TRUE;
248   
249  error:
250   for (j = 0; j < i; j++)
251     dbus_free (retval[i]);
252   dbus_free (retval);
253
254   return FALSE;
255 }
256
257 dbus_bool_t
258 bus_service_add_owner (BusService     *service,
259                        DBusConnection *owner,
260                        BusTransaction *transaction,
261                        DBusError      *error)
262 {
263  /* Send service acquired message first, OOM will result
264   * in cancelling the transaction
265   */
266   if (service->owners == NULL)
267     {
268       if (!bus_driver_send_service_acquired (owner, service->name, transaction, error))
269         return FALSE;
270     }
271   
272   if (!_dbus_list_append (&service->owners,
273                           owner))
274     {
275       BUS_SET_OOM (error);
276       return FALSE;
277     }
278
279   if (!bus_connection_add_owned_service (owner, service))
280     {
281       _dbus_list_remove_last (&service->owners, owner);
282       BUS_SET_OOM (error);
283       return FALSE;
284     }
285   
286   return TRUE;
287 }
288
289 dbus_bool_t
290 bus_service_remove_owner (BusService     *service,
291                           DBusConnection *owner,
292                           BusTransaction *transaction,
293                           DBusError      *error)
294 {
295   /* We send out notifications before we do any work we
296    * might have to undo if the notification-sending failed
297    */
298   
299   /* Send service lost message */
300   if (bus_service_get_primary_owner (service) == owner)
301     {
302       if (!bus_driver_send_service_lost (owner, service->name,
303                                          transaction, error))
304         return FALSE;
305     }
306
307   if (service->owners == NULL)
308     {
309       _dbus_assert_not_reached ("Tried to remove owner of a service that has no owners");
310     }
311   else if (_dbus_list_length_is_one (&service->owners))
312     {
313       /* We are the only owner - send service deleted */
314       if (!bus_driver_send_service_deleted (service->name,
315                                             transaction, error))
316         return FALSE;
317     }
318   else
319     {
320       DBusList *link;
321       link = _dbus_list_get_first (&service->owners);
322       _dbus_assert (link != NULL);
323       link = _dbus_list_get_next_link (&service->owners, link);
324
325       if (link != NULL)
326         {
327           /* This will be our new owner */
328           if (!bus_driver_send_service_acquired (link->data,
329                                                  service->name,
330                                                  transaction,
331                                                  error))
332             return FALSE;
333         }
334     }
335   
336   _dbus_list_remove_last (&service->owners, owner);
337   bus_connection_remove_owned_service (owner, service);
338
339   if (service->owners == NULL)
340     {
341       /* Delete service (already sent message that it was deleted above) */
342       _dbus_hash_table_remove_string (service->registry->service_hash,
343                                       service->name);
344       
345       dbus_free (service->name);
346       _dbus_mem_pool_dealloc (service->registry->service_pool, service);
347     }
348
349   return TRUE;
350 }
351
352 DBusConnection*
353 bus_service_get_primary_owner (BusService *service)
354 {
355   return _dbus_list_get_first (&service->owners);
356 }
357
358 const char*
359 bus_service_get_name (BusService *service)
360 {
361   return service->name;
362 }
363
364 void
365 bus_service_set_prohibit_replacement (BusService  *service,
366                                       dbus_bool_t  prohibit_replacement)
367 {
368   service->prohibit_replacement = prohibit_replacement != FALSE;
369 }
370
371 dbus_bool_t
372 bus_service_get_prohibit_replacement (BusService *service)
373 {
374   return service->prohibit_replacement;
375 }
376
377 dbus_bool_t
378 bus_service_has_owner (BusService     *service,
379                        DBusConnection *owner)
380 {
381   DBusList *link;
382
383   link = _dbus_list_get_first_link (&service->owners);
384   
385   while (link != NULL)
386     {
387       if (link->data == owner)
388         return TRUE;
389       
390       link = _dbus_list_get_next_link (&service->owners, link);
391     }
392
393   return FALSE;
394 }