1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/ofdbus/dbus/bus/activation.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1989 @@
1.4 +/* -*- mode: C; c-file-style: "gnu" -*- */
1.5 +/* activation.c Activation of services
1.6 + *
1.7 + * Copyright (C) 2003 CodeFactory AB
1.8 + * Copyright (C) 2003 Red Hat, Inc.
1.9 + * Copyright (C) 2004 Imendio HB
1.10 + * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
1.11 + *
1.12 + * Licensed under the Academic Free License version 2.1
1.13 + *
1.14 + * This program is free software; you can redistribute it and/or modify
1.15 + * it under the terms of the GNU General Public License as published by
1.16 + * the Free Software Foundation; either version 2 of the License, or
1.17 + * (at your option) any later version.
1.18 + *
1.19 + * This program is distributed in the hope that it will be useful,
1.20 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1.21 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1.22 + * GNU General Public License for more details.
1.23 + *
1.24 + * You should have received a copy of the GNU General Public License
1.25 + * along with this program; if not, write to the Free Software
1.26 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1.27 + *
1.28 + */
1.29 +#include "activation.h"
1.30 +#include "desktop-file.h"
1.31 +#include "services.h"
1.32 +#include "test.h"
1.33 +#include "utils.h"
1.34 +
1.35 +#ifndef __SYMBIAN32__
1.36 +#include <dbus/dbus-internals.h>
1.37 +#include <dbus/dbus-hash.h>
1.38 +#include <dbus/dbus-list.h>
1.39 +#include <dbus/dbus-shell.h>
1.40 +#include <dbus/dbus-spawn.h>
1.41 +#include <dbus/dbus-timeout.h>
1.42 +#include <dbus/dbus-sysdeps.h>
1.43 +#else
1.44 +#include "dbus-internals.h"
1.45 +#include "dbus-hash.h"
1.46 +#include "dbus-list.h"
1.47 +#include "dbus-shell.h"
1.48 +#include "dbus-spawn.h"
1.49 +#include "dbus-timeout.h"
1.50 +#include "dbus-sysdeps.h"
1.51 +#endif //__SYMBIAN32__
1.52 +#include <dirent.h>
1.53 +#include <errno.h>
1.54 +
1.55 +#define DBUS_SERVICE_SECTION "D-BUS Service"
1.56 +#define DBUS_SERVICE_NAME "Name"
1.57 +#define DBUS_SERVICE_EXEC "Exec"
1.58 +
1.59 +struct BusActivation
1.60 +{
1.61 + int refcount;
1.62 + DBusHashTable *entries;
1.63 + DBusHashTable *pending_activations;
1.64 + char *server_address;
1.65 + BusContext *context;
1.66 + int n_pending_activations; /**< This is in fact the number of BusPendingActivationEntry,
1.67 + * i.e. number of pending activation requests, not pending
1.68 + * activations per se
1.69 + */
1.70 + DBusHashTable *directories;
1.71 +};
1.72 +
1.73 +typedef struct
1.74 +{
1.75 + int refcount;
1.76 + char *dir_c;
1.77 + DBusHashTable *entries;
1.78 +} BusServiceDirectory;
1.79 +
1.80 +typedef struct
1.81 +{
1.82 + int refcount;
1.83 + char *name;
1.84 + char *exec;
1.85 + unsigned long mtime;
1.86 + BusServiceDirectory *s_dir;
1.87 + char *filename;
1.88 +} BusActivationEntry;
1.89 +
1.90 +typedef struct BusPendingActivationEntry BusPendingActivationEntry;
1.91 +
1.92 +struct BusPendingActivationEntry
1.93 +{
1.94 + DBusMessage *activation_message;
1.95 + DBusConnection *connection;
1.96 +
1.97 + dbus_bool_t auto_activation;
1.98 +};
1.99 +
1.100 +typedef struct
1.101 +{
1.102 + int refcount;
1.103 + BusActivation *activation;
1.104 + char *service_name;
1.105 + char *exec;
1.106 + DBusList *entries;
1.107 + int n_entries;
1.108 + DBusBabysitter *babysitter;
1.109 + DBusTimeout *timeout;
1.110 + unsigned int timeout_added : 1;
1.111 +} BusPendingActivation;
1.112 +
1.113 +#if 0
1.114 +static BusServiceDirectory *
1.115 +bus_service_directory_ref (BusServiceDirectory *dir)
1.116 +{
1.117 + _dbus_assert (dir->refcount);
1.118 +
1.119 + dir->refcount++;
1.120 +
1.121 + return dir;
1.122 +}
1.123 +#endif
1.124 +
1.125 +static void
1.126 +bus_service_directory_unref (BusServiceDirectory *dir)
1.127 +{
1.128 + if (dir == NULL)
1.129 + return;
1.130 +
1.131 + _dbus_assert (dir->refcount > 0);
1.132 + dir->refcount--;
1.133 +
1.134 + if (dir->refcount > 0)
1.135 + return;
1.136 +
1.137 + if (dir->entries)
1.138 + _dbus_hash_table_unref (dir->entries);
1.139 +
1.140 + dbus_free (dir->dir_c);
1.141 + dbus_free (dir);
1.142 +}
1.143 +
1.144 +static void
1.145 +bus_pending_activation_entry_free (BusPendingActivationEntry *entry)
1.146 +{
1.147 + if (entry->activation_message)
1.148 + dbus_message_unref (entry->activation_message);
1.149 +
1.150 + if (entry->connection)
1.151 + dbus_connection_unref (entry->connection);
1.152 +
1.153 + dbus_free (entry);
1.154 +}
1.155 +
1.156 +static void
1.157 +handle_timeout_callback (DBusTimeout *timeout,
1.158 + void *data)
1.159 +{
1.160 + BusPendingActivation *pending_activation = data;
1.161 +
1.162 + while (!dbus_timeout_handle (pending_activation->timeout))
1.163 + _dbus_wait_for_memory ();
1.164 +}
1.165 +
1.166 +static BusPendingActivation *
1.167 +bus_pending_activation_ref (BusPendingActivation *pending_activation)
1.168 +{
1.169 + _dbus_assert (pending_activation->refcount > 0);
1.170 + pending_activation->refcount += 1;
1.171 +
1.172 + return pending_activation;
1.173 +}
1.174 +
1.175 +static void
1.176 +bus_pending_activation_unref (BusPendingActivation *pending_activation)
1.177 +{
1.178 + DBusList *link;
1.179 +
1.180 + if (pending_activation == NULL) /* hash table requires this */
1.181 + return;
1.182 +
1.183 + _dbus_assert (pending_activation->refcount > 0);
1.184 + pending_activation->refcount -= 1;
1.185 +
1.186 + if (pending_activation->refcount > 0)
1.187 + return;
1.188 +
1.189 + if (pending_activation->timeout_added)
1.190 + {
1.191 + _dbus_loop_remove_timeout (bus_context_get_loop (pending_activation->activation->context),
1.192 + pending_activation->timeout,
1.193 + handle_timeout_callback, pending_activation);
1.194 + pending_activation->timeout_added = FALSE;
1.195 + }
1.196 +
1.197 + if (pending_activation->timeout)
1.198 + _dbus_timeout_unref (pending_activation->timeout);
1.199 +
1.200 + if (pending_activation->babysitter)
1.201 + {
1.202 + if (!_dbus_babysitter_set_watch_functions (pending_activation->babysitter,
1.203 + NULL, NULL, NULL,
1.204 + pending_activation->babysitter,
1.205 + NULL))
1.206 + _dbus_assert_not_reached ("setting watch functions to NULL failed");
1.207 +
1.208 + _dbus_babysitter_unref (pending_activation->babysitter);
1.209 + }
1.210 +
1.211 + dbus_free (pending_activation->service_name);
1.212 + dbus_free (pending_activation->exec);
1.213 +
1.214 + link = _dbus_list_get_first_link (&pending_activation->entries);
1.215 +
1.216 + while (link != NULL)
1.217 + {
1.218 + BusPendingActivationEntry *entry = link->data;
1.219 +
1.220 + bus_pending_activation_entry_free (entry);
1.221 +
1.222 + link = _dbus_list_get_next_link (&pending_activation->entries, link);
1.223 + }
1.224 + _dbus_list_clear (&pending_activation->entries);
1.225 +
1.226 + pending_activation->activation->n_pending_activations -=
1.227 + pending_activation->n_entries;
1.228 +
1.229 + _dbus_assert (pending_activation->activation->n_pending_activations >= 0);
1.230 +
1.231 + dbus_free (pending_activation);
1.232 +}
1.233 +
1.234 +static BusActivationEntry *
1.235 +bus_activation_entry_ref (BusActivationEntry *entry)
1.236 +{
1.237 + _dbus_assert (entry->refcount > 0);
1.238 + entry->refcount++;
1.239 +
1.240 + return entry;
1.241 +}
1.242 +
1.243 +static void
1.244 +bus_activation_entry_unref (BusActivationEntry *entry)
1.245 +{
1.246 + if (entry == NULL) /* hash table requires this */
1.247 + return;
1.248 +
1.249 + _dbus_assert (entry->refcount > 0);
1.250 + entry->refcount--;
1.251 +
1.252 + if (entry->refcount > 0)
1.253 + return;
1.254 +
1.255 + dbus_free (entry->name);
1.256 + dbus_free (entry->exec);
1.257 + dbus_free (entry->filename);
1.258 +
1.259 + dbus_free (entry);
1.260 +}
1.261 +
1.262 +static dbus_bool_t
1.263 +update_desktop_file_entry (BusActivation *activation,
1.264 + BusServiceDirectory *s_dir,
1.265 + DBusString *filename,
1.266 + BusDesktopFile *desktop_file,
1.267 + DBusError *error)
1.268 +{
1.269 + char *name, *exec;
1.270 + BusActivationEntry *entry;
1.271 + DBusStat stat_buf;
1.272 + DBusString file_path;
1.273 +
1.274 + _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1.275 +
1.276 + name = NULL;
1.277 + exec = NULL;
1.278 + entry = NULL;
1.279 +
1.280 + if (!_dbus_string_init (&file_path))
1.281 + {
1.282 + BUS_SET_OOM (error);
1.283 + return FALSE;
1.284 + }
1.285 +
1.286 + if (!_dbus_string_append (&file_path, s_dir->dir_c) ||
1.287 + !_dbus_concat_dir_and_file (&file_path, filename))
1.288 + {
1.289 + BUS_SET_OOM (error);
1.290 + goto failed;
1.291 + }
1.292 +
1.293 + if (!_dbus_stat (&file_path, &stat_buf, NULL))
1.294 + {
1.295 + dbus_set_error (error, DBUS_ERROR_FAILED,
1.296 + "Can't stat the service file\n");
1.297 + goto failed;
1.298 + }
1.299 +
1.300 + if (!bus_desktop_file_get_string (desktop_file,
1.301 + DBUS_SERVICE_SECTION,
1.302 + DBUS_SERVICE_NAME,
1.303 + &name,
1.304 + error))
1.305 + goto failed;
1.306 +
1.307 + if (!bus_desktop_file_get_string (desktop_file,
1.308 + DBUS_SERVICE_SECTION,
1.309 + DBUS_SERVICE_EXEC,
1.310 + &exec,
1.311 + error))
1.312 + goto failed;
1.313 +
1.314 + entry = _dbus_hash_table_lookup_string (s_dir->entries,
1.315 + _dbus_string_get_const_data (filename));
1.316 + if (entry == NULL) /* New file */
1.317 + {
1.318 + /* FIXME we need a better-defined algorithm for which service file to
1.319 + * pick than "whichever one is first in the directory listing"
1.320 + */
1.321 + if (_dbus_hash_table_lookup_string (activation->entries, name))
1.322 + {
1.323 + dbus_set_error (error, DBUS_ERROR_FAILED,
1.324 + "Service %s already exists in activation entry list\n", name);
1.325 + goto failed;
1.326 + }
1.327 +
1.328 + entry = dbus_new0 (BusActivationEntry, 1);
1.329 + if (entry == NULL)
1.330 + {
1.331 + BUS_SET_OOM (error);
1.332 + goto failed;
1.333 + }
1.334 +
1.335 + entry->name = name;
1.336 + entry->exec = exec;
1.337 + entry->refcount = 1;
1.338 +
1.339 + entry->s_dir = s_dir;
1.340 + entry->filename = _dbus_strdup (_dbus_string_get_const_data (filename));
1.341 + if (!entry->filename)
1.342 + {
1.343 + BUS_SET_OOM (error);
1.344 + goto failed;
1.345 + }
1.346 +
1.347 + if (!_dbus_hash_table_insert_string (activation->entries, entry->name, bus_activation_entry_ref (entry)))
1.348 + {
1.349 + BUS_SET_OOM (error);
1.350 + goto failed;
1.351 + }
1.352 +
1.353 + if (!_dbus_hash_table_insert_string (s_dir->entries, entry->filename, bus_activation_entry_ref (entry)))
1.354 + {
1.355 + /* Revert the insertion in the entries table */
1.356 + _dbus_hash_table_remove_string (activation->entries, entry->name);
1.357 + BUS_SET_OOM (error);
1.358 + goto failed;
1.359 + }
1.360 +
1.361 + _dbus_verbose ("Added \"%s\" to list of services\n", entry->name);
1.362 + }
1.363 + else /* Just update the entry */
1.364 + {
1.365 + bus_activation_entry_ref (entry);
1.366 + _dbus_hash_table_remove_string (activation->entries, entry->name);
1.367 +
1.368 + if (_dbus_hash_table_lookup_string (activation->entries, name))
1.369 + {
1.370 + _dbus_verbose ("The new service name \"%s\" of service file \"%s\" already in cache, ignoring\n",
1.371 + name, _dbus_string_get_const_data (&file_path));
1.372 + goto failed;
1.373 + }
1.374 +
1.375 + dbus_free (entry->name);
1.376 + dbus_free (entry->exec);
1.377 + entry->name = name;
1.378 + entry->exec = exec;
1.379 + if (!_dbus_hash_table_insert_string (activation->entries,
1.380 + entry->name, bus_activation_entry_ref(entry)))
1.381 + {
1.382 + BUS_SET_OOM (error);
1.383 + /* Also remove path to entries hash since we want this in sync with
1.384 + * the entries hash table */
1.385 + _dbus_hash_table_remove_string (entry->s_dir->entries,
1.386 + entry->filename);
1.387 + bus_activation_entry_unref (entry);
1.388 + return FALSE;
1.389 + }
1.390 + }
1.391 +
1.392 + entry->mtime = stat_buf.mtime;
1.393 +
1.394 + _dbus_string_free (&file_path);
1.395 + bus_activation_entry_unref (entry);
1.396 +
1.397 + return TRUE;
1.398 +
1.399 +failed:
1.400 + dbus_free (name);
1.401 + dbus_free (exec);
1.402 + _dbus_string_free (&file_path);
1.403 +
1.404 + if (entry)
1.405 + bus_activation_entry_unref (entry);
1.406 +
1.407 + return FALSE;
1.408 +}
1.409 +
1.410 +static dbus_bool_t
1.411 +check_service_file (BusActivation *activation,
1.412 + BusActivationEntry *entry,
1.413 + BusActivationEntry **updated_entry,
1.414 + DBusError *error)
1.415 +{
1.416 + DBusStat stat_buf;
1.417 + dbus_bool_t retval;
1.418 + BusActivationEntry *tmp_entry;
1.419 + DBusString file_path;
1.420 + DBusString filename;
1.421 +
1.422 + retval = TRUE;
1.423 + tmp_entry = entry;
1.424 +
1.425 + _dbus_string_init_const (&filename, entry->filename);
1.426 +
1.427 + if (!_dbus_string_init (&file_path))
1.428 + {
1.429 + BUS_SET_OOM (error);
1.430 + return FALSE;
1.431 + }
1.432 +
1.433 + if (!_dbus_string_append (&file_path, entry->s_dir->dir_c) ||
1.434 + !_dbus_concat_dir_and_file (&file_path, &filename))
1.435 + {
1.436 + BUS_SET_OOM (error);
1.437 + retval = FALSE;
1.438 + goto out;
1.439 + }
1.440 +
1.441 + if (!_dbus_stat (&file_path, &stat_buf, NULL))
1.442 + {
1.443 + _dbus_verbose ("****** Can't stat file \"%s\", removing from cache\n",
1.444 + _dbus_string_get_const_data (&file_path));
1.445 +
1.446 + _dbus_hash_table_remove_string (activation->entries, entry->name);
1.447 + _dbus_hash_table_remove_string (entry->s_dir->entries, entry->filename);
1.448 +
1.449 + tmp_entry = NULL;
1.450 + retval = TRUE;
1.451 + goto out;
1.452 + }
1.453 + else
1.454 + {
1.455 + if (stat_buf.mtime > entry->mtime)
1.456 + {
1.457 + BusDesktopFile *desktop_file;
1.458 + DBusError tmp_error;
1.459 +
1.460 + dbus_error_init (&tmp_error);
1.461 +
1.462 + desktop_file = bus_desktop_file_load (&file_path, &tmp_error);
1.463 + if (desktop_file == NULL)
1.464 + {
1.465 + _dbus_verbose ("Could not load %s: %s\n",
1.466 + _dbus_string_get_const_data (&file_path),
1.467 + tmp_error.message);
1.468 + if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))
1.469 + {
1.470 + dbus_move_error (&tmp_error, error);
1.471 + retval = FALSE;
1.472 + goto out;
1.473 + }
1.474 + dbus_error_free (&tmp_error);
1.475 + retval = TRUE;
1.476 + goto out;
1.477 + }
1.478 +
1.479 + /* @todo We can return OOM or a DBUS_ERROR_FAILED error
1.480 + * Handle these both better
1.481 + */
1.482 + if (!update_desktop_file_entry (activation, entry->s_dir, &filename, desktop_file, &tmp_error))
1.483 + {
1.484 + bus_desktop_file_free (desktop_file);
1.485 + if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))
1.486 + {
1.487 + dbus_move_error (&tmp_error, error);
1.488 + retval = FALSE;
1.489 + goto out;
1.490 + }
1.491 + dbus_error_free (&tmp_error);
1.492 + retval = TRUE;
1.493 + goto out;
1.494 + }
1.495 +
1.496 + bus_desktop_file_free (desktop_file);
1.497 + retval = TRUE;
1.498 + }
1.499 + }
1.500 +
1.501 +out:
1.502 + _dbus_string_free (&file_path);
1.503 +
1.504 + if (updated_entry != NULL)
1.505 + *updated_entry = tmp_entry;
1.506 + return retval;
1.507 +}
1.508 +
1.509 +
1.510 +/* warning: this doesn't fully "undo" itself on failure, i.e. doesn't strip
1.511 + * hash entries it already added.
1.512 + */
1.513 +static dbus_bool_t
1.514 +update_directory (BusActivation *activation,
1.515 + BusServiceDirectory *s_dir,
1.516 + DBusError *error)
1.517 +{
1.518 + DBusDirIter *iter;
1.519 + DBusString dir, filename;
1.520 + BusDesktopFile *desktop_file;
1.521 + DBusError tmp_error;
1.522 + dbus_bool_t retval;
1.523 + BusActivationEntry *entry;
1.524 + DBusString full_path;
1.525 +
1.526 + _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1.527 +
1.528 + iter = NULL;
1.529 + desktop_file = NULL;
1.530 +
1.531 + _dbus_string_init_const (&dir, s_dir->dir_c);
1.532 +
1.533 + if (!_dbus_string_init (&filename))
1.534 + {
1.535 + BUS_SET_OOM (error);
1.536 + return FALSE;
1.537 + }
1.538 +
1.539 + if (!_dbus_string_init (&full_path))
1.540 + {
1.541 + BUS_SET_OOM (error);
1.542 + _dbus_string_free (&filename);
1.543 + return FALSE;
1.544 + }
1.545 +
1.546 + retval = FALSE;
1.547 +
1.548 + /* from this point it's safe to "goto out" */
1.549 +
1.550 + iter = _dbus_directory_open (&dir, error);
1.551 + if (iter == NULL)
1.552 + {
1.553 + _dbus_verbose ("Failed to open directory %s: %s\n",
1.554 + s_dir->dir_c,
1.555 + error ? error->message : "unknown");
1.556 + goto out;
1.557 + }
1.558 +
1.559 + /* Now read the files */
1.560 + dbus_error_init (&tmp_error);
1.561 + while (_dbus_directory_get_next_file (iter, &filename, &tmp_error))
1.562 + {
1.563 + _dbus_assert (!dbus_error_is_set (&tmp_error));
1.564 +
1.565 + _dbus_string_set_length (&full_path, 0);
1.566 +
1.567 + if (!_dbus_string_ends_with_c_str (&filename, ".service"))
1.568 + {
1.569 + _dbus_verbose ("Skipping non-.service file %s\n",
1.570 + _dbus_string_get_const_data (&filename));
1.571 + continue;
1.572 + }
1.573 +
1.574 + entry = _dbus_hash_table_lookup_string (s_dir->entries, _dbus_string_get_const_data (&filename));
1.575 + if (entry) /* Already has this service file in the cache */
1.576 + {
1.577 + if (!check_service_file (activation, entry, NULL, error))
1.578 + goto out;
1.579 +
1.580 + continue;
1.581 + }
1.582 +
1.583 + if (!_dbus_string_append (&full_path, s_dir->dir_c) ||
1.584 + !_dbus_concat_dir_and_file (&full_path, &filename))
1.585 + {
1.586 + BUS_SET_OOM (error);
1.587 + goto out;
1.588 + }
1.589 +
1.590 + /* New file */
1.591 + desktop_file = bus_desktop_file_load (&full_path, &tmp_error);
1.592 + if (desktop_file == NULL)
1.593 + {
1.594 + _dbus_verbose ("Could not load %s: %s\n",
1.595 + _dbus_string_get_const_data (&full_path),
1.596 + tmp_error.message);
1.597 +
1.598 + if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))
1.599 + {
1.600 + dbus_move_error (&tmp_error, error);
1.601 + goto out;
1.602 + }
1.603 +
1.604 + dbus_error_free (&tmp_error);
1.605 + continue;
1.606 + }
1.607 +
1.608 + /* @todo We can return OOM or a DBUS_ERROR_FAILED error
1.609 + * Handle these both better
1.610 + */
1.611 + if (!update_desktop_file_entry (activation, s_dir, &filename, desktop_file, &tmp_error))
1.612 + {
1.613 + bus_desktop_file_free (desktop_file);
1.614 + desktop_file = NULL;
1.615 +
1.616 + _dbus_verbose ("Could not add %s to activation entry list: %s\n",
1.617 + _dbus_string_get_const_data (&full_path), tmp_error.message);
1.618 +
1.619 + if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))
1.620 + {
1.621 + dbus_move_error (&tmp_error, error);
1.622 + goto out;
1.623 + }
1.624 +
1.625 + dbus_error_free (&tmp_error);
1.626 + continue;
1.627 + }
1.628 + else
1.629 + {
1.630 + bus_desktop_file_free (desktop_file);
1.631 + desktop_file = NULL;
1.632 + continue;
1.633 + }
1.634 + }
1.635 +
1.636 + if (dbus_error_is_set (&tmp_error))
1.637 + {
1.638 + dbus_move_error (&tmp_error, error);
1.639 + goto out;
1.640 + }
1.641 +
1.642 + retval = TRUE;
1.643 +
1.644 + out:
1.645 + if (!retval)
1.646 + _DBUS_ASSERT_ERROR_IS_SET (error);
1.647 + else
1.648 + _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1.649 +
1.650 + if (iter != NULL)
1.651 + _dbus_directory_close (iter);
1.652 + _dbus_string_free (&filename);
1.653 + _dbus_string_free (&full_path);
1.654 +
1.655 + return retval;
1.656 +}
1.657 +
1.658 +BusActivation*
1.659 +bus_activation_new (BusContext *context,
1.660 + const DBusString *address,
1.661 + DBusList **directories,
1.662 + DBusError *error)
1.663 +{
1.664 + BusActivation *activation;
1.665 + DBusList *link;
1.666 + char *dir;
1.667 +
1.668 + _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1.669 +
1.670 + activation = dbus_new0 (BusActivation, 1);
1.671 + if (activation == NULL)
1.672 + {
1.673 + BUS_SET_OOM (error);
1.674 + return NULL;
1.675 + }
1.676 +
1.677 + activation->refcount = 1;
1.678 + activation->context = context;
1.679 + activation->n_pending_activations = 0;
1.680 +
1.681 + if (!_dbus_string_copy_data (address, &activation->server_address))
1.682 + {
1.683 + BUS_SET_OOM (error);
1.684 + goto failed;
1.685 + }
1.686 +
1.687 + activation->entries = _dbus_hash_table_new (DBUS_HASH_STRING, NULL,
1.688 + (DBusFreeFunction)bus_activation_entry_unref);
1.689 + if (activation->entries == NULL)
1.690 + {
1.691 + BUS_SET_OOM (error);
1.692 + goto failed;
1.693 + }
1.694 +
1.695 + activation->pending_activations = _dbus_hash_table_new (DBUS_HASH_STRING, NULL,
1.696 + (DBusFreeFunction)bus_pending_activation_unref);
1.697 +
1.698 + if (activation->pending_activations == NULL)
1.699 + {
1.700 + BUS_SET_OOM (error);
1.701 + goto failed;
1.702 + }
1.703 +
1.704 + activation->directories = _dbus_hash_table_new (DBUS_HASH_STRING, NULL,
1.705 + (DBusFreeFunction)bus_service_directory_unref);
1.706 +
1.707 + if (activation->directories == NULL)
1.708 + {
1.709 + BUS_SET_OOM (error);
1.710 + goto failed;
1.711 + }
1.712 +
1.713 + /* Load service files */
1.714 + link = _dbus_list_get_first_link (directories);
1.715 + while (link != NULL)
1.716 + {
1.717 + BusServiceDirectory *s_dir;
1.718 +
1.719 + dir = _dbus_strdup ((const char *) link->data);
1.720 + if (!dir)
1.721 + {
1.722 + BUS_SET_OOM (error);
1.723 + goto failed;
1.724 + }
1.725 +
1.726 + s_dir = dbus_new0 (BusServiceDirectory, 1);
1.727 + if (!s_dir)
1.728 + {
1.729 + dbus_free (dir);
1.730 + BUS_SET_OOM (error);
1.731 + goto failed;
1.732 + }
1.733 +
1.734 + s_dir->refcount = 1;
1.735 + s_dir->dir_c = dir;
1.736 +
1.737 + s_dir->entries = _dbus_hash_table_new (DBUS_HASH_STRING, NULL,
1.738 + (DBusFreeFunction)bus_activation_entry_unref);
1.739 +
1.740 + if (!s_dir->entries)
1.741 + {
1.742 + bus_service_directory_unref (s_dir);
1.743 + BUS_SET_OOM (error);
1.744 + goto failed;
1.745 + }
1.746 +
1.747 + if (!_dbus_hash_table_insert_string (activation->directories, s_dir->dir_c, s_dir))
1.748 + {
1.749 + bus_service_directory_unref (s_dir);
1.750 + BUS_SET_OOM (error);
1.751 + goto failed;
1.752 + }
1.753 +
1.754 + /* only fail on OOM, it is ok if we can't read the directory */
1.755 + if (!update_directory (activation, s_dir, error))
1.756 + {
1.757 + if (dbus_error_has_name (error, DBUS_ERROR_NO_MEMORY))
1.758 + goto failed;
1.759 + else
1.760 + dbus_error_free (error);
1.761 + }
1.762 +
1.763 + link = _dbus_list_get_next_link (directories, link);
1.764 + }
1.765 +
1.766 + return activation;
1.767 +
1.768 + failed:
1.769 + bus_activation_unref (activation);
1.770 + return NULL;
1.771 +}
1.772 +
1.773 +BusActivation *
1.774 +bus_activation_ref (BusActivation *activation)
1.775 +{
1.776 + _dbus_assert (activation->refcount > 0);
1.777 +
1.778 + activation->refcount += 1;
1.779 +
1.780 + return activation;
1.781 +}
1.782 +
1.783 +void
1.784 +bus_activation_unref (BusActivation *activation)
1.785 +{
1.786 + _dbus_assert (activation->refcount > 0);
1.787 +
1.788 + activation->refcount -= 1;
1.789 +
1.790 + if (activation->refcount > 0)
1.791 + return;
1.792 +
1.793 + dbus_free (activation->server_address);
1.794 + if (activation->entries)
1.795 + _dbus_hash_table_unref (activation->entries);
1.796 + if (activation->pending_activations)
1.797 + _dbus_hash_table_unref (activation->pending_activations);
1.798 + if (activation->directories)
1.799 + _dbus_hash_table_unref (activation->directories);
1.800 +
1.801 + dbus_free (activation);
1.802 +}
1.803 +
1.804 +static void
1.805 +child_setup (void *data)
1.806 +{
1.807 + BusActivation *activation = data;
1.808 + const char *type;
1.809 +
1.810 + /* If no memory, we simply have the child exit, so it won't try
1.811 + * to connect to the wrong thing.
1.812 + */
1.813 + if (!_dbus_setenv ("DBUS_STARTER_ADDRESS", activation->server_address))
1.814 + _dbus_exit (1);
1.815 +
1.816 + type = bus_context_get_type (activation->context);
1.817 + if (type != NULL)
1.818 + {
1.819 + if (!_dbus_setenv ("DBUS_STARTER_BUS_TYPE", type))
1.820 + _dbus_exit (1);
1.821 +
1.822 + if (strcmp (type, "session") == 0)
1.823 + {
1.824 + if (!_dbus_setenv ("DBUS_SESSION_BUS_ADDRESS",
1.825 + activation->server_address))
1.826 + _dbus_exit (1);
1.827 + }
1.828 + else if (strcmp (type, "system") == 0)
1.829 + {
1.830 + if (!_dbus_setenv ("DBUS_SYSTEM_BUS_ADDRESS",
1.831 + activation->server_address))
1.832 + _dbus_exit (1);
1.833 + }
1.834 + }
1.835 +}
1.836 +
1.837 +typedef struct
1.838 +{
1.839 + BusPendingActivation *pending_activation;
1.840 + DBusPreallocatedHash *hash_entry;
1.841 +} RestorePendingData;
1.842 +
1.843 +static void
1.844 +restore_pending (void *data)
1.845 +{
1.846 + RestorePendingData *d = data;
1.847 +
1.848 + _dbus_assert (d->pending_activation != NULL);
1.849 + _dbus_assert (d->hash_entry != NULL);
1.850 +
1.851 + _dbus_verbose ("Restoring pending activation for service %s, has timeout = %d\n",
1.852 + d->pending_activation->service_name,
1.853 + d->pending_activation->timeout_added);
1.854 +
1.855 + _dbus_hash_table_insert_string_preallocated (d->pending_activation->activation->pending_activations,
1.856 + d->hash_entry,
1.857 + d->pending_activation->service_name, d->pending_activation);
1.858 +
1.859 + bus_pending_activation_ref (d->pending_activation);
1.860 +
1.861 + d->hash_entry = NULL;
1.862 +}
1.863 +
1.864 +static void
1.865 +free_pending_restore_data (void *data)
1.866 +{
1.867 + RestorePendingData *d = data;
1.868 +
1.869 + if (d->hash_entry)
1.870 + _dbus_hash_table_free_preallocated_entry (d->pending_activation->activation->pending_activations,
1.871 + d->hash_entry);
1.872 +
1.873 + bus_pending_activation_unref (d->pending_activation);
1.874 +
1.875 + dbus_free (d);
1.876 +}
1.877 +
1.878 +static dbus_bool_t
1.879 +add_restore_pending_to_transaction (BusTransaction *transaction,
1.880 + BusPendingActivation *pending_activation)
1.881 +{
1.882 + RestorePendingData *d;
1.883 +
1.884 + d = dbus_new (RestorePendingData, 1);
1.885 + if (d == NULL)
1.886 + return FALSE;
1.887 +
1.888 + d->pending_activation = pending_activation;
1.889 + d->hash_entry = _dbus_hash_table_preallocate_entry (d->pending_activation->activation->pending_activations);
1.890 +
1.891 + bus_pending_activation_ref (d->pending_activation);
1.892 +
1.893 + if (d->hash_entry == NULL ||
1.894 + !bus_transaction_add_cancel_hook (transaction, restore_pending, d,
1.895 + free_pending_restore_data))
1.896 + {
1.897 + free_pending_restore_data (d);
1.898 + return FALSE;
1.899 + }
1.900 +
1.901 + _dbus_verbose ("Saved pending activation to be restored if the transaction fails\n");
1.902 +
1.903 + return TRUE;
1.904 +}
1.905 +
1.906 +dbus_bool_t
1.907 +bus_activation_service_created (BusActivation *activation,
1.908 + const char *service_name,
1.909 + BusTransaction *transaction,
1.910 + DBusError *error)
1.911 +{
1.912 + BusPendingActivation *pending_activation;
1.913 + DBusMessage *message;
1.914 + DBusList *link;
1.915 +
1.916 + _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1.917 +
1.918 + /* Check if it's a pending activation */
1.919 + pending_activation = _dbus_hash_table_lookup_string (activation->pending_activations, service_name);
1.920 +
1.921 + if (!pending_activation)
1.922 + return TRUE;
1.923 +
1.924 + link = _dbus_list_get_first_link (&pending_activation->entries);
1.925 + while (link != NULL)
1.926 + {
1.927 + BusPendingActivationEntry *entry = link->data;
1.928 + DBusList *next = _dbus_list_get_next_link (&pending_activation->entries, link);
1.929 +
1.930 + if (dbus_connection_get_is_connected (entry->connection))
1.931 + {
1.932 + /* Only send activation replies to regular activation requests. */
1.933 + if (!entry->auto_activation)
1.934 + {
1.935 + dbus_uint32_t result;
1.936 +
1.937 + message = dbus_message_new_method_return (entry->activation_message);
1.938 + if (!message)
1.939 + {
1.940 + BUS_SET_OOM (error);
1.941 + goto error;
1.942 + }
1.943 +
1.944 + result = DBUS_START_REPLY_SUCCESS;
1.945 +
1.946 + if (!dbus_message_append_args (message,
1.947 + DBUS_TYPE_UINT32, &result,
1.948 + DBUS_TYPE_INVALID))
1.949 + {
1.950 + dbus_message_unref (message);
1.951 + BUS_SET_OOM (error);
1.952 + goto error;
1.953 + }
1.954 +
1.955 + if (!bus_transaction_send_from_driver (transaction, entry->connection, message))
1.956 + {
1.957 + dbus_message_unref (message);
1.958 + BUS_SET_OOM (error);
1.959 + goto error;
1.960 + }
1.961 +
1.962 + dbus_message_unref (message);
1.963 + }
1.964 + }
1.965 +
1.966 + link = next;
1.967 + }
1.968 +
1.969 + return TRUE;
1.970 +
1.971 + error:
1.972 + return FALSE;
1.973 +}
1.974 +
1.975 +dbus_bool_t
1.976 +bus_activation_send_pending_auto_activation_messages (BusActivation *activation,
1.977 + BusService *service,
1.978 + BusTransaction *transaction,
1.979 + DBusError *error)
1.980 +{
1.981 + BusPendingActivation *pending_activation;
1.982 + DBusList *link;
1.983 +
1.984 + _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1.985 +
1.986 + /* Check if it's a pending activation */
1.987 + pending_activation = _dbus_hash_table_lookup_string (activation->pending_activations,
1.988 + bus_service_get_name (service));
1.989 +
1.990 + if (!pending_activation)
1.991 + return TRUE;
1.992 +
1.993 + link = _dbus_list_get_first_link (&pending_activation->entries);
1.994 + while (link != NULL)
1.995 + {
1.996 + BusPendingActivationEntry *entry = link->data;
1.997 + DBusList *next = _dbus_list_get_next_link (&pending_activation->entries, link);
1.998 +
1.999 + if (entry->auto_activation && dbus_connection_get_is_connected (entry->connection))
1.1000 + {
1.1001 + DBusConnection *addressed_recipient;
1.1002 +
1.1003 + addressed_recipient = bus_service_get_primary_owners_connection (service);
1.1004 +
1.1005 + /* Check the security policy, which has the side-effect of adding an
1.1006 + * expected pending reply.
1.1007 + */
1.1008 + if (!bus_context_check_security_policy (activation->context, transaction,
1.1009 + entry->connection,
1.1010 + addressed_recipient,
1.1011 + addressed_recipient,
1.1012 + entry->activation_message, error))
1.1013 + goto error;
1.1014 +
1.1015 + if (!bus_transaction_send (transaction, addressed_recipient, entry->activation_message))
1.1016 + {
1.1017 + BUS_SET_OOM (error);
1.1018 + goto error;
1.1019 + }
1.1020 + }
1.1021 +
1.1022 + link = next;
1.1023 + }
1.1024 +
1.1025 + if (!add_restore_pending_to_transaction (transaction, pending_activation))
1.1026 + {
1.1027 + _dbus_verbose ("Could not add cancel hook to transaction to revert removing pending activation\n");
1.1028 + BUS_SET_OOM (error);
1.1029 + goto error;
1.1030 + }
1.1031 +
1.1032 + _dbus_hash_table_remove_string (activation->pending_activations, bus_service_get_name (service));
1.1033 +
1.1034 + return TRUE;
1.1035 +
1.1036 + error:
1.1037 + return FALSE;
1.1038 +}
1.1039 +
1.1040 +/**
1.1041 + * FIXME @todo the error messages here would ideally be preallocated
1.1042 + * so we don't need to allocate memory to send them.
1.1043 + * Using the usual tactic, prealloc an OOM message, then
1.1044 + * if we can't alloc the real error send the OOM error instead.
1.1045 + */
1.1046 +static dbus_bool_t
1.1047 +try_send_activation_failure (BusPendingActivation *pending_activation,
1.1048 + const DBusError *how)
1.1049 +{
1.1050 + BusActivation *activation;
1.1051 + DBusList *link;
1.1052 + BusTransaction *transaction;
1.1053 +
1.1054 + activation = pending_activation->activation;
1.1055 +
1.1056 + transaction = bus_transaction_new (activation->context);
1.1057 + if (transaction == NULL)
1.1058 + return FALSE;
1.1059 +
1.1060 + link = _dbus_list_get_first_link (&pending_activation->entries);
1.1061 + while (link != NULL)
1.1062 + {
1.1063 + BusPendingActivationEntry *entry = link->data;
1.1064 + DBusList *next = _dbus_list_get_next_link (&pending_activation->entries, link);
1.1065 +
1.1066 + if (dbus_connection_get_is_connected (entry->connection))
1.1067 + {
1.1068 + if (!bus_transaction_send_error_reply (transaction,
1.1069 + entry->connection,
1.1070 + how,
1.1071 + entry->activation_message))
1.1072 + goto error;
1.1073 + }
1.1074 +
1.1075 + link = next;
1.1076 + }
1.1077 +
1.1078 + bus_transaction_execute_and_free (transaction);
1.1079 +
1.1080 + return TRUE;
1.1081 +
1.1082 + error:
1.1083 + if (transaction)
1.1084 + bus_transaction_cancel_and_free (transaction);
1.1085 + return FALSE;
1.1086 +}
1.1087 +
1.1088 +/**
1.1089 + * Free the pending activation and send an error message to all the
1.1090 + * connections that were waiting for it.
1.1091 + */
1.1092 +static void
1.1093 +pending_activation_failed (BusPendingActivation *pending_activation,
1.1094 + const DBusError *how)
1.1095 +{
1.1096 + /* FIXME use preallocated OOM messages instead of bus_wait_for_memory() */
1.1097 + while (!try_send_activation_failure (pending_activation, how))
1.1098 + _dbus_wait_for_memory ();
1.1099 +
1.1100 + /* Destroy this pending activation */
1.1101 + _dbus_hash_table_remove_string (pending_activation->activation->pending_activations,
1.1102 + pending_activation->service_name);
1.1103 +}
1.1104 +
1.1105 +static dbus_bool_t
1.1106 +babysitter_watch_callback (DBusWatch *watch,
1.1107 + unsigned int condition,
1.1108 + void *data)
1.1109 +{
1.1110 + BusPendingActivation *pending_activation = data;
1.1111 + dbus_bool_t retval;
1.1112 + DBusBabysitter *babysitter;
1.1113 +
1.1114 + babysitter = pending_activation->babysitter;
1.1115 +
1.1116 + _dbus_babysitter_ref (babysitter);
1.1117 +
1.1118 + retval = dbus_watch_handle (watch, condition);
1.1119 +
1.1120 + /* FIXME this is broken in the same way that
1.1121 + * connection watches used to be; there should be
1.1122 + * a separate callback for status change, instead
1.1123 + * of doing "if we handled a watch status might
1.1124 + * have changed"
1.1125 + *
1.1126 + * Fixing this lets us move dbus_watch_handle
1.1127 + * calls into dbus-mainloop.c
1.1128 + */
1.1129 +
1.1130 + if (_dbus_babysitter_get_child_exited (babysitter))
1.1131 + {
1.1132 + DBusError error;
1.1133 + DBusHashIter iter;
1.1134 +
1.1135 + dbus_error_init (&error);
1.1136 + _dbus_babysitter_set_child_exit_error (babysitter, &error);
1.1137 +
1.1138 + /* Destroy all pending activations with the same exec */
1.1139 + _dbus_hash_iter_init (pending_activation->activation->pending_activations,
1.1140 + &iter);
1.1141 + while (_dbus_hash_iter_next (&iter))
1.1142 + {
1.1143 + BusPendingActivation *p = _dbus_hash_iter_get_value (&iter);
1.1144 +
1.1145 + if (p != pending_activation && strcmp (p->exec, pending_activation->exec) == 0)
1.1146 + pending_activation_failed (p, &error);
1.1147 + }
1.1148 +
1.1149 + /* Destroys the pending activation */
1.1150 + pending_activation_failed (pending_activation, &error);
1.1151 +
1.1152 + dbus_error_free (&error);
1.1153 + }
1.1154 +
1.1155 + _dbus_babysitter_unref (babysitter);
1.1156 +
1.1157 + return retval;
1.1158 +}
1.1159 +
1.1160 +static dbus_bool_t
1.1161 +add_babysitter_watch (DBusWatch *watch,
1.1162 + void *data)
1.1163 +{
1.1164 + BusPendingActivation *pending_activation = data;
1.1165 +
1.1166 + return _dbus_loop_add_watch (bus_context_get_loop (pending_activation->activation->context),
1.1167 + watch, babysitter_watch_callback, pending_activation,
1.1168 + NULL);
1.1169 +}
1.1170 +
1.1171 +static void
1.1172 +remove_babysitter_watch (DBusWatch *watch,
1.1173 + void *data)
1.1174 +{
1.1175 + BusPendingActivation *pending_activation = data;
1.1176 +
1.1177 + _dbus_loop_remove_watch (bus_context_get_loop (pending_activation->activation->context),
1.1178 + watch, babysitter_watch_callback, pending_activation);
1.1179 +}
1.1180 +
1.1181 +static dbus_bool_t
1.1182 +pending_activation_timed_out (void *data)
1.1183 +{
1.1184 + BusPendingActivation *pending_activation = data;
1.1185 + DBusError error;
1.1186 +
1.1187 + /* Kill the spawned process, since it sucks
1.1188 + * (not sure this is what we want to do, but
1.1189 + * may as well try it for now)
1.1190 + */
1.1191 + if (pending_activation->babysitter)
1.1192 + _dbus_babysitter_kill_child (pending_activation->babysitter);
1.1193 +
1.1194 + dbus_error_init (&error);
1.1195 +
1.1196 + dbus_set_error (&error, DBUS_ERROR_TIMED_OUT,
1.1197 + "Activation of %s timed out",
1.1198 + pending_activation->service_name);
1.1199 +
1.1200 + pending_activation_failed (pending_activation, &error);
1.1201 +
1.1202 + dbus_error_free (&error);
1.1203 +
1.1204 + return TRUE;
1.1205 +}
1.1206 +
1.1207 +static void
1.1208 +cancel_pending (void *data)
1.1209 +{
1.1210 + BusPendingActivation *pending_activation = data;
1.1211 +
1.1212 + _dbus_verbose ("Canceling pending activation of %s\n",
1.1213 + pending_activation->service_name);
1.1214 +
1.1215 + if (pending_activation->babysitter)
1.1216 + _dbus_babysitter_kill_child (pending_activation->babysitter);
1.1217 +
1.1218 + _dbus_hash_table_remove_string (pending_activation->activation->pending_activations,
1.1219 + pending_activation->service_name);
1.1220 +}
1.1221 +
1.1222 +static void
1.1223 +free_pending_cancel_data (void *data)
1.1224 +{
1.1225 + BusPendingActivation *pending_activation = data;
1.1226 +
1.1227 + bus_pending_activation_unref (pending_activation);
1.1228 +}
1.1229 +
1.1230 +static dbus_bool_t
1.1231 +add_cancel_pending_to_transaction (BusTransaction *transaction,
1.1232 + BusPendingActivation *pending_activation)
1.1233 +{
1.1234 + if (!bus_transaction_add_cancel_hook (transaction, cancel_pending,
1.1235 + pending_activation,
1.1236 + free_pending_cancel_data))
1.1237 + return FALSE;
1.1238 +
1.1239 + bus_pending_activation_ref (pending_activation);
1.1240 +
1.1241 + _dbus_verbose ("Saved pending activation to be canceled if the transaction fails\n");
1.1242 +
1.1243 + return TRUE;
1.1244 +}
1.1245 +
1.1246 +static dbus_bool_t
1.1247 +update_service_cache (BusActivation *activation, DBusError *error)
1.1248 +{
1.1249 + DBusHashIter iter;
1.1250 +
1.1251 + _dbus_hash_iter_init (activation->directories, &iter);
1.1252 + while (_dbus_hash_iter_next (&iter))
1.1253 + {
1.1254 + DBusError tmp_error;
1.1255 + BusServiceDirectory *s_dir;
1.1256 +
1.1257 + s_dir = _dbus_hash_iter_get_value (&iter);
1.1258 +
1.1259 + dbus_error_init (&tmp_error);
1.1260 + if (!update_directory (activation, s_dir, &tmp_error))
1.1261 + {
1.1262 + if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY))
1.1263 + {
1.1264 + dbus_move_error (&tmp_error, error);
1.1265 + return FALSE;
1.1266 + }
1.1267 +
1.1268 + dbus_error_free (&tmp_error);
1.1269 + continue;
1.1270 + }
1.1271 + }
1.1272 +
1.1273 + return TRUE;
1.1274 +}
1.1275 +
1.1276 +static BusActivationEntry *
1.1277 +activation_find_entry (BusActivation *activation,
1.1278 + const char *service_name,
1.1279 + DBusError *error)
1.1280 +{
1.1281 + BusActivationEntry *entry;
1.1282 +
1.1283 + entry = _dbus_hash_table_lookup_string (activation->entries, service_name);
1.1284 + if (!entry)
1.1285 + {
1.1286 + if (!update_service_cache (activation, error))
1.1287 + return NULL;
1.1288 +
1.1289 + entry = _dbus_hash_table_lookup_string (activation->entries,
1.1290 + service_name);
1.1291 + }
1.1292 + else
1.1293 + {
1.1294 + BusActivationEntry *updated_entry;
1.1295 +
1.1296 + if (!check_service_file (activation, entry, &updated_entry, error))
1.1297 + return NULL;
1.1298 +
1.1299 + entry = updated_entry;
1.1300 + }
1.1301 +
1.1302 + if (!entry)
1.1303 + {
1.1304 + dbus_set_error (error, DBUS_ERROR_SERVICE_UNKNOWN,
1.1305 + "The name %s was not provided by any .service files",
1.1306 + service_name);
1.1307 + return NULL;
1.1308 + }
1.1309 +
1.1310 + return entry;
1.1311 +}
1.1312 +
1.1313 +dbus_bool_t
1.1314 +bus_activation_activate_service (BusActivation *activation,
1.1315 + DBusConnection *connection,
1.1316 + BusTransaction *transaction,
1.1317 + dbus_bool_t auto_activation,
1.1318 + DBusMessage *activation_message,
1.1319 + const char *service_name,
1.1320 + DBusError *error)
1.1321 +{
1.1322 + BusActivationEntry *entry;
1.1323 + BusPendingActivation *pending_activation;
1.1324 + BusPendingActivationEntry *pending_activation_entry;
1.1325 + DBusMessage *message;
1.1326 + DBusString service_str;
1.1327 + char **argv;
1.1328 + int argc;
1.1329 + dbus_bool_t retval;
1.1330 + DBusHashIter iter;
1.1331 + dbus_bool_t activated;
1.1332 +
1.1333 + activated = TRUE;
1.1334 +
1.1335 + _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1.1336 +
1.1337 + if (activation->n_pending_activations >=
1.1338 + bus_context_get_max_pending_activations (activation->context))
1.1339 + {
1.1340 + dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,
1.1341 + "The maximum number of pending activations has been reached, activation of %s failed",
1.1342 + service_name);
1.1343 + return FALSE;
1.1344 + }
1.1345 +
1.1346 + entry = activation_find_entry (activation, service_name, error);
1.1347 + if (!entry)
1.1348 + return FALSE;
1.1349 +
1.1350 + /* Bypass the registry lookup if we're auto-activating, bus_dispatch would not
1.1351 + * call us if the service is already active.
1.1352 + */
1.1353 + if (!auto_activation)
1.1354 + {
1.1355 + /* Check if the service is active */
1.1356 + _dbus_string_init_const (&service_str, service_name);
1.1357 + if (bus_registry_lookup (bus_context_get_registry (activation->context), &service_str) != NULL)
1.1358 + {
1.1359 + dbus_uint32_t result;
1.1360 +
1.1361 + _dbus_verbose ("Service \"%s\" is already active\n", service_name);
1.1362 +
1.1363 + message = dbus_message_new_method_return (activation_message);
1.1364 +
1.1365 + if (!message)
1.1366 + {
1.1367 + _dbus_verbose ("No memory to create reply to activate message\n");
1.1368 + BUS_SET_OOM (error);
1.1369 + return FALSE;
1.1370 + }
1.1371 +
1.1372 + result = DBUS_START_REPLY_ALREADY_RUNNING;
1.1373 +
1.1374 + if (!dbus_message_append_args (message,
1.1375 + DBUS_TYPE_UINT32, &result,
1.1376 + DBUS_TYPE_INVALID))
1.1377 + {
1.1378 + _dbus_verbose ("No memory to set args of reply to activate message\n");
1.1379 + BUS_SET_OOM (error);
1.1380 + dbus_message_unref (message);
1.1381 + return FALSE;
1.1382 + }
1.1383 +
1.1384 + retval = bus_transaction_send_from_driver (transaction, connection, message);
1.1385 + dbus_message_unref (message);
1.1386 + if (!retval)
1.1387 + {
1.1388 + _dbus_verbose ("Failed to send reply\n");
1.1389 + BUS_SET_OOM (error);
1.1390 + }
1.1391 +
1.1392 + return retval;
1.1393 + }
1.1394 + }
1.1395 +
1.1396 + pending_activation_entry = dbus_new0 (BusPendingActivationEntry, 1);
1.1397 + if (!pending_activation_entry)
1.1398 + {
1.1399 + _dbus_verbose ("Failed to create pending activation entry\n");
1.1400 + BUS_SET_OOM (error);
1.1401 + return FALSE;
1.1402 + }
1.1403 +
1.1404 + pending_activation_entry->auto_activation = auto_activation;
1.1405 +
1.1406 + pending_activation_entry->activation_message = activation_message;
1.1407 + dbus_message_ref (activation_message);
1.1408 + pending_activation_entry->connection = connection;
1.1409 + dbus_connection_ref (connection);
1.1410 +
1.1411 + /* Check if the service is being activated */
1.1412 + pending_activation = _dbus_hash_table_lookup_string (activation->pending_activations, service_name);
1.1413 + if (pending_activation)
1.1414 + {
1.1415 + if (!_dbus_list_append (&pending_activation->entries, pending_activation_entry))
1.1416 + {
1.1417 + _dbus_verbose ("Failed to append a new entry to pending activation\n");
1.1418 +
1.1419 + BUS_SET_OOM (error);
1.1420 + bus_pending_activation_entry_free (pending_activation_entry);
1.1421 + return FALSE;
1.1422 + }
1.1423 +
1.1424 + pending_activation->n_entries += 1;
1.1425 + pending_activation->activation->n_pending_activations += 1;
1.1426 + }
1.1427 + else
1.1428 + {
1.1429 + pending_activation = dbus_new0 (BusPendingActivation, 1);
1.1430 + if (!pending_activation)
1.1431 + {
1.1432 + _dbus_verbose ("Failed to create pending activation\n");
1.1433 +
1.1434 + BUS_SET_OOM (error);
1.1435 + bus_pending_activation_entry_free (pending_activation_entry);
1.1436 + return FALSE;
1.1437 + }
1.1438 +
1.1439 + pending_activation->activation = activation;
1.1440 + pending_activation->refcount = 1;
1.1441 +
1.1442 + pending_activation->service_name = _dbus_strdup (service_name);
1.1443 + if (!pending_activation->service_name)
1.1444 + {
1.1445 + _dbus_verbose ("Failed to copy service name for pending activation\n");
1.1446 +
1.1447 + BUS_SET_OOM (error);
1.1448 + bus_pending_activation_unref (pending_activation);
1.1449 + bus_pending_activation_entry_free (pending_activation_entry);
1.1450 + return FALSE;
1.1451 + }
1.1452 +
1.1453 + pending_activation->exec = _dbus_strdup (entry->exec);
1.1454 + if (!pending_activation->exec)
1.1455 + {
1.1456 + _dbus_verbose ("Failed to copy service exec for pending activation\n");
1.1457 + BUS_SET_OOM (error);
1.1458 + bus_pending_activation_unref (pending_activation);
1.1459 + bus_pending_activation_entry_free (pending_activation_entry);
1.1460 + return FALSE;
1.1461 + }
1.1462 +
1.1463 + pending_activation->timeout =
1.1464 + _dbus_timeout_new (bus_context_get_activation_timeout (activation->context),
1.1465 + pending_activation_timed_out,
1.1466 + pending_activation,
1.1467 + NULL);
1.1468 + if (!pending_activation->timeout)
1.1469 + {
1.1470 + _dbus_verbose ("Failed to create timeout for pending activation\n");
1.1471 +
1.1472 + BUS_SET_OOM (error);
1.1473 + bus_pending_activation_unref (pending_activation);
1.1474 + bus_pending_activation_entry_free (pending_activation_entry);
1.1475 + return FALSE;
1.1476 + }
1.1477 +
1.1478 + if (!_dbus_loop_add_timeout (bus_context_get_loop (activation->context),
1.1479 + pending_activation->timeout,
1.1480 + handle_timeout_callback,
1.1481 + pending_activation,
1.1482 + NULL))
1.1483 + {
1.1484 + _dbus_verbose ("Failed to add timeout for pending activation\n");
1.1485 +
1.1486 + BUS_SET_OOM (error);
1.1487 + bus_pending_activation_unref (pending_activation);
1.1488 + bus_pending_activation_entry_free (pending_activation_entry);
1.1489 + return FALSE;
1.1490 + }
1.1491 +
1.1492 + pending_activation->timeout_added = TRUE;
1.1493 +
1.1494 + if (!_dbus_list_append (&pending_activation->entries, pending_activation_entry))
1.1495 + {
1.1496 + _dbus_verbose ("Failed to add entry to just-created pending activation\n");
1.1497 +
1.1498 + BUS_SET_OOM (error);
1.1499 + bus_pending_activation_unref (pending_activation);
1.1500 + bus_pending_activation_entry_free (pending_activation_entry);
1.1501 + return FALSE;
1.1502 + }
1.1503 +
1.1504 + pending_activation->n_entries += 1;
1.1505 + pending_activation->activation->n_pending_activations += 1;
1.1506 +
1.1507 + activated = FALSE;
1.1508 + _dbus_hash_iter_init (activation->pending_activations, &iter);
1.1509 + while (_dbus_hash_iter_next (&iter))
1.1510 + {
1.1511 + BusPendingActivation *p = _dbus_hash_iter_get_value (&iter);
1.1512 +
1.1513 + if (strcmp (p->exec, entry->exec) == 0)
1.1514 + {
1.1515 + activated = TRUE;
1.1516 + break;
1.1517 + }
1.1518 + }
1.1519 +
1.1520 + if (!_dbus_hash_table_insert_string (activation->pending_activations,
1.1521 + pending_activation->service_name,
1.1522 + pending_activation))
1.1523 + {
1.1524 + _dbus_verbose ("Failed to put pending activation in hash table\n");
1.1525 +
1.1526 + BUS_SET_OOM (error);
1.1527 + bus_pending_activation_unref (pending_activation);
1.1528 + return FALSE;
1.1529 + }
1.1530 + }
1.1531 +
1.1532 + if (!add_cancel_pending_to_transaction (transaction, pending_activation))
1.1533 + {
1.1534 + _dbus_verbose ("Failed to add pending activation cancel hook to transaction\n");
1.1535 + BUS_SET_OOM (error);
1.1536 + _dbus_hash_table_remove_string (activation->pending_activations,
1.1537 + pending_activation->service_name);
1.1538 +
1.1539 + return FALSE;
1.1540 + }
1.1541 +
1.1542 + if (activated)
1.1543 + return TRUE;
1.1544 + #ifndef __SYMBIAN32__
1.1545 +
1.1546 + /* Now try to spawn the process */
1.1547 + if (!_dbus_shell_parse_argv (entry->exec, &argc, &argv, error))
1.1548 + {
1.1549 + _dbus_verbose ("Failed to parse command line: %s\n", entry->exec);
1.1550 + _DBUS_ASSERT_ERROR_IS_SET (error);
1.1551 +
1.1552 + _dbus_hash_table_remove_string (activation->pending_activations,
1.1553 + pending_activation->service_name);
1.1554 +
1.1555 + return FALSE;
1.1556 + }
1.1557 +
1.1558 + _dbus_verbose ("Spawning %s ...\n", argv[0]);
1.1559 + #else
1.1560 +
1.1561 + _dbus_verbose ("Spawning %s ...\n", entry->exec);
1.1562 + #endif
1.1563 +
1.1564 + #ifdef __SYMBIAN32__
1.1565 + if (!_dbus_spawn_async_with_babysitter (&pending_activation->babysitter, &entry->exec,
1.1566 + child_setup, activation,
1.1567 + error))
1.1568 + #else
1.1569 + if (!_dbus_spawn_async_with_babysitter (&pending_activation->babysitter, argv,
1.1570 + child_setup, activation,
1.1571 + error))
1.1572 + {
1.1573 + _dbus_verbose ("Failed to spawn child\n");
1.1574 + _DBUS_ASSERT_ERROR_IS_SET (error);
1.1575 + dbus_free_string_array (argv);
1.1576 +
1.1577 + return FALSE;
1.1578 + }
1.1579 +
1.1580 + dbus_free_string_array (argv);
1.1581 +
1.1582 + _dbus_assert (pending_activation->babysitter != NULL);
1.1583 +
1.1584 + if (!_dbus_babysitter_set_watch_functions (pending_activation->babysitter,
1.1585 + add_babysitter_watch,
1.1586 + remove_babysitter_watch,
1.1587 + NULL,
1.1588 + pending_activation,
1.1589 + NULL))
1.1590 + {
1.1591 + BUS_SET_OOM (error);
1.1592 + _dbus_verbose ("Failed to set babysitter watch functions\n");
1.1593 + return FALSE;
1.1594 + }
1.1595 + #endif
1.1596 + return TRUE;
1.1597 +}
1.1598 +
1.1599 +dbus_bool_t
1.1600 +bus_activation_list_services (BusActivation *activation,
1.1601 + char ***listp,
1.1602 + int *array_len)
1.1603 +{
1.1604 + int i, j, len;
1.1605 + char **retval;
1.1606 + DBusHashIter iter;
1.1607 +
1.1608 + len = _dbus_hash_table_get_n_entries (activation->entries);
1.1609 + retval = dbus_new (char *, len + 1);
1.1610 +
1.1611 + if (retval == NULL)
1.1612 + return FALSE;
1.1613 +
1.1614 + _dbus_hash_iter_init (activation->entries, &iter);
1.1615 + i = 0;
1.1616 + while (_dbus_hash_iter_next (&iter))
1.1617 + {
1.1618 + BusActivationEntry *entry = _dbus_hash_iter_get_value (&iter);
1.1619 +
1.1620 + retval[i] = _dbus_strdup (entry->name);
1.1621 + if (retval[i] == NULL)
1.1622 + goto error;
1.1623 +
1.1624 + i++;
1.1625 + }
1.1626 +
1.1627 + retval[i] = NULL;
1.1628 +
1.1629 + if (array_len)
1.1630 + *array_len = len;
1.1631 +
1.1632 + *listp = retval;
1.1633 + return TRUE;
1.1634 +
1.1635 + error:
1.1636 + for (j = 0; j < i; j++)
1.1637 + dbus_free (retval[i]);
1.1638 + dbus_free (retval);
1.1639 +
1.1640 + return FALSE;
1.1641 +}
1.1642 +
1.1643 +
1.1644 +#ifdef DBUS_BUILD_TESTS
1.1645 +
1.1646 +#include <stdio.h>
1.1647 +
1.1648 +#define SERVICE_NAME_1 "MyService1"
1.1649 +#define SERVICE_NAME_2 "MyService2"
1.1650 +#define SERVICE_NAME_3 "MyService3"
1.1651 +
1.1652 +#define SERVICE_FILE_1 "service-1.service"
1.1653 +#define SERVICE_FILE_2 "service-2.service"
1.1654 +#define SERVICE_FILE_3 "service-3.service"
1.1655 +
1.1656 +static dbus_bool_t
1.1657 +test_create_service_file (DBusString *dir,
1.1658 + const char *filename,
1.1659 + const char *name,
1.1660 + const char *exec)
1.1661 +{
1.1662 + DBusString file_name, full_path;
1.1663 + FILE *file;
1.1664 + dbus_bool_t ret_val;
1.1665 +
1.1666 + ret_val = TRUE;
1.1667 + _dbus_string_init_const (&file_name, filename);
1.1668 +
1.1669 + if (!_dbus_string_init (&full_path))
1.1670 + return FALSE;
1.1671 +
1.1672 + if (!_dbus_string_append (&full_path, _dbus_string_get_const_data (dir)) ||
1.1673 + !_dbus_concat_dir_and_file (&full_path, &file_name))
1.1674 + {
1.1675 + ret_val = FALSE;
1.1676 + goto out;
1.1677 + }
1.1678 +
1.1679 + file = fopen (_dbus_string_get_const_data (&full_path), "w");
1.1680 + if (!file)
1.1681 + {
1.1682 + ret_val = FALSE;
1.1683 + goto out;
1.1684 + }
1.1685 +
1.1686 + fprintf (file, "[D-BUS Service]\nName=%s\nExec=%s\n", name, exec);
1.1687 + fclose (file);
1.1688 +
1.1689 +out:
1.1690 + _dbus_string_free (&full_path);
1.1691 + return ret_val;
1.1692 +}
1.1693 +
1.1694 +static dbus_bool_t
1.1695 +test_remove_service_file (DBusString *dir, const char *filename)
1.1696 +{
1.1697 + DBusString file_name, full_path;
1.1698 + dbus_bool_t ret_val;
1.1699 +
1.1700 + ret_val = TRUE;
1.1701 +
1.1702 + _dbus_string_init_const (&file_name, filename);
1.1703 +
1.1704 + if (!_dbus_string_init (&full_path))
1.1705 + return FALSE;
1.1706 +
1.1707 + if (!_dbus_string_append (&full_path, _dbus_string_get_const_data (dir)) ||
1.1708 + !_dbus_concat_dir_and_file (&full_path, &file_name))
1.1709 + {
1.1710 + ret_val = FALSE;
1.1711 + goto out;
1.1712 + }
1.1713 +
1.1714 + if (!_dbus_delete_file (&full_path, NULL))
1.1715 + {
1.1716 + ret_val = FALSE;
1.1717 + goto out;
1.1718 + }
1.1719 +
1.1720 +out:
1.1721 + _dbus_string_free (&full_path);
1.1722 + return ret_val;
1.1723 +}
1.1724 +
1.1725 +static dbus_bool_t
1.1726 +test_remove_directory (DBusString *dir)
1.1727 +{
1.1728 + DBusDirIter *iter;
1.1729 + DBusString filename, full_path;
1.1730 + dbus_bool_t ret_val;
1.1731 +
1.1732 + ret_val = TRUE;
1.1733 +
1.1734 + if (!_dbus_string_init (&filename))
1.1735 + return FALSE;
1.1736 +
1.1737 + if (!_dbus_string_init (&full_path))
1.1738 + {
1.1739 + _dbus_string_free (&filename);
1.1740 + return FALSE;
1.1741 + }
1.1742 +
1.1743 + iter = _dbus_directory_open (dir, NULL);
1.1744 + if (iter == NULL)
1.1745 + {
1.1746 + ret_val = FALSE;
1.1747 + goto out;
1.1748 + }
1.1749 +
1.1750 + while (_dbus_directory_get_next_file (iter, &filename, NULL))
1.1751 + {
1.1752 + if (!test_remove_service_file (dir, _dbus_string_get_const_data (&filename)))
1.1753 + {
1.1754 + ret_val = FALSE;
1.1755 + goto out;
1.1756 + }
1.1757 + }
1.1758 + _dbus_directory_close (iter);
1.1759 +
1.1760 + if (!_dbus_delete_directory (dir, NULL))
1.1761 + {
1.1762 + ret_val = FALSE;
1.1763 + goto out;
1.1764 + }
1.1765 +
1.1766 +out:
1.1767 + _dbus_string_free (&filename);
1.1768 + _dbus_string_free (&full_path);
1.1769 +
1.1770 + return ret_val;
1.1771 +}
1.1772 +
1.1773 +static dbus_bool_t
1.1774 +init_service_reload_test (DBusString *dir)
1.1775 +{
1.1776 + DBusStat stat_buf;
1.1777 +
1.1778 + if (!_dbus_stat (dir, &stat_buf, NULL))
1.1779 + {
1.1780 + if (!_dbus_create_directory (dir, NULL))
1.1781 + return FALSE;
1.1782 + }
1.1783 + else
1.1784 + {
1.1785 + if (!test_remove_directory (dir))
1.1786 + return FALSE;
1.1787 +
1.1788 + if (!_dbus_create_directory (dir, NULL))
1.1789 + return FALSE;
1.1790 + }
1.1791 +
1.1792 + /* Create one initial file */
1.1793 + if (!test_create_service_file (dir, SERVICE_FILE_1, SERVICE_NAME_1, "exec-1"))
1.1794 + return FALSE;
1.1795 +
1.1796 + return TRUE;
1.1797 +}
1.1798 +
1.1799 +static dbus_bool_t
1.1800 +cleanup_service_reload_test (DBusString *dir)
1.1801 +{
1.1802 + if (!test_remove_directory (dir))
1.1803 + return FALSE;
1.1804 +
1.1805 + return TRUE;
1.1806 +}
1.1807 +
1.1808 +typedef struct
1.1809 +{
1.1810 + BusActivation *activation;
1.1811 + const char *service_name;
1.1812 + dbus_bool_t expecting_find;
1.1813 +} CheckData;
1.1814 +
1.1815 +static dbus_bool_t
1.1816 +check_func (void *data)
1.1817 +{
1.1818 + CheckData *d;
1.1819 + BusActivationEntry *entry;
1.1820 + DBusError error;
1.1821 + dbus_bool_t ret_val;
1.1822 +
1.1823 + ret_val = TRUE;
1.1824 + d = data;
1.1825 +
1.1826 + dbus_error_init (&error);
1.1827 +
1.1828 + entry = activation_find_entry (d->activation, d->service_name, &error);
1.1829 + if (entry == NULL)
1.1830 + {
1.1831 + if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1.1832 + {
1.1833 + ret_val = TRUE;
1.1834 + }
1.1835 + else
1.1836 + {
1.1837 + if (d->expecting_find)
1.1838 + ret_val = FALSE;
1.1839 + }
1.1840 +
1.1841 + dbus_error_free (&error);
1.1842 + }
1.1843 + else
1.1844 + {
1.1845 + if (!d->expecting_find)
1.1846 + ret_val = FALSE;
1.1847 + }
1.1848 +
1.1849 + return ret_val;
1.1850 +}
1.1851 +
1.1852 +static dbus_bool_t
1.1853 +do_test (const char *description, dbus_bool_t oom_test, CheckData *data)
1.1854 +{
1.1855 + dbus_bool_t err;
1.1856 +
1.1857 + if (oom_test)
1.1858 + err = !_dbus_test_oom_handling (description, check_func, data);
1.1859 + else
1.1860 + err = !check_func (data);
1.1861 +
1.1862 + if (err)
1.1863 + _dbus_assert_not_reached ("Test failed");
1.1864 +
1.1865 + return TRUE;
1.1866 +}
1.1867 +
1.1868 +static dbus_bool_t
1.1869 +do_service_reload_test (DBusString *dir, dbus_bool_t oom_test)
1.1870 +{
1.1871 + BusActivation *activation;
1.1872 + DBusString address;
1.1873 + DBusList *directories;
1.1874 + CheckData d;
1.1875 +
1.1876 + directories = NULL;
1.1877 + _dbus_string_init_const (&address, "");
1.1878 +
1.1879 + if (!_dbus_list_append (&directories, _dbus_string_get_data (dir)))
1.1880 + return FALSE;
1.1881 +
1.1882 + activation = bus_activation_new (NULL, &address, &directories, NULL);
1.1883 + if (!activation)
1.1884 + return FALSE;
1.1885 +
1.1886 + d.activation = activation;
1.1887 +
1.1888 + /* Check for existing service file */
1.1889 + d.expecting_find = TRUE;
1.1890 + d.service_name = SERVICE_NAME_1;
1.1891 +
1.1892 + if (!do_test ("Existing service file", oom_test, &d))
1.1893 + return FALSE;
1.1894 +
1.1895 + /* Check for non-existing service file */
1.1896 + d.expecting_find = FALSE;
1.1897 + d.service_name = SERVICE_NAME_3;
1.1898 +
1.1899 + if (!do_test ("Nonexisting service file", oom_test, &d))
1.1900 + return FALSE;
1.1901 +
1.1902 + /* Check for added service file */
1.1903 + if (!test_create_service_file (dir, SERVICE_FILE_2, SERVICE_NAME_2, "exec-2"))
1.1904 + return FALSE;
1.1905 +
1.1906 + d.expecting_find = TRUE;
1.1907 + d.service_name = SERVICE_NAME_2;
1.1908 +
1.1909 + if (!do_test ("Added service file", oom_test, &d))
1.1910 + return FALSE;
1.1911 +
1.1912 + /* Check for removed service file */
1.1913 + if (!test_remove_service_file (dir, SERVICE_FILE_2))
1.1914 + return FALSE;
1.1915 +
1.1916 + d.expecting_find = FALSE;
1.1917 + d.service_name = SERVICE_FILE_2;
1.1918 +
1.1919 + if (!do_test ("Removed service file", oom_test, &d))
1.1920 + return FALSE;
1.1921 +
1.1922 + /* Check for updated service file */
1.1923 +
1.1924 + _dbus_sleep_milliseconds (1000); /* Sleep a second to make sure the mtime is updated */
1.1925 +
1.1926 + if (!test_create_service_file (dir, SERVICE_FILE_1, SERVICE_NAME_3, "exec-3"))
1.1927 + return FALSE;
1.1928 +
1.1929 + d.expecting_find = TRUE;
1.1930 + d.service_name = SERVICE_NAME_3;
1.1931 +
1.1932 + if (!do_test ("Updated service file, part 1", oom_test, &d))
1.1933 + return FALSE;
1.1934 +
1.1935 + d.expecting_find = FALSE;
1.1936 + d.service_name = SERVICE_NAME_1;
1.1937 +
1.1938 + if (!do_test ("Updated service file, part 2", oom_test, &d))
1.1939 + return FALSE;
1.1940 +
1.1941 + bus_activation_unref (activation);
1.1942 + _dbus_list_clear (&directories);
1.1943 +
1.1944 + return TRUE;
1.1945 +}
1.1946 +
1.1947 +dbus_bool_t
1.1948 +bus_activation_service_reload_test (const DBusString *test_data_dir)
1.1949 +{
1.1950 + DBusString directory;
1.1951 + DBusStat stat_buf;
1.1952 + if (!_dbus_string_init (&directory))
1.1953 + return FALSE;
1.1954 +
1.1955 + if (!_dbus_string_append (&directory, _dbus_get_tmpdir()))
1.1956 + return FALSE;
1.1957 + if (!_dbus_stat (&directory, &stat_buf, NULL))
1.1958 + {
1.1959 + if (!_dbus_create_directory (&directory, NULL))
1.1960 + return FALSE;
1.1961 + }
1.1962 +
1.1963 + if (!_dbus_string_append (&directory, "/dbus-reload-test-") ||
1.1964 + !_dbus_generate_random_ascii (&directory, 6))
1.1965 + {
1.1966 + return FALSE;
1.1967 + }
1.1968 +
1.1969 + /* Do normal tests */
1.1970 + if (!init_service_reload_test (&directory))
1.1971 + _dbus_assert_not_reached ("could not initiate service reload test");
1.1972 +
1.1973 + if (!do_service_reload_test (&directory, FALSE))
1.1974 + ; /* Do nothing? */
1.1975 +
1.1976 + /* Do OOM tests */
1.1977 + if (!init_service_reload_test (&directory))
1.1978 + _dbus_assert_not_reached ("could not initiate service reload test");
1.1979 +
1.1980 + if (!do_service_reload_test (&directory, TRUE))
1.1981 + ; /* Do nothing? */
1.1982 +
1.1983 + /* Cleanup test directory */
1.1984 + if (!cleanup_service_reload_test (&directory))
1.1985 + return FALSE;
1.1986 +
1.1987 + _dbus_string_free (&directory);
1.1988 +
1.1989 + return TRUE;
1.1990 +}
1.1991 +
1.1992 +#endif /* DBUS_BUILD_TESTS */