1 /* -*- mode: C; c-file-style: "gnu" -*- */

     2 /* activation.c  Activation of services

     3  *

     4  * Copyright (C) 2003  CodeFactory AB

     5  * Copyright (C) 2003  Red Hat, Inc.

     6  * Copyright (C) 2004  Imendio HB

     7  * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     8  *

     9  * Licensed under the Academic Free License version 2.1

    10  * 

    11  * This program is free software; you can redistribute it and/or modify

    12  * it under the terms of the GNU General Public License as published by

    13  * the Free Software Foundation; either version 2 of the License, or

    14  * (at your option) any later version.

    15  *

    16  * This program is distributed in the hope that it will be useful,

    17  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19  * GNU General Public License for more details.

    20  * 

    21  * You should have received a copy of the GNU General Public License

    22  * along with this program; if not, write to the Free Software

    23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24  *

    25  */ 

    26 #include "activation.h"

    27 #include "desktop-file.h" 

    28 #include "services.h"

    29 #include "test.h"

    30 #include "utils.h"

    31 

    32 #ifndef __SYMBIAN32__

    33 #include <dbus/dbus-internals.h>

    34 #include <dbus/dbus-hash.h>

    35 #include <dbus/dbus-list.h>

    36 #include <dbus/dbus-shell.h>

    37 #include <dbus/dbus-spawn.h>

    38 #include <dbus/dbus-timeout.h>

    39 #include <dbus/dbus-sysdeps.h>

    40 #else

    41 #include "dbus-internals.h"

    42 #include "dbus-hash.h"

    43 #include "dbus-list.h"

    44 #include "dbus-shell.h"

    45 #include "dbus-spawn.h"

    46 #include "dbus-timeout.h"

    47 #include "dbus-sysdeps.h"

    48 #endif //__SYMBIAN32__

    49 #include <dirent.h>

    50 #include <errno.h>

    51 

    52 #define DBUS_SERVICE_SECTION "D-BUS Service"

    53 #define DBUS_SERVICE_NAME "Name"

    54 #define DBUS_SERVICE_EXEC "Exec"

    55 

    56 struct BusActivation

    57 {

    58   int refcount;

    59   DBusHashTable *entries;

    60   DBusHashTable *pending_activations;

    61   char *server_address;

    62   BusContext *context;

    63   int n_pending_activations; /**< This is in fact the number of BusPendingActivationEntry,

    64                               * i.e. number of pending activation requests, not pending

    65                               * activations per se

    66                               */

    67   DBusHashTable *directories;

    68 };

    69 

    70 typedef struct

    71 {

    72   int refcount;

    73   char *dir_c;

    74   DBusHashTable *entries;

    75 } BusServiceDirectory;

    76 

    77 typedef struct

    78 {

    79   int refcount;

    80   char *name;

    81   char *exec;

    82   unsigned long mtime;

    83   BusServiceDirectory *s_dir;

    84   char *filename;

    85 } BusActivationEntry;

    86 

    87 typedef struct BusPendingActivationEntry BusPendingActivationEntry;

    88 

    89 struct BusPendingActivationEntry

    90 {

    91   DBusMessage *activation_message;

    92   DBusConnection *connection;

    93 

    94   dbus_bool_t auto_activation;

    95 };

    96 

    97 typedef struct

    98 {

    99   int refcount;

   100   BusActivation *activation;

   101   char *service_name;

   102   char *exec;

   103   DBusList *entries;

   104   int n_entries;

   105   DBusBabysitter *babysitter;

   106   DBusTimeout *timeout;

   107   unsigned int timeout_added : 1;

   108 } BusPendingActivation;

   109 

   110 #if 0

   111 static BusServiceDirectory *

   112 bus_service_directory_ref (BusServiceDirectory *dir)

   113 {

   114   _dbus_assert (dir->refcount);

   115   

   116   dir->refcount++;

   117 

   118   return dir;

   119 }

   120 #endif

   121 

   122 static void

   123 bus_service_directory_unref (BusServiceDirectory *dir)

   124 {

   125   if (dir == NULL) 

   126     return; 

   127 

   128   _dbus_assert (dir->refcount > 0);

   129   dir->refcount--;

   130 

   131   if (dir->refcount > 0)

   132     return;

   133 

   134   if (dir->entries)

   135     _dbus_hash_table_unref (dir->entries);

   136 

   137   dbus_free (dir->dir_c);

   138   dbus_free (dir);

   139 }

   140 

   141 static void

   142 bus_pending_activation_entry_free (BusPendingActivationEntry *entry)

   143 {

   144   if (entry->activation_message)

   145     dbus_message_unref (entry->activation_message);

   146   

   147   if (entry->connection)

   148     dbus_connection_unref (entry->connection);

   149   

   150   dbus_free (entry);

   151 }

   152 

   153 static void

   154 handle_timeout_callback (DBusTimeout   *timeout,

   155                          void          *data)

   156 {

   157   BusPendingActivation *pending_activation = data;

   158 

   159   while (!dbus_timeout_handle (pending_activation->timeout))

   160     _dbus_wait_for_memory ();

   161 }

   162 

   163 static BusPendingActivation * 

   164 bus_pending_activation_ref (BusPendingActivation *pending_activation)

   165 {

   166   _dbus_assert (pending_activation->refcount > 0);

   167   pending_activation->refcount += 1;

   168 

   169   return pending_activation;

   170 }

   171 

   172 static void

   173 bus_pending_activation_unref (BusPendingActivation *pending_activation)

   174 {

   175   DBusList *link;

   176   

   177   if (pending_activation == NULL) /* hash table requires this */

   178     return;

   179 

   180   _dbus_assert (pending_activation->refcount > 0);

   181   pending_activation->refcount -= 1;

   182 

   183   if (pending_activation->refcount > 0)

   184     return;

   185   

   186   if (pending_activation->timeout_added)

   187     {

   188       _dbus_loop_remove_timeout (bus_context_get_loop (pending_activation->activation->context),

   189                                  pending_activation->timeout,

   190                                  handle_timeout_callback, pending_activation);

   191       pending_activation->timeout_added = FALSE;

   192     }

   193 

   194   if (pending_activation->timeout)

   195     _dbus_timeout_unref (pending_activation->timeout);

   196   

   197   if (pending_activation->babysitter)

   198     {

   199       if (!_dbus_babysitter_set_watch_functions (pending_activation->babysitter,

   200                                                  NULL, NULL, NULL,

   201                                                  pending_activation->babysitter,

   202                                                  NULL))

   203         _dbus_assert_not_reached ("setting watch functions to NULL failed");

   204       

   205       _dbus_babysitter_unref (pending_activation->babysitter);

   206     }

   207   

   208   dbus_free (pending_activation->service_name);

   209   dbus_free (pending_activation->exec);

   210 

   211   link = _dbus_list_get_first_link (&pending_activation->entries);

   212 

   213   while (link != NULL)

   214     {

   215       BusPendingActivationEntry *entry = link->data;

   216 

   217       bus_pending_activation_entry_free (entry);

   218 

   219       link = _dbus_list_get_next_link (&pending_activation->entries, link);

   220     }

   221   _dbus_list_clear (&pending_activation->entries);

   222 

   223   pending_activation->activation->n_pending_activations -=

   224     pending_activation->n_entries;

   225 

   226   _dbus_assert (pending_activation->activation->n_pending_activations >= 0);

   227   

   228   dbus_free (pending_activation);

   229 }

   230 

   231 static BusActivationEntry *

   232 bus_activation_entry_ref (BusActivationEntry *entry)

   233 {

   234   _dbus_assert (entry->refcount > 0);

   235   entry->refcount++;

   236 

   237   return entry;

   238 }

   239 

   240 static void

   241 bus_activation_entry_unref (BusActivationEntry *entry)

   242 {

   243   if (entry == NULL) /* hash table requires this */

   244     return;

   245   

   246   _dbus_assert (entry->refcount > 0);

   247   entry->refcount--;

   248   

   249   if (entry->refcount > 0) 

   250     return;

   251   

   252   dbus_free (entry->name);

   253   dbus_free (entry->exec);

   254   dbus_free (entry->filename);

   255 

   256   dbus_free (entry);

   257 }

   258 

   259 static dbus_bool_t

   260 update_desktop_file_entry (BusActivation       *activation,

   261                            BusServiceDirectory *s_dir,

   262                            DBusString          *filename,

   263                            BusDesktopFile      *desktop_file,

   264                            DBusError           *error)

   265 {

   266   char *name, *exec;

   267   BusActivationEntry *entry;

   268   DBusStat stat_buf;

   269   DBusString file_path;

   270 

   271   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   272   

   273   name = NULL;

   274   exec = NULL;

   275   entry = NULL;

   276   

   277   if (!_dbus_string_init (&file_path))

   278     {

   279       BUS_SET_OOM (error);

   280       return FALSE;

   281     }

   282  

   283   if (!_dbus_string_append (&file_path, s_dir->dir_c) ||

   284       !_dbus_concat_dir_and_file (&file_path, filename))

   285     {

   286       BUS_SET_OOM (error);

   287       goto failed;

   288     }

   289  

   290   if (!_dbus_stat (&file_path, &stat_buf, NULL)) 

   291     {

   292       dbus_set_error (error, DBUS_ERROR_FAILED,

   293                       "Can't stat the service file\n");

   294       goto failed;

   295     }

   296  

   297   if (!bus_desktop_file_get_string (desktop_file,

   298                                     DBUS_SERVICE_SECTION,

   299                                     DBUS_SERVICE_NAME,

   300                                     &name,

   301                                     error))

   302     goto failed;

   303 

   304   if (!bus_desktop_file_get_string (desktop_file,

   305                                     DBUS_SERVICE_SECTION,

   306                                     DBUS_SERVICE_EXEC,

   307                                     &exec,

   308                                     error))

   309     goto failed;

   310 

   311   entry = _dbus_hash_table_lookup_string (s_dir->entries, 

   312                                           _dbus_string_get_const_data (filename));

   313   if (entry == NULL) /* New file */

   314     { 

   315       /* FIXME we need a better-defined algorithm for which service file to

   316        * pick than "whichever one is first in the directory listing"

   317        */

   318       if (_dbus_hash_table_lookup_string (activation->entries, name))

   319         {

   320           dbus_set_error (error, DBUS_ERROR_FAILED,

   321                           "Service %s already exists in activation entry list\n", name);

   322           goto failed;

   323         }

   324       

   325       entry = dbus_new0 (BusActivationEntry, 1);

   326       if (entry == NULL)

   327         {

   328           BUS_SET_OOM (error);

   329           goto failed;

   330         }

   331      

   332       entry->name = name;

   333       entry->exec = exec;

   334       entry->refcount = 1;

   335     

   336       entry->s_dir = s_dir;

   337       entry->filename = _dbus_strdup (_dbus_string_get_const_data (filename));

   338       if (!entry->filename)

   339         {

   340           BUS_SET_OOM (error);

   341           goto failed;

   342         }

   343 

   344       if (!_dbus_hash_table_insert_string (activation->entries, entry->name, bus_activation_entry_ref (entry)))

   345         {

   346           BUS_SET_OOM (error);

   347           goto failed;

   348         }

   349      

   350       if (!_dbus_hash_table_insert_string (s_dir->entries, entry->filename, bus_activation_entry_ref (entry)))

   351         {

   352           /* Revert the insertion in the entries table */

   353           _dbus_hash_table_remove_string (activation->entries, entry->name);

   354           BUS_SET_OOM (error);

   355           goto failed;

   356         }

   357 

   358       _dbus_verbose ("Added \"%s\" to list of services\n", entry->name);

   359     }

   360   else /* Just update the entry */

   361     {

   362       bus_activation_entry_ref (entry);

   363       _dbus_hash_table_remove_string (activation->entries, entry->name);

   364 

   365       if (_dbus_hash_table_lookup_string (activation->entries, name))

   366         {

   367           _dbus_verbose ("The new service name \"%s\" of service file \"%s\" already in cache, ignoring\n",

   368                          name, _dbus_string_get_const_data (&file_path));

   369           goto failed;

   370         }

   371  

   372       dbus_free (entry->name);

   373       dbus_free (entry->exec);

   374       entry->name = name;

   375       entry->exec = exec;

   376       if (!_dbus_hash_table_insert_string (activation->entries,

   377                                            entry->name, bus_activation_entry_ref(entry)))

   378         {

   379           BUS_SET_OOM (error);

   380           /* Also remove path to entries hash since we want this in sync with

   381            * the entries hash table */

   382           _dbus_hash_table_remove_string (entry->s_dir->entries, 

   383                                           entry->filename);

   384           bus_activation_entry_unref (entry);

   385           return FALSE;

   386         }

   387     }

   388   

   389   entry->mtime = stat_buf.mtime;

   390   

   391   _dbus_string_free (&file_path);

   392   bus_activation_entry_unref (entry);

   393 

   394   return TRUE;

   395 

   396 failed:

   397   dbus_free (name);

   398   dbus_free (exec);

   399   _dbus_string_free (&file_path);

   400 

   401   if (entry)

   402     bus_activation_entry_unref (entry);

   403   

   404   return FALSE;

   405 }

   406 

   407 static dbus_bool_t

   408 check_service_file (BusActivation       *activation,

   409                     BusActivationEntry  *entry,

   410                     BusActivationEntry **updated_entry,

   411                     DBusError           *error)

   412 {

   413   DBusStat stat_buf;

   414   dbus_bool_t retval;

   415   BusActivationEntry *tmp_entry;

   416   DBusString file_path;

   417   DBusString filename;

   418 

   419   retval = TRUE;

   420   tmp_entry = entry;

   421   

   422   _dbus_string_init_const (&filename, entry->filename);

   423   

   424   if (!_dbus_string_init (&file_path))

   425     {

   426       BUS_SET_OOM (error);

   427       return FALSE;

   428     }

   429  

   430   if (!_dbus_string_append (&file_path, entry->s_dir->dir_c) ||

   431       !_dbus_concat_dir_and_file (&file_path, &filename))

   432     {

   433       BUS_SET_OOM (error);

   434       retval = FALSE;

   435       goto out;

   436     }

   437   

   438   if (!_dbus_stat (&file_path, &stat_buf, NULL))

   439     {

   440       _dbus_verbose ("****** Can't stat file \"%s\", removing from cache\n",

   441                      _dbus_string_get_const_data (&file_path));

   442 

   443       _dbus_hash_table_remove_string (activation->entries, entry->name);

   444       _dbus_hash_table_remove_string (entry->s_dir->entries, entry->filename);

   445 

   446       tmp_entry = NULL;

   447       retval = TRUE;

   448       goto out;

   449     }

   450   else 

   451     {

   452       if (stat_buf.mtime > entry->mtime) 

   453         {

   454           BusDesktopFile *desktop_file;

   455           DBusError tmp_error;

   456           

   457           dbus_error_init (&tmp_error);

   458           

   459           desktop_file = bus_desktop_file_load (&file_path, &tmp_error);

   460           if (desktop_file == NULL)

   461             {

   462               _dbus_verbose ("Could not load %s: %s\n",

   463                              _dbus_string_get_const_data (&file_path), 

   464                              tmp_error.message);

   465               if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))

   466                 {

   467                   dbus_move_error (&tmp_error, error);

   468                   retval = FALSE;

   469                   goto out;

   470                 }

   471               dbus_error_free (&tmp_error);

   472               retval = TRUE;

   473               goto out;

   474             }

   475          

   476           /* @todo We can return OOM or a DBUS_ERROR_FAILED error 

   477            *       Handle these both better

   478            */ 

   479           if (!update_desktop_file_entry (activation, entry->s_dir, &filename, desktop_file, &tmp_error))

   480             {

   481               bus_desktop_file_free (desktop_file);

   482               if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))

   483                 {

   484                   dbus_move_error (&tmp_error, error);

   485                   retval = FALSE;

   486                   goto out;

   487                 }

   488               dbus_error_free (&tmp_error);

   489               retval = TRUE;

   490               goto out;

   491             }

   492          

   493           bus_desktop_file_free (desktop_file);

   494           retval = TRUE;

   495         }

   496     }

   497   

   498 out:

   499   _dbus_string_free (&file_path);

   500 

   501   if (updated_entry != NULL)

   502     *updated_entry = tmp_entry;

   503   return retval;

   504 }

   505 

   506 

   507 /* warning: this doesn't fully "undo" itself on failure, i.e. doesn't strip

   508  * hash entries it already added.

   509  */

   510 static dbus_bool_t

   511 update_directory (BusActivation       *activation,

   512                   BusServiceDirectory *s_dir,

   513                   DBusError           *error)

   514 {

   515   DBusDirIter *iter;

   516   DBusString dir, filename;

   517   BusDesktopFile *desktop_file;

   518   DBusError tmp_error;

   519   dbus_bool_t retval;

   520   BusActivationEntry *entry;

   521   DBusString full_path;

   522   

   523   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   524   

   525   iter = NULL;

   526   desktop_file = NULL;

   527   

   528   _dbus_string_init_const (&dir, s_dir->dir_c);

   529   

   530   if (!_dbus_string_init (&filename))

   531     {

   532       BUS_SET_OOM (error);

   533       return FALSE;

   534     }

   535 

   536   if (!_dbus_string_init (&full_path))

   537     {

   538       BUS_SET_OOM (error);

   539       _dbus_string_free (&filename);

   540       return FALSE;

   541     }

   542 

   543   retval = FALSE;

   544 

   545   /* from this point it's safe to "goto out" */

   546   

   547   iter = _dbus_directory_open (&dir, error);

   548   if (iter == NULL)

   549     {

   550       _dbus_verbose ("Failed to open directory %s: %s\n",

   551                      s_dir->dir_c, 

   552                      error ? error->message : "unknown");

   553       goto out;

   554     }

   555   

   556   /* Now read the files */

   557   dbus_error_init (&tmp_error);

   558   while (_dbus_directory_get_next_file (iter, &filename, &tmp_error))

   559     {

   560       _dbus_assert (!dbus_error_is_set (&tmp_error));

   561       

   562       _dbus_string_set_length (&full_path, 0);

   563       

   564       if (!_dbus_string_ends_with_c_str (&filename, ".service"))

   565         {

   566           _dbus_verbose ("Skipping non-.service file %s\n",

   567                          _dbus_string_get_const_data (&filename));

   568           continue;

   569         }

   570 

   571       entry = _dbus_hash_table_lookup_string (s_dir->entries, _dbus_string_get_const_data (&filename));

   572       if (entry) /* Already has this service file in the cache */ 

   573         {

   574           if (!check_service_file (activation, entry, NULL, error))

   575             goto out;

   576 

   577           continue;

   578         }

   579       

   580       if (!_dbus_string_append (&full_path, s_dir->dir_c) ||

   581           !_dbus_concat_dir_and_file (&full_path, &filename))

   582         {

   583           BUS_SET_OOM (error);

   584           goto out;

   585         }

   586           

   587       /* New file */

   588       desktop_file = bus_desktop_file_load (&full_path, &tmp_error);

   589       if (desktop_file == NULL)

   590         {

   591           _dbus_verbose ("Could not load %s: %s\n",

   592                          _dbus_string_get_const_data (&full_path),

   593                          tmp_error.message);

   594 

   595           if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))

   596             {

   597               dbus_move_error (&tmp_error, error);

   598               goto out;

   599             }

   600           

   601           dbus_error_free (&tmp_error);

   602           continue;

   603         }

   604 

   605       /* @todo We can return OOM or a DBUS_ERROR_FAILED error 

   606        *       Handle these both better

   607        */ 

   608       if (!update_desktop_file_entry (activation, s_dir, &filename, desktop_file, &tmp_error))

   609         {

   610           bus_desktop_file_free (desktop_file);

   611           desktop_file = NULL;

   612           

   613           _dbus_verbose ("Could not add %s to activation entry list: %s\n",

   614                          _dbus_string_get_const_data (&full_path), tmp_error.message);

   615 

   616           if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))

   617             {

   618               dbus_move_error (&tmp_error, error);

   619               goto out;

   620             }

   621 

   622           dbus_error_free (&tmp_error);

   623           continue;

   624         }

   625       else

   626         {

   627           bus_desktop_file_free (desktop_file);

   628           desktop_file = NULL;

   629           continue;

   630         }

   631     }

   632 

   633   if (dbus_error_is_set (&tmp_error))

   634     {

   635       dbus_move_error (&tmp_error, error);

   636       goto out;

   637     }

   638   

   639   retval = TRUE;

   640 

   641  out:

   642   if (!retval)

   643     _DBUS_ASSERT_ERROR_IS_SET (error);

   644   else

   645     _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   646   

   647   if (iter != NULL)

   648     _dbus_directory_close (iter);

   649   _dbus_string_free (&filename);

   650   _dbus_string_free (&full_path);

   651   

   652   return retval;

   653 }

   654 

   655 BusActivation*

   656 bus_activation_new (BusContext        *context,

   657                     const DBusString  *address,

   658                     DBusList         **directories,

   659                     DBusError         *error)

   660 {

   661   BusActivation *activation;

   662   DBusList      *link;

   663   char          *dir;

   664   

   665   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   666   

   667   activation = dbus_new0 (BusActivation, 1);

   668   if (activation == NULL)

   669     {

   670       BUS_SET_OOM (error);

   671       return NULL;

   672     }

   673   

   674   activation->refcount = 1;

   675   activation->context = context;

   676   activation->n_pending_activations = 0;

   677   

   678   if (!_dbus_string_copy_data (address, &activation->server_address))

   679     {

   680       BUS_SET_OOM (error);

   681       goto failed;

   682     }

   683   

   684   activation->entries = _dbus_hash_table_new (DBUS_HASH_STRING, NULL,

   685                                              (DBusFreeFunction)bus_activation_entry_unref);

   686   if (activation->entries == NULL)

   687     {      

   688       BUS_SET_OOM (error);

   689       goto failed;

   690     }

   691 

   692   activation->pending_activations = _dbus_hash_table_new (DBUS_HASH_STRING, NULL,

   693                                                           (DBusFreeFunction)bus_pending_activation_unref);

   694 

   695   if (activation->pending_activations == NULL)

   696     {

   697       BUS_SET_OOM (error);

   698       goto failed;

   699     }

   700 

   701   activation->directories = _dbus_hash_table_new (DBUS_HASH_STRING, NULL,

   702                                                   (DBusFreeFunction)bus_service_directory_unref);

   703   

   704   if (activation->directories == NULL) 

   705     {

   706       BUS_SET_OOM (error);

   707       goto failed;

   708     }

   709  

   710   /* Load service files */

   711   link = _dbus_list_get_first_link (directories);

   712   while (link != NULL)

   713     {

   714       BusServiceDirectory *s_dir;

   715       

   716       dir = _dbus_strdup ((const char *) link->data);

   717       if (!dir)

   718         {

   719           BUS_SET_OOM (error);

   720           goto failed;

   721         }

   722       

   723       s_dir = dbus_new0 (BusServiceDirectory, 1);

   724       if (!s_dir)

   725         {

   726           dbus_free (dir);

   727           BUS_SET_OOM (error);

   728           goto failed;

   729         }

   730 

   731       s_dir->refcount = 1;

   732       s_dir->dir_c = dir;

   733       

   734       s_dir->entries = _dbus_hash_table_new (DBUS_HASH_STRING, NULL,

   735                                              (DBusFreeFunction)bus_activation_entry_unref);

   736 

   737       if (!s_dir->entries)

   738         {

   739           bus_service_directory_unref (s_dir);

   740           BUS_SET_OOM (error);

   741           goto failed;

   742         }

   743 

   744       if (!_dbus_hash_table_insert_string (activation->directories, s_dir->dir_c, s_dir))

   745         {

   746           bus_service_directory_unref (s_dir);

   747           BUS_SET_OOM (error);

   748           goto failed;

   749         }

   750 

   751       /* only fail on OOM, it is ok if we can't read the directory */

   752       if (!update_directory (activation, s_dir, error))

   753         { 

   754           if (dbus_error_has_name (error, DBUS_ERROR_NO_MEMORY)) 

   755             goto failed;

   756           else

   757             dbus_error_free (error);

   758         }

   759 

   760       link = _dbus_list_get_next_link (directories, link);

   761     }

   762 

   763   return activation;

   764   

   765  failed:

   766   bus_activation_unref (activation);  

   767   return NULL;

   768 }

   769 

   770 BusActivation *

   771 bus_activation_ref (BusActivation *activation)

   772 {

   773   _dbus_assert (activation->refcount > 0);

   774   

   775   activation->refcount += 1;

   776 

   777   return activation;

   778 }

   779 

   780 void

   781 bus_activation_unref (BusActivation *activation)

   782 {

   783   _dbus_assert (activation->refcount > 0);

   784 

   785   activation->refcount -= 1;

   786 

   787   if (activation->refcount > 0)

   788     return;

   789   

   790   dbus_free (activation->server_address);

   791   if (activation->entries)

   792     _dbus_hash_table_unref (activation->entries);

   793   if (activation->pending_activations)

   794     _dbus_hash_table_unref (activation->pending_activations);

   795   if (activation->directories)  

   796     _dbus_hash_table_unref (activation->directories);

   797   

   798   dbus_free (activation);

   799 }

   800 

   801 static void

   802 child_setup (void *data)

   803 {

   804   BusActivation *activation = data;

   805   const char *type;

   806   

   807   /* If no memory, we simply have the child exit, so it won't try

   808    * to connect to the wrong thing.

   809    */

   810   if (!_dbus_setenv ("DBUS_STARTER_ADDRESS", activation->server_address))

   811     _dbus_exit (1);

   812   

   813   type = bus_context_get_type (activation->context);

   814   if (type != NULL)

   815     {

   816       if (!_dbus_setenv ("DBUS_STARTER_BUS_TYPE", type))

   817         _dbus_exit (1);

   818 

   819       if (strcmp (type, "session") == 0)

   820         {

   821           if (!_dbus_setenv ("DBUS_SESSION_BUS_ADDRESS",

   822                              activation->server_address))

   823             _dbus_exit (1);

   824         }

   825       else if (strcmp (type, "system") == 0)

   826         {

   827           if (!_dbus_setenv ("DBUS_SYSTEM_BUS_ADDRESS",

   828                              activation->server_address))

   829             _dbus_exit (1);

   830         }

   831     }

   832 }

   833 

   834 typedef struct

   835 {

   836   BusPendingActivation *pending_activation;

   837   DBusPreallocatedHash *hash_entry;

   838 } RestorePendingData;

   839 

   840 static void

   841 restore_pending (void *data)

   842 {

   843   RestorePendingData *d = data;

   844 

   845   _dbus_assert (d->pending_activation != NULL);

   846   _dbus_assert (d->hash_entry != NULL);

   847 

   848   _dbus_verbose ("Restoring pending activation for service %s, has timeout = %d\n",

   849                  d->pending_activation->service_name,

   850                  d->pending_activation->timeout_added);

   851   

   852   _dbus_hash_table_insert_string_preallocated (d->pending_activation->activation->pending_activations,

   853                                                d->hash_entry,

   854                                                d->pending_activation->service_name, d->pending_activation);

   855 

   856   bus_pending_activation_ref (d->pending_activation);

   857   

   858   d->hash_entry = NULL;

   859 }

   860 

   861 static void

   862 free_pending_restore_data (void *data)

   863 {

   864   RestorePendingData *d = data;

   865 

   866   if (d->hash_entry)

   867     _dbus_hash_table_free_preallocated_entry (d->pending_activation->activation->pending_activations,

   868                                               d->hash_entry);

   869 

   870   bus_pending_activation_unref (d->pending_activation);

   871   

   872   dbus_free (d);

   873 }

   874 

   875 static dbus_bool_t

   876 add_restore_pending_to_transaction (BusTransaction       *transaction,

   877                                     BusPendingActivation *pending_activation)

   878 {

   879   RestorePendingData *d;

   880 

   881   d = dbus_new (RestorePendingData, 1);

   882   if (d == NULL)

   883     return FALSE;

   884   

   885   d->pending_activation = pending_activation;

   886   d->hash_entry = _dbus_hash_table_preallocate_entry (d->pending_activation->activation->pending_activations);

   887   

   888   bus_pending_activation_ref (d->pending_activation);

   889   

   890   if (d->hash_entry == NULL ||

   891       !bus_transaction_add_cancel_hook (transaction, restore_pending, d,

   892                                         free_pending_restore_data))

   893     {

   894       free_pending_restore_data (d);

   895       return FALSE;

   896     }

   897 

   898   _dbus_verbose ("Saved pending activation to be restored if the transaction fails\n");

   899   

   900   return TRUE;

   901 }

   902 

   903 dbus_bool_t

   904 bus_activation_service_created (BusActivation  *activation,

   905                                 const char     *service_name,

   906                                 BusTransaction *transaction,

   907                                 DBusError      *error)

   908 {

   909   BusPendingActivation *pending_activation;

   910   DBusMessage *message;

   911   DBusList *link;

   912 

   913   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   914   

   915   /* Check if it's a pending activation */

   916   pending_activation = _dbus_hash_table_lookup_string (activation->pending_activations, service_name);

   917 

   918   if (!pending_activation)

   919     return TRUE;

   920 

   921   link = _dbus_list_get_first_link (&pending_activation->entries);

   922   while (link != NULL)

   923     {

   924       BusPendingActivationEntry *entry = link->data;

   925       DBusList *next = _dbus_list_get_next_link (&pending_activation->entries, link);

   926       

   927       if (dbus_connection_get_is_connected (entry->connection))

   928         {

   929           /* Only send activation replies to regular activation requests. */

   930           if (!entry->auto_activation)

   931             {

   932               dbus_uint32_t result;

   933               

   934               message = dbus_message_new_method_return (entry->activation_message);

   935               if (!message)

   936                 {

   937                   BUS_SET_OOM (error);

   938                   goto error;

   939                 }

   940 

   941               result = DBUS_START_REPLY_SUCCESS;

   942               

   943               if (!dbus_message_append_args (message,

   944                                              DBUS_TYPE_UINT32, &result,

   945                                              DBUS_TYPE_INVALID))

   946                 {

   947                   dbus_message_unref (message);

   948                   BUS_SET_OOM (error);

   949                   goto error;

   950                 }

   951               

   952               if (!bus_transaction_send_from_driver (transaction, entry->connection, message))

   953                 {

   954                   dbus_message_unref (message);

   955                   BUS_SET_OOM (error);

   956                   goto error;

   957                 }

   958               

   959               dbus_message_unref (message);

   960             }

   961         }

   962       

   963       link = next;

   964     }

   965 

   966   return TRUE;

   967 

   968  error:

   969   return FALSE;

   970 }

   971 

   972 dbus_bool_t

   973 bus_activation_send_pending_auto_activation_messages (BusActivation  *activation,

   974                                                       BusService     *service,

   975                                                       BusTransaction *transaction,

   976                                                       DBusError      *error)

   977 {

   978   BusPendingActivation *pending_activation;

   979   DBusList *link;

   980 

   981   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   982   

   983   /* Check if it's a pending activation */

   984   pending_activation = _dbus_hash_table_lookup_string (activation->pending_activations,

   985                                                        bus_service_get_name (service));

   986 

   987   if (!pending_activation)

   988     return TRUE;

   989 

   990   link = _dbus_list_get_first_link (&pending_activation->entries);

   991   while (link != NULL)

   992     {

   993       BusPendingActivationEntry *entry = link->data;

   994       DBusList *next = _dbus_list_get_next_link (&pending_activation->entries, link);

   995 

   996       if (entry->auto_activation && dbus_connection_get_is_connected (entry->connection))

   997         {

   998           DBusConnection *addressed_recipient;

   999           

  1000           addressed_recipient = bus_service_get_primary_owners_connection (service);

  1001 

  1002           /* Check the security policy, which has the side-effect of adding an

  1003            * expected pending reply.

  1004            */

  1005           if (!bus_context_check_security_policy (activation->context, transaction,

  1006                                                   entry->connection,

  1007                                                   addressed_recipient,

  1008                                                   addressed_recipient,

  1009                                                   entry->activation_message, error))

  1010             goto error;

  1011 

  1012           if (!bus_transaction_send (transaction, addressed_recipient, entry->activation_message))

  1013             {

  1014               BUS_SET_OOM (error);

  1015               goto error;

  1016             }

  1017         }

  1018 

  1019       link = next;

  1020     }

  1021 

  1022   if (!add_restore_pending_to_transaction (transaction, pending_activation))

  1023     {

  1024       _dbus_verbose ("Could not add cancel hook to transaction to revert removing pending activation\n");

  1025       BUS_SET_OOM (error);

  1026       goto error;

  1027     }

  1028   

  1029   _dbus_hash_table_remove_string (activation->pending_activations, bus_service_get_name (service));

  1030 

  1031   return TRUE;

  1032 

  1033  error:

  1034   return FALSE;

  1035 }

  1036 

  1037 /**

  1038  * FIXME @todo the error messages here would ideally be preallocated

  1039  * so we don't need to allocate memory to send them.

  1040  * Using the usual tactic, prealloc an OOM message, then

  1041  * if we can't alloc the real error send the OOM error instead.

  1042  */

  1043 static dbus_bool_t

  1044 try_send_activation_failure (BusPendingActivation *pending_activation,

  1045                              const DBusError      *how)

  1046 {

  1047   BusActivation *activation;

  1048   DBusList *link;

  1049   BusTransaction *transaction;

  1050   

  1051   activation = pending_activation->activation;

  1052 

  1053   transaction = bus_transaction_new (activation->context);

  1054   if (transaction == NULL)

  1055     return FALSE;

  1056   

  1057   link = _dbus_list_get_first_link (&pending_activation->entries);

  1058   while (link != NULL)

  1059     {

  1060       BusPendingActivationEntry *entry = link->data;

  1061       DBusList *next = _dbus_list_get_next_link (&pending_activation->entries, link);

  1062       

  1063       if (dbus_connection_get_is_connected (entry->connection))

  1064         {

  1065           if (!bus_transaction_send_error_reply (transaction,

  1066                                                  entry->connection,

  1067                                                  how,

  1068                                                  entry->activation_message))

  1069             goto error;

  1070         }

  1071       

  1072       link = next;

  1073     }

  1074 

  1075   bus_transaction_execute_and_free (transaction);

  1076   

  1077   return TRUE;

  1078 

  1079  error:

  1080   if (transaction)

  1081     bus_transaction_cancel_and_free (transaction);

  1082   return FALSE;

  1083 }

  1084 

  1085 /**

  1086  * Free the pending activation and send an error message to all the

  1087  * connections that were waiting for it.

  1088  */

  1089 static void

  1090 pending_activation_failed (BusPendingActivation *pending_activation,

  1091                            const DBusError      *how)

  1092 {

  1093   /* FIXME use preallocated OOM messages instead of bus_wait_for_memory() */

  1094   while (!try_send_activation_failure (pending_activation, how))

  1095     _dbus_wait_for_memory ();

  1096 

  1097   /* Destroy this pending activation */

  1098   _dbus_hash_table_remove_string (pending_activation->activation->pending_activations,

  1099                                   pending_activation->service_name);

  1100 }

  1101 

  1102 static dbus_bool_t

  1103 babysitter_watch_callback (DBusWatch     *watch,

  1104                            unsigned int   condition,

  1105                            void          *data)

  1106 {

  1107   BusPendingActivation *pending_activation = data;

  1108   dbus_bool_t retval;

  1109   DBusBabysitter *babysitter;

  1110 

  1111   babysitter = pending_activation->babysitter;

  1112   

  1113   _dbus_babysitter_ref (babysitter);

  1114   

  1115   retval = dbus_watch_handle (watch, condition);

  1116 

  1117   /* FIXME this is broken in the same way that

  1118    * connection watches used to be; there should be

  1119    * a separate callback for status change, instead

  1120    * of doing "if we handled a watch status might

  1121    * have changed"

  1122    *

  1123    * Fixing this lets us move dbus_watch_handle

  1124    * calls into dbus-mainloop.c

  1125    */

  1126   

  1127   if (_dbus_babysitter_get_child_exited (babysitter))

  1128     {

  1129       DBusError error;

  1130       DBusHashIter iter;

  1131       

  1132       dbus_error_init (&error);

  1133       _dbus_babysitter_set_child_exit_error (babysitter, &error);

  1134 

  1135       /* Destroy all pending activations with the same exec */