2011-07-22 04:21:18 +02:00
|
|
|
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
|
|
|
|
|
|
|
/***
|
|
|
|
This file is part of systemd.
|
|
|
|
|
|
|
|
Copyright 2011 Lennart Poettering
|
|
|
|
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
2012-04-12 00:20:58 +02:00
|
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
2011-07-22 04:21:18 +02:00
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
|
|
WITHOUT ANY WARRANTY; without even the implied warranty <of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
2012-04-12 00:20:58 +02:00
|
|
|
Lesser General Public License for more details.
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2012-04-12 00:20:58 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
2011-07-22 04:21:18 +02:00
|
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
***/
|
|
|
|
|
|
|
|
#include <errno.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <fnmatch.h>
|
2015-10-24 22:58:24 +02:00
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "conf-files.h"
|
|
|
|
#include "conf-parser.h"
|
2015-10-26 20:07:55 +01:00
|
|
|
#include "dirent-util.h"
|
|
|
|
#include "fd-util.h"
|
2015-10-26 21:16:26 +01:00
|
|
|
#include "fs-util.h"
|
2011-07-22 04:21:18 +02:00
|
|
|
#include "hashmap.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "install-printf.h"
|
2015-10-26 20:07:55 +01:00
|
|
|
#include "install.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "mkdir.h"
|
2011-07-22 04:21:18 +02:00
|
|
|
#include "path-lookup.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "path-util.h"
|
|
|
|
#include "set.h"
|
|
|
|
#include "special.h"
|
2015-10-26 22:01:44 +01:00
|
|
|
#include "stat-util.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "string-util.h"
|
2011-07-22 04:21:18 +02:00
|
|
|
#include "strv.h"
|
|
|
|
#include "unit-name.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "util.h"
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
typedef struct {
|
2014-08-22 10:35:59 +02:00
|
|
|
OrderedHashmap *will_install;
|
|
|
|
OrderedHashmap *have_installed;
|
2011-07-22 04:21:18 +02:00
|
|
|
} InstallContext;
|
|
|
|
|
2014-06-17 01:37:54 +02:00
|
|
|
static int in_search_path(const char *path, char **search) {
|
2014-06-17 00:53:49 +02:00
|
|
|
_cleanup_free_ char *parent = NULL;
|
|
|
|
|
|
|
|
assert(path);
|
|
|
|
|
2015-10-26 17:30:56 +01:00
|
|
|
parent = dirname_malloc(path);
|
|
|
|
if (!parent)
|
|
|
|
return -ENOMEM;
|
2014-06-17 00:53:49 +02:00
|
|
|
|
2014-06-17 01:37:54 +02:00
|
|
|
return strv_contains(search, parent);
|
2014-06-17 00:53:49 +02:00
|
|
|
}
|
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
static int get_config_path(UnitFileScope scope, bool runtime, const char *root_dir, char **ret) {
|
|
|
|
char *p = NULL;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
|
|
|
assert(ret);
|
|
|
|
|
|
|
|
switch (scope) {
|
|
|
|
|
|
|
|
case UNIT_FILE_SYSTEM:
|
|
|
|
|
2014-07-26 20:47:31 +02:00
|
|
|
if (runtime)
|
|
|
|
p = path_join(root_dir, "/run/systemd/system", NULL);
|
|
|
|
else
|
|
|
|
p = path_join(root_dir, SYSTEM_CONFIG_UNIT_PATH, NULL);
|
2011-07-22 04:21:18 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case UNIT_FILE_GLOBAL:
|
|
|
|
|
|
|
|
if (root_dir)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (runtime)
|
|
|
|
p = strdup("/run/systemd/user");
|
|
|
|
else
|
|
|
|
p = strdup(USER_CONFIG_UNIT_PATH);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case UNIT_FILE_USER:
|
|
|
|
|
2014-09-28 23:54:25 +02:00
|
|
|
if (root_dir)
|
2011-07-22 04:21:18 +02:00
|
|
|
return -EINVAL;
|
|
|
|
|
2014-09-28 23:54:25 +02:00
|
|
|
if (runtime)
|
2014-10-02 14:01:00 +02:00
|
|
|
r = user_runtime_dir(&p);
|
2014-09-28 23:54:25 +02:00
|
|
|
else
|
|
|
|
r = user_config_home(&p);
|
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r <= 0)
|
|
|
|
return r < 0 ? r : -ENOENT;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
assert_not_reached("Bad scope");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!p)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
*ret = p;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mark_symlink_for_removal(
|
|
|
|
Set **remove_symlinks_to,
|
|
|
|
const char *p) {
|
|
|
|
|
|
|
|
char *n;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(p);
|
|
|
|
|
2014-08-13 01:00:18 +02:00
|
|
|
r = set_ensure_allocated(remove_symlinks_to, &string_hash_ops);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
n = strdup(p);
|
|
|
|
if (!n)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
path_kill_slashes(n);
|
|
|
|
|
2013-04-23 05:12:15 +02:00
|
|
|
r = set_consume(*remove_symlinks_to, n);
|
|
|
|
if (r < 0)
|
2011-07-22 04:21:18 +02:00
|
|
|
return r == -EEXIST ? 0 : r;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int remove_marked_symlinks_fd(
|
|
|
|
Set *remove_symlinks_to,
|
|
|
|
int fd,
|
|
|
|
const char *path,
|
|
|
|
const char *config_path,
|
|
|
|
bool *deleted,
|
|
|
|
UnitFileChange **changes,
|
2012-07-13 15:59:26 +02:00
|
|
|
unsigned *n_changes,
|
2014-06-16 19:48:31 +02:00
|
|
|
char** instance_whitelist) {
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_closedir_ DIR *d = NULL;
|
2014-06-16 19:48:31 +02:00
|
|
|
int r = 0;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
assert(remove_symlinks_to);
|
|
|
|
assert(fd >= 0);
|
|
|
|
assert(path);
|
|
|
|
assert(config_path);
|
|
|
|
assert(deleted);
|
|
|
|
|
|
|
|
d = fdopendir(fd);
|
|
|
|
if (!d) {
|
2014-03-18 19:22:43 +01:00
|
|
|
safe_close(fd);
|
2011-07-22 04:21:18 +02:00
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
rewinddir(d);
|
|
|
|
|
|
|
|
for (;;) {
|
2012-09-19 22:21:09 +02:00
|
|
|
struct dirent *de;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2013-12-19 11:59:19 +01:00
|
|
|
errno = 0;
|
|
|
|
de = readdir(d);
|
|
|
|
if (!de && errno != 0) {
|
2011-07-22 04:21:18 +02:00
|
|
|
r = -errno;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!de)
|
|
|
|
break;
|
|
|
|
|
2014-12-19 20:03:36 +01:00
|
|
|
if (hidden_file(de->d_name))
|
2011-07-22 04:21:18 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
dirent_ensure_type(d, de);
|
|
|
|
|
|
|
|
if (de->d_type == DT_DIR) {
|
|
|
|
int nfd, q;
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *p = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
nfd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
|
|
|
|
if (nfd < 0) {
|
|
|
|
if (errno == ENOENT)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (r == 0)
|
|
|
|
r = -errno;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = path_make_absolute(de->d_name, path);
|
|
|
|
if (!p) {
|
2014-03-18 19:22:43 +01:00
|
|
|
safe_close(nfd);
|
2013-01-29 02:33:10 +01:00
|
|
|
return -ENOMEM;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This will close nfd, regardless whether it succeeds or not */
|
2014-06-16 19:48:31 +02:00
|
|
|
q = remove_marked_symlinks_fd(remove_symlinks_to, nfd, p, config_path, deleted, changes, n_changes, instance_whitelist);
|
|
|
|
if (q < 0 && r == 0)
|
2011-07-22 04:21:18 +02:00
|
|
|
r = q;
|
|
|
|
|
|
|
|
} else if (de->d_type == DT_LNK) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *p = NULL, *dest = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
int q;
|
|
|
|
bool found;
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!unit_name_is_valid(de->d_name, UNIT_NAME_ANY))
|
2014-06-16 19:48:31 +02:00
|
|
|
continue;
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (unit_name_is_valid(de->d_name, UNIT_NAME_INSTANCE) &&
|
2014-06-16 19:48:31 +02:00
|
|
|
instance_whitelist &&
|
2014-06-17 00:33:39 +02:00
|
|
|
!strv_contains(instance_whitelist, de->d_name)) {
|
|
|
|
|
2015-06-24 01:16:18 +02:00
|
|
|
_cleanup_free_ char *w = NULL;
|
2014-06-17 00:33:39 +02:00
|
|
|
|
|
|
|
/* OK, the file is not listed directly
|
|
|
|
* in the whitelist, so let's check if
|
|
|
|
* the template of it might be
|
|
|
|
* listed. */
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_template(de->d_name, &w);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2014-06-17 00:33:39 +02:00
|
|
|
|
|
|
|
if (!strv_contains(instance_whitelist, w))
|
|
|
|
continue;
|
|
|
|
}
|
2014-06-16 19:48:31 +02:00
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
p = path_make_absolute(de->d_name, path);
|
2013-01-29 02:33:10 +01:00
|
|
|
if (!p)
|
|
|
|
return -ENOMEM;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
q = readlink_and_canonicalize(p, &dest);
|
|
|
|
if (q < 0) {
|
|
|
|
if (q == -ENOENT)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
found =
|
|
|
|
set_get(remove_symlinks_to, dest) ||
|
2013-12-07 03:29:55 +01:00
|
|
|
set_get(remove_symlinks_to, basename(dest));
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-17 00:10:54 +02:00
|
|
|
if (!found)
|
|
|
|
continue;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-17 00:10:54 +02:00
|
|
|
if (unlink(p) < 0 && errno != ENOENT) {
|
|
|
|
if (r == 0)
|
|
|
|
r = -errno;
|
|
|
|
continue;
|
|
|
|
}
|
2014-06-16 19:48:31 +02:00
|
|
|
|
2014-06-17 00:10:54 +02:00
|
|
|
path_kill_slashes(p);
|
2014-06-17 00:33:39 +02:00
|
|
|
rmdir_parents(p, config_path);
|
2015-05-15 09:54:10 +02:00
|
|
|
unit_file_changes_add(changes, n_changes, UNIT_FILE_UNLINK, p, NULL);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-17 00:10:54 +02:00
|
|
|
if (!set_get(remove_symlinks_to, p)) {
|
|
|
|
|
|
|
|
q = mark_symlink_for_removal(&remove_symlinks_to, p);
|
|
|
|
if (q < 0) {
|
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
} else
|
|
|
|
*deleted = true;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int remove_marked_symlinks(
|
|
|
|
Set *remove_symlinks_to,
|
|
|
|
const char *config_path,
|
|
|
|
UnitFileChange **changes,
|
2012-07-13 15:59:26 +02:00
|
|
|
unsigned *n_changes,
|
2014-06-16 19:48:31 +02:00
|
|
|
char** instance_whitelist) {
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-16 17:19:30 +02:00
|
|
|
_cleanup_close_ int fd = -1;
|
|
|
|
int r = 0;
|
2011-07-22 04:21:18 +02:00
|
|
|
bool deleted;
|
|
|
|
|
|
|
|
assert(config_path);
|
|
|
|
|
|
|
|
if (set_size(remove_symlinks_to) <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fd = open(config_path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
|
|
|
|
if (fd < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
do {
|
|
|
|
int q, cfd;
|
|
|
|
deleted = false;
|
|
|
|
|
2014-05-13 16:40:53 +02:00
|
|
|
cfd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (cfd < 0) {
|
|
|
|
r = -errno;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This takes possession of cfd and closes it */
|
2014-06-16 19:48:31 +02:00
|
|
|
q = remove_marked_symlinks_fd(remove_symlinks_to, cfd, config_path, config_path, &deleted, changes, n_changes, instance_whitelist);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
} while (deleted);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int find_symlinks_fd(
|
|
|
|
const char *name,
|
|
|
|
int fd,
|
|
|
|
const char *path,
|
|
|
|
const char *config_path,
|
|
|
|
bool *same_name_link) {
|
|
|
|
|
|
|
|
int r = 0;
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_closedir_ DIR *d = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
assert(name);
|
|
|
|
assert(fd >= 0);
|
|
|
|
assert(path);
|
|
|
|
assert(config_path);
|
|
|
|
assert(same_name_link);
|
|
|
|
|
|
|
|
d = fdopendir(fd);
|
|
|
|
if (!d) {
|
2014-03-18 19:22:43 +01:00
|
|
|
safe_close(fd);
|
2011-07-22 04:21:18 +02:00
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
2012-09-19 22:21:09 +02:00
|
|
|
struct dirent *de;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2013-12-19 11:59:19 +01:00
|
|
|
errno = 0;
|
|
|
|
de = readdir(d);
|
|
|
|
if (!de && errno != 0)
|
2013-01-27 21:54:00 +01:00
|
|
|
return -errno;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
if (!de)
|
2013-01-27 21:54:00 +01:00
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-12-19 20:03:36 +01:00
|
|
|
if (hidden_file(de->d_name))
|
2011-07-22 04:21:18 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
dirent_ensure_type(d, de);
|
|
|
|
|
|
|
|
if (de->d_type == DT_DIR) {
|
|
|
|
int nfd, q;
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *p = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
nfd = openat(fd, de->d_name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
|
|
|
|
if (nfd < 0) {
|
|
|
|
if (errno == ENOENT)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (r == 0)
|
|
|
|
r = -errno;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = path_make_absolute(de->d_name, path);
|
|
|
|
if (!p) {
|
2014-03-18 19:22:43 +01:00
|
|
|
safe_close(nfd);
|
2013-01-27 21:54:00 +01:00
|
|
|
return -ENOMEM;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This will close nfd, regardless whether it succeeds or not */
|
|
|
|
q = find_symlinks_fd(name, nfd, p, config_path, same_name_link);
|
2013-01-27 21:54:00 +01:00
|
|
|
if (q > 0)
|
|
|
|
return 1;
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
|
|
|
|
} else if (de->d_type == DT_LNK) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *p = NULL, *dest = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
bool found_path, found_dest, b = false;
|
|
|
|
int q;
|
|
|
|
|
|
|
|
/* Acquire symlink name */
|
|
|
|
p = path_make_absolute(de->d_name, path);
|
2013-01-27 21:54:00 +01:00
|
|
|
if (!p)
|
|
|
|
return -ENOMEM;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
/* Acquire symlink destination */
|
|
|
|
q = readlink_and_canonicalize(p, &dest);
|
|
|
|
if (q < 0) {
|
|
|
|
if (q == -ENOENT)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check if the symlink itself matches what we
|
|
|
|
* are looking for */
|
|
|
|
if (path_is_absolute(name))
|
|
|
|
found_path = path_equal(p, name);
|
|
|
|
else
|
|
|
|
found_path = streq(de->d_name, name);
|
|
|
|
|
|
|
|
/* Check if what the symlink points to
|
|
|
|
* matches what we are looking for */
|
|
|
|
if (path_is_absolute(name))
|
|
|
|
found_dest = path_equal(dest, name);
|
|
|
|
else
|
2013-12-07 03:29:55 +01:00
|
|
|
found_dest = streq(basename(dest), name);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
if (found_path && found_dest) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *t = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
/* Filter out same name links in the main
|
|
|
|
* config path */
|
|
|
|
t = path_make_absolute(name, config_path);
|
2013-01-27 21:54:00 +01:00
|
|
|
if (!t)
|
|
|
|
return -ENOMEM;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
b = path_equal(t, p);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (b)
|
|
|
|
*same_name_link = true;
|
2013-01-27 21:54:00 +01:00
|
|
|
else if (found_path || found_dest)
|
|
|
|
return 1;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int find_symlinks(
|
|
|
|
const char *name,
|
|
|
|
const char *config_path,
|
|
|
|
bool *same_name_link) {
|
|
|
|
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
assert(name);
|
|
|
|
assert(config_path);
|
|
|
|
assert(same_name_link);
|
|
|
|
|
|
|
|
fd = open(config_path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW);
|
2012-09-16 12:35:46 +02:00
|
|
|
if (fd < 0) {
|
|
|
|
if (errno == ENOENT)
|
|
|
|
return 0;
|
2011-07-22 04:21:18 +02:00
|
|
|
return -errno;
|
2012-09-16 12:35:46 +02:00
|
|
|
}
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
/* This takes possession of fd and closes it */
|
|
|
|
return find_symlinks_fd(name, fd, config_path, config_path, same_name_link);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int find_symlinks_in_scope(
|
|
|
|
UnitFileScope scope,
|
|
|
|
const char *root_dir,
|
|
|
|
const char *name,
|
|
|
|
UnitFileState *state) {
|
|
|
|
|
|
|
|
int r;
|
2015-04-10 15:44:02 +02:00
|
|
|
_cleanup_free_ char *normal_path = NULL, *runtime_path = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
bool same_name_link_runtime = false, same_name_link = false;
|
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
|
|
|
assert(name);
|
|
|
|
|
2014-09-28 23:54:25 +02:00
|
|
|
/* First look in runtime config path */
|
2015-04-10 15:44:02 +02:00
|
|
|
r = get_config_path(scope, true, root_dir, &normal_path);
|
2014-09-28 23:54:25 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2015-04-10 15:44:02 +02:00
|
|
|
r = find_symlinks(name, normal_path, &same_name_link_runtime);
|
2014-09-28 23:54:25 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
else if (r > 0) {
|
|
|
|
*state = UNIT_FILE_ENABLED_RUNTIME;
|
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Then look in the normal config path */
|
2015-04-10 15:44:02 +02:00
|
|
|
r = get_config_path(scope, false, root_dir, &runtime_path);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2015-04-10 15:44:02 +02:00
|
|
|
r = find_symlinks(name, runtime_path, &same_name_link);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
else if (r > 0) {
|
|
|
|
*state = UNIT_FILE_ENABLED;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Hmm, we didn't find it, but maybe we found the same name
|
|
|
|
* link? */
|
|
|
|
if (same_name_link_runtime) {
|
|
|
|
*state = UNIT_FILE_LINKED_RUNTIME;
|
|
|
|
return 1;
|
|
|
|
} else if (same_name_link) {
|
|
|
|
*state = UNIT_FILE_LINKED;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int unit_file_mask(
|
|
|
|
UnitFileScope scope,
|
|
|
|
bool runtime,
|
|
|
|
const char *root_dir,
|
2013-12-27 06:16:39 +01:00
|
|
|
char **files,
|
2011-07-22 04:21:18 +02:00
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
2012-09-16 12:55:28 +02:00
|
|
|
char **i;
|
2014-06-13 18:48:18 +02:00
|
|
|
_cleanup_free_ char *prefix = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
|
|
|
|
|
|
|
r = get_config_path(scope, runtime, root_dir, &prefix);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
STRV_FOREACH(i, files) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *path = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!unit_name_is_valid(*i, UNIT_NAME_ANY)) {
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r == 0)
|
|
|
|
r = -EINVAL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
path = path_make_absolute(*i, prefix);
|
|
|
|
if (!path) {
|
|
|
|
r = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (symlink("/dev/null", path) >= 0) {
|
2015-05-15 09:54:10 +02:00
|
|
|
unit_file_changes_add(changes, n_changes, UNIT_FILE_SYMLINK, path, "/dev/null");
|
2011-07-22 04:21:18 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (errno == EEXIST) {
|
|
|
|
|
2012-09-16 12:55:28 +02:00
|
|
|
if (null_or_empty_path(path) > 0)
|
2011-07-22 04:21:18 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (force) {
|
2014-06-17 00:11:47 +02:00
|
|
|
if (symlink_atomic("/dev/null", path) >= 0) {
|
2015-05-15 09:54:10 +02:00
|
|
|
unit_file_changes_add(changes, n_changes, UNIT_FILE_UNLINK, path, NULL);
|
|
|
|
unit_file_changes_add(changes, n_changes, UNIT_FILE_SYMLINK, path, "/dev/null");
|
2011-07-22 04:21:18 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (r == 0)
|
|
|
|
r = -EEXIST;
|
|
|
|
} else {
|
|
|
|
if (r == 0)
|
|
|
|
r = -errno;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
int unit_file_unmask(
|
|
|
|
UnitFileScope scope,
|
|
|
|
bool runtime,
|
|
|
|
const char *root_dir,
|
2013-12-27 06:16:39 +01:00
|
|
|
char **files,
|
2011-07-22 04:21:18 +02:00
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
|
|
|
char **i, *config_path = NULL;
|
|
|
|
int r, q;
|
|
|
|
Set *remove_symlinks_to = NULL;
|
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
|
|
|
|
|
|
|
r = get_config_path(scope, runtime, root_dir, &config_path);
|
|
|
|
if (r < 0)
|
|
|
|
goto finish;
|
|
|
|
|
|
|
|
STRV_FOREACH(i, files) {
|
2014-11-29 11:14:48 +01:00
|
|
|
_cleanup_free_ char *path = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!unit_name_is_valid(*i, UNIT_NAME_ANY)) {
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r == 0)
|
|
|
|
r = -EINVAL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
path = path_make_absolute(*i, config_path);
|
|
|
|
if (!path) {
|
|
|
|
r = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
q = null_or_empty_path(path);
|
|
|
|
if (q > 0) {
|
2014-11-29 11:14:48 +01:00
|
|
|
if (unlink(path) < 0)
|
|
|
|
q = -errno;
|
|
|
|
else {
|
|
|
|
q = mark_symlink_for_removal(&remove_symlinks_to, path);
|
2015-05-15 09:54:10 +02:00
|
|
|
unit_file_changes_add(changes, n_changes, UNIT_FILE_UNLINK, path, NULL);
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (q != -ENOENT && r == 0)
|
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
finish:
|
2012-07-13 15:59:26 +02:00
|
|
|
q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
|
|
|
|
set_free_free(remove_symlinks_to);
|
|
|
|
free(config_path);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
int unit_file_link(
|
|
|
|
UnitFileScope scope,
|
|
|
|
bool runtime,
|
|
|
|
const char *root_dir,
|
2013-12-27 06:16:39 +01:00
|
|
|
char **files,
|
2011-07-22 04:21:18 +02:00
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_lookup_paths_free_ LookupPaths paths = {};
|
2013-01-29 02:33:10 +01:00
|
|
|
char **i;
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *config_path = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
int r, q;
|
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
|
|
|
|
2014-04-24 07:44:10 +02:00
|
|
|
r = lookup_paths_init_from_scope(&paths, scope, root_dir);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = get_config_path(scope, runtime, root_dir, &config_path);
|
|
|
|
if (r < 0)
|
2013-01-29 02:33:10 +01:00
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
STRV_FOREACH(i, files) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *path = NULL;
|
2013-01-29 02:33:10 +01:00
|
|
|
char *fn;
|
2011-07-22 04:21:18 +02:00
|
|
|
struct stat st;
|
|
|
|
|
2013-12-07 03:29:55 +01:00
|
|
|
fn = basename(*i);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
if (!path_is_absolute(*i) ||
|
2015-04-30 20:21:00 +02:00
|
|
|
!unit_name_is_valid(fn, UNIT_NAME_ANY)) {
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r == 0)
|
|
|
|
r = -EINVAL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lstat(*i, &st) < 0) {
|
|
|
|
if (r == 0)
|
|
|
|
r = -errno;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!S_ISREG(st.st_mode)) {
|
|
|
|
r = -ENOENT;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-06-17 01:37:54 +02:00
|
|
|
q = in_search_path(*i, paths.unit_path);
|
2013-01-29 02:33:10 +01:00
|
|
|
if (q < 0)
|
|
|
|
return q;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
if (q > 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
path = path_make_absolute(fn, config_path);
|
2013-01-29 02:33:10 +01:00
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
if (symlink(*i, path) >= 0) {
|
2015-05-15 09:54:10 +02:00
|
|
|
unit_file_changes_add(changes, n_changes, UNIT_FILE_SYMLINK, path, *i);
|
2011-07-22 04:21:18 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (errno == EEXIST) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *dest = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
q = readlink_and_make_absolute(path, &dest);
|
|
|
|
if (q < 0 && errno != ENOENT) {
|
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2013-01-29 02:33:10 +01:00
|
|
|
if (q >= 0 && path_equal(dest, *i))
|
2011-07-22 04:21:18 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (force) {
|
2014-06-17 00:11:47 +02:00
|
|
|
if (symlink_atomic(*i, path) >= 0) {
|
2015-05-15 09:54:10 +02:00
|
|
|
unit_file_changes_add(changes, n_changes, UNIT_FILE_UNLINK, path, NULL);
|
|
|
|
unit_file_changes_add(changes, n_changes, UNIT_FILE_SYMLINK, path, *i);
|
2011-07-22 04:21:18 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (r == 0)
|
|
|
|
r = -EEXIST;
|
|
|
|
} else {
|
|
|
|
if (r == 0)
|
|
|
|
r = -errno;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
void unit_file_list_free(Hashmap *h) {
|
|
|
|
UnitFileList *i;
|
|
|
|
|
|
|
|
while ((i = hashmap_steal_first(h))) {
|
|
|
|
free(i->path);
|
|
|
|
free(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
hashmap_free(h);
|
|
|
|
}
|
|
|
|
|
2015-05-15 09:54:10 +02:00
|
|
|
int unit_file_changes_add(
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes,
|
|
|
|
UnitFileChangeType type,
|
|
|
|
const char *path,
|
|
|
|
const char *source) {
|
|
|
|
|
|
|
|
UnitFileChange *c;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
assert(path);
|
|
|
|
assert(!changes == !n_changes);
|
|
|
|
|
|
|
|
if (!changes)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
c = realloc(*changes, (*n_changes + 1) * sizeof(UnitFileChange));
|
|
|
|
if (!c)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
*changes = c;
|
|
|
|
i = *n_changes;
|
|
|
|
|
|
|
|
c[i].type = type;
|
|
|
|
c[i].path = strdup(path);
|
|
|
|
if (!c[i].path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
path_kill_slashes(c[i].path);
|
|
|
|
|
|
|
|
if (source) {
|
|
|
|
c[i].source = strdup(source);
|
|
|
|
if (!c[i].source) {
|
|
|
|
free(c[i].path);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
path_kill_slashes(c[i].path);
|
|
|
|
} else
|
|
|
|
c[i].source = NULL;
|
|
|
|
|
|
|
|
*n_changes = i+1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
void unit_file_changes_free(UnitFileChange *changes, unsigned n_changes) {
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
assert(changes || n_changes == 0);
|
|
|
|
|
|
|
|
if (!changes)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < n_changes; i++) {
|
|
|
|
free(changes[i].path);
|
|
|
|
free(changes[i].source);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(changes);
|
|
|
|
}
|
|
|
|
|
2015-05-11 22:53:54 +02:00
|
|
|
static void install_info_free(UnitFileInstallInfo *i) {
|
2011-07-22 04:21:18 +02:00
|
|
|
assert(i);
|
|
|
|
|
|
|
|
free(i->name);
|
|
|
|
free(i->path);
|
|
|
|
strv_free(i->aliases);
|
|
|
|
strv_free(i->wanted_by);
|
2012-05-21 15:27:26 +02:00
|
|
|
strv_free(i->required_by);
|
2014-11-07 21:21:05 +01:00
|
|
|
strv_free(i->also);
|
2014-06-17 00:15:31 +02:00
|
|
|
free(i->default_instance);
|
2011-07-22 04:21:18 +02:00
|
|
|
free(i);
|
|
|
|
}
|
|
|
|
|
2014-08-22 10:35:59 +02:00
|
|
|
static void install_info_hashmap_free(OrderedHashmap *m) {
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
if (!m)
|
|
|
|
return;
|
|
|
|
|
2014-08-22 10:35:59 +02:00
|
|
|
while ((i = ordered_hashmap_steal_first(m)))
|
2011-07-22 04:21:18 +02:00
|
|
|
install_info_free(i);
|
|
|
|
|
2014-08-22 10:35:59 +02:00
|
|
|
ordered_hashmap_free(m);
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void install_context_done(InstallContext *c) {
|
|
|
|
assert(c);
|
|
|
|
|
|
|
|
install_info_hashmap_free(c->will_install);
|
|
|
|
install_info_hashmap_free(c->have_installed);
|
|
|
|
|
|
|
|
c->will_install = c->have_installed = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int install_info_add(
|
|
|
|
InstallContext *c,
|
|
|
|
const char *name,
|
|
|
|
const char *path) {
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(c);
|
|
|
|
assert(name || path);
|
|
|
|
|
|
|
|
if (!name)
|
2013-12-07 03:29:55 +01:00
|
|
|
name = basename(path);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!unit_name_is_valid(name, UNIT_NAME_ANY))
|
2011-07-22 04:21:18 +02:00
|
|
|
return -EINVAL;
|
|
|
|
|
2014-08-22 10:35:59 +02:00
|
|
|
if (ordered_hashmap_get(c->have_installed, name) ||
|
|
|
|
ordered_hashmap_get(c->will_install, name))
|
2011-07-22 04:21:18 +02:00
|
|
|
return 0;
|
|
|
|
|
2014-08-22 10:35:59 +02:00
|
|
|
r = ordered_hashmap_ensure_allocated(&c->will_install, &string_hash_ops);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2015-05-11 22:53:54 +02:00
|
|
|
i = new0(UnitFileInstallInfo, 1);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (!i)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
i->name = strdup(name);
|
|
|
|
if (!i->name) {
|
|
|
|
r = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (path) {
|
|
|
|
i->path = strdup(path);
|
|
|
|
if (!i->path) {
|
|
|
|
r = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-22 10:35:59 +02:00
|
|
|
r = ordered_hashmap_put(c->will_install, i->name, i);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
if (i)
|
|
|
|
install_info_free(i);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int install_info_add_auto(
|
|
|
|
InstallContext *c,
|
|
|
|
const char *name_or_path) {
|
|
|
|
|
|
|
|
assert(c);
|
|
|
|
assert(name_or_path);
|
|
|
|
|
|
|
|
if (path_is_absolute(name_or_path))
|
|
|
|
return install_info_add(c, NULL, name_or_path);
|
|
|
|
else
|
|
|
|
return install_info_add(c, name_or_path, NULL);
|
|
|
|
}
|
|
|
|
|
2014-06-17 00:15:31 +02:00
|
|
|
static int config_parse_also(
|
|
|
|
const char *unit,
|
|
|
|
const char *filename,
|
|
|
|
unsigned line,
|
|
|
|
const char *section,
|
|
|
|
unsigned section_line,
|
|
|
|
const char *lvalue,
|
|
|
|
int ltype,
|
|
|
|
const char *rvalue,
|
|
|
|
void *data,
|
|
|
|
void *userdata) {
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
size_t l;
|
2014-07-30 04:01:36 +02:00
|
|
|
const char *word, *state;
|
2011-07-22 04:21:18 +02:00
|
|
|
InstallContext *c = data;
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i = userdata;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
assert(filename);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
|
2014-07-30 04:01:36 +02:00
|
|
|
FOREACH_WORD_QUOTED(word, l, rvalue, state) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *n;
|
2011-07-22 04:21:18 +02:00
|
|
|
int r;
|
|
|
|
|
2014-07-30 04:01:36 +02:00
|
|
|
n = strndup(word, l);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (!n)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
r = install_info_add(c, n, NULL);
|
2013-01-29 02:33:10 +01:00
|
|
|
if (r < 0)
|
2011-07-22 04:21:18 +02:00
|
|
|
return r;
|
2014-11-07 21:21:05 +01:00
|
|
|
|
|
|
|
r = strv_extend(&i->also, n);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
2014-07-31 09:28:37 +02:00
|
|
|
if (!isempty(state))
|
2015-09-30 18:22:42 +02:00
|
|
|
log_syntax(unit, LOG_ERR, filename, line, 0, "Trailing garbage, ignoring.");
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-17 00:15:31 +02:00
|
|
|
static int config_parse_user(
|
|
|
|
const char *unit,
|
|
|
|
const char *filename,
|
|
|
|
unsigned line,
|
|
|
|
const char *section,
|
|
|
|
unsigned section_line,
|
|
|
|
const char *lvalue,
|
|
|
|
int ltype,
|
|
|
|
const char *rvalue,
|
|
|
|
void *data,
|
|
|
|
void *userdata) {
|
2013-01-29 04:34:38 +01:00
|
|
|
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i = data;
|
2014-06-17 00:15:31 +02:00
|
|
|
char *printed;
|
2013-09-17 17:03:46 +02:00
|
|
|
int r;
|
2013-01-29 04:34:38 +01:00
|
|
|
|
|
|
|
assert(filename);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
|
2013-09-17 17:03:46 +02:00
|
|
|
r = install_full_printf(i, rvalue, &printed);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2013-01-29 04:34:38 +01:00
|
|
|
|
|
|
|
free(i->user);
|
|
|
|
i->user = printed;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-17 00:15:31 +02:00
|
|
|
static int config_parse_default_instance(
|
|
|
|
const char *unit,
|
|
|
|
const char *filename,
|
|
|
|
unsigned line,
|
|
|
|
const char *section,
|
|
|
|
unsigned section_line,
|
|
|
|
const char *lvalue,
|
|
|
|
int ltype,
|
|
|
|
const char *rvalue,
|
|
|
|
void *data,
|
|
|
|
void *userdata) {
|
|
|
|
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i = data;
|
2014-06-17 00:15:31 +02:00
|
|
|
char *printed;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(filename);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
|
|
|
|
r = install_full_printf(i, rvalue, &printed);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2014-09-16 21:36:26 +02:00
|
|
|
if (!unit_instance_is_valid(printed)) {
|
|
|
|
free(printed);
|
2014-06-17 00:15:31 +02:00
|
|
|
return -EINVAL;
|
2014-09-16 21:36:26 +02:00
|
|
|
}
|
2014-06-17 00:15:31 +02:00
|
|
|
|
|
|
|
free(i->default_instance);
|
|
|
|
i->default_instance = printed;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
static int unit_file_load(
|
|
|
|
InstallContext *c,
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *info,
|
2011-07-22 04:21:18 +02:00
|
|
|
const char *path,
|
2014-06-17 01:37:54 +02:00
|
|
|
const char *root_dir,
|
2014-10-08 11:59:46 +02:00
|
|
|
bool allow_symlink,
|
2014-11-07 21:21:05 +01:00
|
|
|
bool load,
|
|
|
|
bool *also) {
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2011-08-01 00:43:05 +02:00
|
|
|
const ConfigTableItem items[] = {
|
2014-06-17 00:15:31 +02:00
|
|
|
{ "Install", "Alias", config_parse_strv, 0, &info->aliases },
|
|
|
|
{ "Install", "WantedBy", config_parse_strv, 0, &info->wanted_by },
|
|
|
|
{ "Install", "RequiredBy", config_parse_strv, 0, &info->required_by },
|
|
|
|
{ "Install", "DefaultInstance", config_parse_default_instance, 0, info },
|
|
|
|
{ "Install", "Also", config_parse_also, 0, c },
|
|
|
|
{ "Exec", "User", config_parse_user, 0, info },
|
|
|
|
{}
|
2011-07-22 04:21:18 +02:00
|
|
|
};
|
|
|
|
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_fclose_ FILE *f = NULL;
|
2014-06-17 01:37:54 +02:00
|
|
|
int fd, r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
assert(c);
|
|
|
|
assert(info);
|
|
|
|
assert(path);
|
|
|
|
|
2014-06-17 01:37:54 +02:00
|
|
|
if (!isempty(root_dir))
|
2015-02-03 02:05:59 +01:00
|
|
|
path = strjoina(root_dir, "/", path);
|
2014-06-17 01:37:54 +02:00
|
|
|
|
2014-10-08 11:59:46 +02:00
|
|
|
if (!load) {
|
|
|
|
r = access(path, F_OK) ? -errno : 0;
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|(allow_symlink ? 0 : O_NOFOLLOW));
|
|
|
|
if (fd < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
f = fdopen(fd, "re");
|
|
|
|
if (!f) {
|
2014-03-18 19:22:43 +01:00
|
|
|
safe_close(fd);
|
2011-07-22 04:21:18 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2014-07-17 00:27:12 +02:00
|
|
|
r = config_parse(NULL, path, f,
|
|
|
|
NULL,
|
|
|
|
config_item_table_lookup, items,
|
|
|
|
true, true, false, info);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2014-11-07 21:21:05 +01:00
|
|
|
if (also)
|
|
|
|
*also = !strv_isempty(info->also);
|
|
|
|
|
2012-05-21 15:27:26 +02:00
|
|
|
return
|
2013-12-25 17:46:45 +01:00
|
|
|
(int) strv_length(info->aliases) +
|
|
|
|
(int) strv_length(info->wanted_by) +
|
|
|
|
(int) strv_length(info->required_by);
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int unit_file_search(
|
|
|
|
InstallContext *c,
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *info,
|
2015-03-15 02:46:59 +01:00
|
|
|
const LookupPaths *paths,
|
2011-07-22 04:21:18 +02:00
|
|
|
const char *root_dir,
|
2014-10-08 11:59:46 +02:00
|
|
|
bool allow_symlink,
|
2014-11-07 21:21:05 +01:00
|
|
|
bool load,
|
|
|
|
bool *also) {
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
char **p;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(c);
|
|
|
|
assert(info);
|
|
|
|
assert(paths);
|
|
|
|
|
2014-06-17 01:37:54 +02:00
|
|
|
if (info->path)
|
2014-11-07 21:21:05 +01:00
|
|
|
return unit_file_load(c, info, info->path, root_dir, allow_symlink, load, also);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
assert(info->name);
|
|
|
|
|
|
|
|
STRV_FOREACH(p, paths->unit_path) {
|
2014-06-17 00:13:48 +02:00
|
|
|
_cleanup_free_ char *path = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-17 01:37:54 +02:00
|
|
|
path = strjoin(*p, "/", info->name, NULL);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-11-07 21:21:05 +01:00
|
|
|
r = unit_file_load(c, info, path, root_dir, allow_symlink, load, also);
|
2014-04-22 01:17:40 +02:00
|
|
|
if (r >= 0) {
|
2011-07-22 04:21:18 +02:00
|
|
|
info->path = path;
|
2014-04-22 01:17:40 +02:00
|
|
|
path = NULL;
|
2014-06-17 00:13:48 +02:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
if (r != -ENOENT && r != -ELOOP)
|
|
|
|
return r;
|
|
|
|
}
|
2014-04-22 01:17:40 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (unit_name_is_valid(info->name, UNIT_NAME_INSTANCE)) {
|
2012-07-13 15:59:26 +02:00
|
|
|
|
2014-06-17 00:13:48 +02:00
|
|
|
/* Unit file doesn't exist, however instance
|
|
|
|
* enablement was requested. We will check if it is
|
|
|
|
* possible to load template unit file. */
|
2012-07-13 15:59:26 +02:00
|
|
|
|
2014-06-17 21:22:01 +02:00
|
|
|
_cleanup_free_ char *template = NULL;
|
2014-06-17 00:13:48 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_template(info->name, &template);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2014-06-17 00:13:48 +02:00
|
|
|
|
|
|
|
STRV_FOREACH(p, paths->unit_path) {
|
|
|
|
_cleanup_free_ char *path = NULL;
|
|
|
|
|
2014-06-17 01:37:54 +02:00
|
|
|
path = strjoin(*p, "/", template, NULL);
|
2014-04-22 01:17:40 +02:00
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
2012-07-13 15:59:26 +02:00
|
|
|
|
2014-11-07 21:21:05 +01:00
|
|
|
r = unit_file_load(c, info, path, root_dir, allow_symlink, load, also);
|
2014-04-22 01:17:40 +02:00
|
|
|
if (r >= 0) {
|
|
|
|
info->path = path;
|
|
|
|
path = NULL;
|
2014-06-17 00:13:48 +02:00
|
|
|
return r;
|
2012-07-13 15:59:26 +02:00
|
|
|
}
|
2014-06-17 00:13:48 +02:00
|
|
|
if (r != -ENOENT && r != -ELOOP)
|
|
|
|
return r;
|
2012-07-13 15:59:26 +02:00
|
|
|
}
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int unit_file_can_install(
|
2015-03-15 02:46:59 +01:00
|
|
|
const LookupPaths *paths,
|
2011-07-22 04:21:18 +02:00
|
|
|
const char *root_dir,
|
|
|
|
const char *name,
|
2014-11-07 21:21:05 +01:00
|
|
|
bool allow_symlink,
|
|
|
|
bool *also) {
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-08-21 19:08:30 +02:00
|
|
|
_cleanup_(install_context_done) InstallContext c = {};
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i;
|
2011-07-22 04:21:18 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(paths);
|
|
|
|
assert(name);
|
|
|
|
|
|
|
|
r = install_info_add_auto(&c, name);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2014-08-22 10:35:59 +02:00
|
|
|
assert_se(i = ordered_hashmap_first(c.will_install));
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-11-07 21:21:05 +01:00
|
|
|
r = unit_file_search(&c, i, paths, root_dir, allow_symlink, true, also);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
if (r >= 0)
|
2012-05-21 15:27:26 +02:00
|
|
|
r =
|
2013-12-25 17:46:45 +01:00
|
|
|
(int) strv_length(i->aliases) +
|
|
|
|
(int) strv_length(i->wanted_by) +
|
|
|
|
(int) strv_length(i->required_by);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int create_symlink(
|
|
|
|
const char *old_path,
|
|
|
|
const char *new_path,
|
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *dest = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(old_path);
|
|
|
|
assert(new_path);
|
|
|
|
|
2012-05-31 12:40:20 +02:00
|
|
|
mkdir_parents_label(new_path, 0755);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
if (symlink(old_path, new_path) >= 0) {
|
2015-05-15 09:54:10 +02:00
|
|
|
unit_file_changes_add(changes, n_changes, UNIT_FILE_SYMLINK, new_path, old_path);
|
2011-07-22 04:21:18 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (errno != EEXIST)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
r = readlink_and_make_absolute(new_path, &dest);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2013-01-29 02:33:10 +01:00
|
|
|
if (path_equal(dest, old_path))
|
2011-07-22 04:21:18 +02:00
|
|
|
return 0;
|
|
|
|
|
2012-05-15 08:12:49 +02:00
|
|
|
if (!force)
|
2011-07-22 04:21:18 +02:00
|
|
|
return -EEXIST;
|
|
|
|
|
2014-06-17 00:11:47 +02:00
|
|
|
r = symlink_atomic(old_path, new_path);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2015-05-15 09:54:10 +02:00
|
|
|
unit_file_changes_add(changes, n_changes, UNIT_FILE_UNLINK, new_path, NULL);
|
|
|
|
unit_file_changes_add(changes, n_changes, UNIT_FILE_SYMLINK, new_path, old_path);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-17 00:11:47 +02:00
|
|
|
return 0;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int install_info_symlink_alias(
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i,
|
2011-07-22 04:21:18 +02:00
|
|
|
const char *config_path,
|
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
|
|
|
char **s;
|
|
|
|
int r = 0, q;
|
|
|
|
|
|
|
|
assert(i);
|
|
|
|
assert(config_path);
|
|
|
|
|
|
|
|
STRV_FOREACH(s, i->aliases) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *alias_path = NULL, *dst = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2013-09-17 17:03:46 +02:00
|
|
|
q = install_full_printf(i, *s, &dst);
|
|
|
|
if (q < 0)
|
|
|
|
return q;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2013-01-28 05:11:31 +01:00
|
|
|
alias_path = path_make_absolute(dst, config_path);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (!alias_path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
q = create_symlink(i->path, alias_path, force, changes, n_changes);
|
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int install_info_symlink_wants(
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i,
|
2011-07-22 04:21:18 +02:00
|
|
|
const char *config_path,
|
2014-06-17 00:15:31 +02:00
|
|
|
char **list,
|
|
|
|
const char *suffix,
|
2011-07-22 04:21:18 +02:00
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
2014-06-17 00:15:31 +02:00
|
|
|
_cleanup_free_ char *buf = NULL;
|
|
|
|
const char *n;
|
2011-07-22 04:21:18 +02:00
|
|
|
char **s;
|
|
|
|
int r = 0, q;
|
|
|
|
|
|
|
|
assert(i);
|
|
|
|
assert(config_path);
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (unit_name_is_valid(i->name, UNIT_NAME_TEMPLATE)) {
|
2014-06-17 01:22:55 +02:00
|
|
|
|
|
|
|
/* Don't install any symlink if there's no default
|
|
|
|
* instance configured */
|
|
|
|
|
|
|
|
if (!i->default_instance)
|
|
|
|
return 0;
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_replace_instance(i->name, i->default_instance, &buf);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-17 00:15:31 +02:00
|
|
|
n = buf;
|
|
|
|
} else
|
|
|
|
n = i->name;
|
2012-05-21 15:27:26 +02:00
|
|
|
|
2014-06-17 00:15:31 +02:00
|
|
|
STRV_FOREACH(s, list) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *path = NULL, *dst = NULL;
|
2012-05-21 15:27:26 +02:00
|
|
|
|
2013-09-17 17:03:46 +02:00
|
|
|
q = install_full_printf(i, *s, &dst);
|
|
|
|
if (q < 0)
|
|
|
|
return q;
|
2013-01-28 05:11:31 +01:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!unit_name_is_valid(dst, UNIT_NAME_ANY)) {
|
2012-05-21 15:27:26 +02:00
|
|
|
r = -EINVAL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-06-17 00:15:31 +02:00
|
|
|
path = strjoin(config_path, "/", dst, suffix, n, NULL);
|
|
|
|
if (!path)
|
2012-05-21 15:27:26 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
q = create_symlink(i->path, path, force, changes, n_changes);
|
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
static int install_info_symlink_link(
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i,
|
2015-03-15 02:46:59 +01:00
|
|
|
const LookupPaths *paths,
|
2011-07-22 04:21:18 +02:00
|
|
|
const char *config_path,
|
2014-06-17 00:53:49 +02:00
|
|
|
const char *root_dir,
|
2011-07-22 04:21:18 +02:00
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *path = NULL;
|
2014-06-17 00:10:54 +02:00
|
|
|
int r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
assert(i);
|
|
|
|
assert(paths);
|
|
|
|
assert(config_path);
|
|
|
|
assert(i->path);
|
|
|
|
|
2014-06-17 01:37:54 +02:00
|
|
|
r = in_search_path(i->path, paths->unit_path);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r != 0)
|
|
|
|
return r;
|
|
|
|
|
2014-06-17 00:10:54 +02:00
|
|
|
path = strjoin(config_path, "/", i->name, NULL);
|
|
|
|
if (!path)
|
2011-07-22 04:21:18 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2014-06-17 00:10:54 +02:00
|
|
|
return create_symlink(i->path, path, force, changes, n_changes);
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int install_info_apply(
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i,
|
2015-03-15 02:46:59 +01:00
|
|
|
const LookupPaths *paths,
|
2011-07-22 04:21:18 +02:00
|
|
|
const char *config_path,
|
2014-06-17 00:53:49 +02:00
|
|
|
const char *root_dir,
|
2011-07-22 04:21:18 +02:00
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
|
|
|
int r, q;
|
|
|
|
|
|
|
|
assert(i);
|
|
|
|
assert(paths);
|
|
|
|
assert(config_path);
|
|
|
|
|
|
|
|
r = install_info_symlink_alias(i, config_path, force, changes, n_changes);
|
|
|
|
|
2014-06-17 00:15:31 +02:00
|
|
|
q = install_info_symlink_wants(i, config_path, i->wanted_by, ".wants/", force, changes, n_changes);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
|
2014-06-17 00:15:31 +02:00
|
|
|
q = install_info_symlink_wants(i, config_path, i->required_by, ".requires/", force, changes, n_changes);
|
2012-05-21 15:27:26 +02:00
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
|
2014-06-17 00:53:49 +02:00
|
|
|
q = install_info_symlink_link(i, paths, config_path, root_dir, force, changes, n_changes);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int install_context_apply(
|
|
|
|
InstallContext *c,
|
2015-03-15 02:46:59 +01:00
|
|
|
const LookupPaths *paths,
|
2011-07-22 04:21:18 +02:00
|
|
|
const char *config_path,
|
|
|
|
const char *root_dir,
|
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i;
|
2014-10-04 21:29:10 +02:00
|
|
|
int r, q;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
assert(c);
|
|
|
|
assert(paths);
|
|
|
|
assert(config_path);
|
|
|
|
|
2014-10-04 21:29:10 +02:00
|
|
|
if (!ordered_hashmap_isempty(c->will_install)) {
|
|
|
|
r = ordered_hashmap_ensure_allocated(&c->have_installed, &string_hash_ops);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-10-04 21:29:10 +02:00
|
|
|
r = ordered_hashmap_reserve(c->have_installed, ordered_hashmap_size(c->will_install));
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-10-04 21:29:10 +02:00
|
|
|
r = 0;
|
|
|
|
while ((i = ordered_hashmap_first(c->will_install))) {
|
2014-08-22 10:35:59 +02:00
|
|
|
assert_se(ordered_hashmap_move_one(c->have_installed, c->will_install, i->name) == 0);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-11-07 21:21:05 +01:00
|
|
|
q = unit_file_search(c, i, paths, root_dir, false, true, NULL);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (q < 0) {
|
|
|
|
if (r >= 0)
|
|
|
|
r = q;
|
|
|
|
|
|
|
|
return r;
|
|
|
|
} else if (r >= 0)
|
|
|
|
r += q;
|
|
|
|
|
2014-06-17 00:53:49 +02:00
|
|
|
q = install_info_apply(i, paths, config_path, root_dir, force, changes, n_changes);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r >= 0 && q < 0)
|
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int install_context_mark_for_removal(
|
|
|
|
InstallContext *c,
|
2015-03-15 02:46:59 +01:00
|
|
|
const LookupPaths *paths,
|
2011-07-22 04:21:18 +02:00
|
|
|
Set **remove_symlinks_to,
|
|
|
|
const char *config_path,
|
|
|
|
const char *root_dir) {
|
|
|
|
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i;
|
2014-10-04 21:29:10 +02:00
|
|
|
int r, q;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
assert(c);
|
|
|
|
assert(paths);
|
|
|
|
assert(config_path);
|
|
|
|
|
|
|
|
/* Marks all items for removal */
|
|
|
|
|
2014-10-04 21:29:10 +02:00
|
|
|
if (!ordered_hashmap_isempty(c->will_install)) {
|
|
|
|
r = ordered_hashmap_ensure_allocated(&c->have_installed, &string_hash_ops);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-10-04 21:29:10 +02:00
|
|
|
r = ordered_hashmap_reserve(c->have_installed, ordered_hashmap_size(c->will_install));
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-10-04 21:29:10 +02:00
|
|
|
r = 0;
|
|
|
|
while ((i = ordered_hashmap_first(c->will_install))) {
|
2014-08-22 10:35:59 +02:00
|
|
|
assert_se(ordered_hashmap_move_one(c->have_installed, c->will_install, i->name) == 0);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-11-07 21:21:05 +01:00
|
|
|
q = unit_file_search(c, i, paths, root_dir, false, true, NULL);
|
2013-06-03 19:55:13 +02:00
|
|
|
if (q == -ENOENT) {
|
|
|
|
/* do nothing */
|
|
|
|
} else if (q < 0) {
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r >= 0)
|
|
|
|
r = q;
|
|
|
|
|
|
|
|
return r;
|
|
|
|
} else if (r >= 0)
|
|
|
|
r += q;
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (unit_name_is_valid(i->name, UNIT_NAME_INSTANCE)) {
|
systemd: fix NULL dereference when disabling a nonexistent instance
Assertion 'p' failed at src/shared/path-util.c:51, function path_get_file_name(). Aborting.
The unit file could not be found, and i->path would not be set.
In 02b9e969 a code path was added which attempts to remove symlinks
to a nonexistent (removed) unit file. This worked OK in case of
non-instance services, but broke in the case of instance services.
Behaviour wrt. to instance units is changed in the way that 02b9e969
changed it for non-instance units: it is now possible to remove
instance symlinks to a template unit that has been removed.
This patch isn't a full fix, because the behaviour wrt. to enabling
and disabling instance units is still broken: e.g it is possible to
start autovt@tty5.service, but it is not possible to enable it,
because autovt@.service is a symlink, and on the other hand, disabling
getty@tty5.service removes all symlinks to getty@.service, which is
wrong too. But segfaults make bad pr, so let's add at least this
partial fix for now.
2013-07-15 05:36:14 +02:00
|
|
|
char *unit_file;
|
|
|
|
|
|
|
|
if (i->path) {
|
2013-12-07 03:29:55 +01:00
|
|
|
unit_file = basename(i->path);
|
systemd: fix NULL dereference when disabling a nonexistent instance
Assertion 'p' failed at src/shared/path-util.c:51, function path_get_file_name(). Aborting.
The unit file could not be found, and i->path would not be set.
In 02b9e969 a code path was added which attempts to remove symlinks
to a nonexistent (removed) unit file. This worked OK in case of
non-instance services, but broke in the case of instance services.
Behaviour wrt. to instance units is changed in the way that 02b9e969
changed it for non-instance units: it is now possible to remove
instance symlinks to a template unit that has been removed.
This patch isn't a full fix, because the behaviour wrt. to enabling
and disabling instance units is still broken: e.g it is possible to
start autovt@tty5.service, but it is not possible to enable it,
because autovt@.service is a symlink, and on the other hand, disabling
getty@tty5.service removes all symlinks to getty@.service, which is
wrong too. But segfaults make bad pr, so let's add at least this
partial fix for now.
2013-07-15 05:36:14 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (unit_name_is_valid(unit_file, UNIT_NAME_INSTANCE))
|
systemd: fix NULL dereference when disabling a nonexistent instance
Assertion 'p' failed at src/shared/path-util.c:51, function path_get_file_name(). Aborting.
The unit file could not be found, and i->path would not be set.
In 02b9e969 a code path was added which attempts to remove symlinks
to a nonexistent (removed) unit file. This worked OK in case of
non-instance services, but broke in the case of instance services.
Behaviour wrt. to instance units is changed in the way that 02b9e969
changed it for non-instance units: it is now possible to remove
instance symlinks to a template unit that has been removed.
This patch isn't a full fix, because the behaviour wrt. to enabling
and disabling instance units is still broken: e.g it is possible to
start autovt@tty5.service, but it is not possible to enable it,
because autovt@.service is a symlink, and on the other hand, disabling
getty@tty5.service removes all symlinks to getty@.service, which is
wrong too. But segfaults make bad pr, so let's add at least this
partial fix for now.
2013-07-15 05:36:14 +02:00
|
|
|
/* unit file named as instance exists, thus all symlinks
|
|
|
|
* pointing to it will be removed */
|
|
|
|
q = mark_symlink_for_removal(remove_symlinks_to, i->name);
|
|
|
|
else
|
|
|
|
/* does not exist, thus we will mark for removal symlinks
|
|
|
|
* to template unit file */
|
|
|
|
q = mark_symlink_for_removal(remove_symlinks_to, unit_file);
|
|
|
|
} else {
|
|
|
|
/* If i->path is not set, it means that we didn't actually find
|
|
|
|
* the unit file. But we can still remove symlinks to the
|
|
|
|
* nonexistent template. */
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_template(i->name, &unit_file);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2012-07-13 15:59:26 +02:00
|
|
|
|
|
|
|
q = mark_symlink_for_removal(remove_symlinks_to, unit_file);
|
systemd: fix NULL dereference when disabling a nonexistent instance
Assertion 'p' failed at src/shared/path-util.c:51, function path_get_file_name(). Aborting.
The unit file could not be found, and i->path would not be set.
In 02b9e969 a code path was added which attempts to remove symlinks
to a nonexistent (removed) unit file. This worked OK in case of
non-instance services, but broke in the case of instance services.
Behaviour wrt. to instance units is changed in the way that 02b9e969
changed it for non-instance units: it is now possible to remove
instance symlinks to a template unit that has been removed.
This patch isn't a full fix, because the behaviour wrt. to enabling
and disabling instance units is still broken: e.g it is possible to
start autovt@tty5.service, but it is not possible to enable it,
because autovt@.service is a symlink, and on the other hand, disabling
getty@tty5.service removes all symlinks to getty@.service, which is
wrong too. But segfaults make bad pr, so let's add at least this
partial fix for now.
2013-07-15 05:36:14 +02:00
|
|
|
free(unit_file);
|
|
|
|
}
|
2012-07-13 15:59:26 +02:00
|
|
|
} else
|
|
|
|
q = mark_symlink_for_removal(remove_symlinks_to, i->name);
|
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r >= 0 && q < 0)
|
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2014-10-08 11:59:46 +02:00
|
|
|
int unit_file_add_dependency(
|
|
|
|
UnitFileScope scope,
|
|
|
|
bool runtime,
|
|
|
|
const char *root_dir,
|
|
|
|
char **files,
|
|
|
|
char *target,
|
|
|
|
UnitDependency dep,
|
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
|
|
|
_cleanup_lookup_paths_free_ LookupPaths paths = {};
|
|
|
|
_cleanup_(install_context_done) InstallContext c = {};
|
|
|
|
_cleanup_free_ char *config_path = NULL;
|
|
|
|
char **i;
|
|
|
|
int r;
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *info;
|
2014-10-08 11:59:46 +02:00
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
|
|
|
|
|
|
|
r = lookup_paths_init_from_scope(&paths, scope, root_dir);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = get_config_path(scope, runtime, root_dir, &config_path);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
STRV_FOREACH(i, files) {
|
|
|
|
UnitFileState state;
|
|
|
|
|
|
|
|
state = unit_file_get_state(scope, root_dir, *i);
|
2014-11-28 18:50:43 +01:00
|
|
|
if (state < 0)
|
|
|
|
return log_error_errno(state, "Failed to get unit file state for %s: %m", *i);
|
2014-10-08 11:59:46 +02:00
|
|
|
|
|
|
|
if (state == UNIT_FILE_MASKED || state == UNIT_FILE_MASKED_RUNTIME) {
|
|
|
|
log_error("Failed to enable unit: Unit %s is masked", *i);
|
2015-03-13 14:08:00 +01:00
|
|
|
return -EOPNOTSUPP;
|
2014-10-08 11:59:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
r = install_info_add_auto(&c, *i);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2014-10-04 21:29:10 +02:00
|
|
|
if (!ordered_hashmap_isempty(c.will_install)) {
|
2014-08-22 10:35:59 +02:00
|
|
|
r = ordered_hashmap_ensure_allocated(&c.have_installed, &string_hash_ops);
|
2014-10-08 11:59:46 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2014-10-04 21:29:10 +02:00
|
|
|
r = ordered_hashmap_reserve(c.have_installed, ordered_hashmap_size(c.will_install));
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
while ((info = ordered_hashmap_first(c.will_install))) {
|
2014-08-22 10:35:59 +02:00
|
|
|
assert_se(ordered_hashmap_move_one(c.have_installed, c.will_install, info->name) == 0);
|
2014-10-08 11:59:46 +02:00
|
|
|
|
2014-11-07 21:21:05 +01:00
|
|
|
r = unit_file_search(&c, info, &paths, root_dir, false, false, NULL);
|
2014-10-08 11:59:46 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (dep == UNIT_WANTS)
|
|
|
|
r = strv_extend(&info->wanted_by, target);
|
|
|
|
else if (dep == UNIT_REQUIRES)
|
|
|
|
r = strv_extend(&info->required_by, target);
|
|
|
|
else
|
|
|
|
r = -EINVAL;
|
|
|
|
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = install_info_apply(info, &paths, config_path, root_dir, force, changes, n_changes);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
int unit_file_enable(
|
|
|
|
UnitFileScope scope,
|
|
|
|
bool runtime,
|
|
|
|
const char *root_dir,
|
2013-12-27 06:16:39 +01:00
|
|
|
char **files,
|
2011-07-22 04:21:18 +02:00
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_lookup_paths_free_ LookupPaths paths = {};
|
2014-08-21 19:08:30 +02:00
|
|
|
_cleanup_(install_context_done) InstallContext c = {};
|
2013-01-29 02:33:10 +01:00
|
|
|
char **i;
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *config_path = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
|
|
|
|
2014-04-24 07:44:10 +02:00
|
|
|
r = lookup_paths_init_from_scope(&paths, scope, root_dir);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = get_config_path(scope, runtime, root_dir, &config_path);
|
|
|
|
if (r < 0)
|
2013-01-29 02:33:10 +01:00
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
STRV_FOREACH(i, files) {
|
2014-10-07 13:35:41 +02:00
|
|
|
UnitFileState state;
|
|
|
|
|
2014-10-31 01:12:05 +01:00
|
|
|
/* We only want to know if this unit is masked, so we ignore
|
|
|
|
* errors from unit_file_get_state, deferring other checks.
|
|
|
|
* This allows templated units to be enabled on the fly. */
|
2014-10-07 13:35:41 +02:00
|
|
|
state = unit_file_get_state(scope, root_dir, *i);
|
|
|
|
if (state == UNIT_FILE_MASKED || state == UNIT_FILE_MASKED_RUNTIME) {
|
|
|
|
log_error("Failed to enable unit: Unit %s is masked", *i);
|
2015-03-13 14:08:00 +01:00
|
|
|
return -EOPNOTSUPP;
|
2014-10-07 13:35:41 +02:00
|
|
|
}
|
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
r = install_info_add_auto(&c, *i);
|
|
|
|
if (r < 0)
|
2013-01-29 02:33:10 +01:00
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
2011-07-25 04:58:02 +02:00
|
|
|
/* This will return the number of symlink rules that were
|
|
|
|
supposed to be created, not the ones actually created. This is
|
2012-10-17 16:06:51 +02:00
|
|
|
useful to determine whether the passed files had any
|
2011-07-25 04:58:02 +02:00
|
|
|
installation data at all. */
|
2014-04-23 06:57:34 +02:00
|
|
|
|
|
|
|
return install_context_apply(&c, &paths, config_path, root_dir, force, changes, n_changes);
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int unit_file_disable(
|
|
|
|
UnitFileScope scope,
|
|
|
|
bool runtime,
|
|
|
|
const char *root_dir,
|
2013-12-27 06:16:39 +01:00
|
|
|
char **files,
|
2011-07-22 04:21:18 +02:00
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_lookup_paths_free_ LookupPaths paths = {};
|
2014-08-21 19:08:30 +02:00
|
|
|
_cleanup_(install_context_done) InstallContext c = {};
|
2013-01-29 02:33:10 +01:00
|
|
|
char **i;
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *config_path = NULL;
|
|
|
|
_cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
int r, q;
|
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
|
|
|
|
2014-04-24 07:44:10 +02:00
|
|
|
r = lookup_paths_init_from_scope(&paths, scope, root_dir);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = get_config_path(scope, runtime, root_dir, &config_path);
|
|
|
|
if (r < 0)
|
2013-01-29 02:33:10 +01:00
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
STRV_FOREACH(i, files) {
|
|
|
|
r = install_info_add_auto(&c, *i);
|
|
|
|
if (r < 0)
|
2013-01-29 02:33:10 +01:00
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
r = install_context_mark_for_removal(&c, &paths, &remove_symlinks_to, config_path, root_dir);
|
|
|
|
|
2012-07-13 15:59:26 +02:00
|
|
|
q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
|
2014-10-25 21:15:28 +02:00
|
|
|
if (r >= 0)
|
2011-07-22 21:01:15 +02:00
|
|
|
r = q;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
int unit_file_reenable(
|
|
|
|
UnitFileScope scope,
|
|
|
|
bool runtime,
|
|
|
|
const char *root_dir,
|
2013-12-27 06:16:39 +01:00
|
|
|
char **files,
|
2011-07-22 04:21:18 +02:00
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
2013-06-17 20:11:50 +02:00
|
|
|
int r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2013-06-17 20:11:50 +02:00
|
|
|
r = unit_file_disable(scope, runtime, root_dir, files,
|
|
|
|
changes, n_changes);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
2013-01-29 02:33:10 +01:00
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2013-06-17 20:11:50 +02:00
|
|
|
return unit_file_enable(scope, runtime, root_dir, files, force,
|
|
|
|
changes, n_changes);
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
2013-05-28 11:05:48 +02:00
|
|
|
int unit_file_set_default(
|
|
|
|
UnitFileScope scope,
|
|
|
|
const char *root_dir,
|
2013-11-19 01:09:12 +01:00
|
|
|
const char *file,
|
2013-11-19 21:12:59 +01:00
|
|
|
bool force,
|
2013-05-28 11:05:48 +02:00
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
|
|
|
_cleanup_lookup_paths_free_ LookupPaths paths = {};
|
2014-08-21 19:08:30 +02:00
|
|
|
_cleanup_(install_context_done) InstallContext c = {};
|
2013-05-28 11:05:48 +02:00
|
|
|
_cleanup_free_ char *config_path = NULL;
|
|
|
|
char *path;
|
|
|
|
int r;
|
2015-05-11 22:53:54 +02:00
|
|
|
UnitFileInstallInfo *i = NULL;
|
2013-05-28 11:05:48 +02:00
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
2013-11-19 01:09:12 +01:00
|
|
|
assert(file);
|
2013-05-28 11:05:48 +02:00
|
|
|
|
|
|
|
if (unit_name_to_type(file) != UNIT_TARGET)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-04-24 07:44:10 +02:00
|
|
|
r = lookup_paths_init_from_scope(&paths, scope, root_dir);
|
2013-05-28 11:05:48 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = get_config_path(scope, false, root_dir, &config_path);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = install_info_add_auto(&c, file);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2014-08-22 10:35:59 +02:00
|
|
|
assert_se(i = ordered_hashmap_first(c.will_install));
|
2013-05-28 11:05:48 +02:00
|
|
|
|
2014-11-07 21:21:05 +01:00
|
|
|
r = unit_file_search(&c, i, &paths, root_dir, false, true, NULL);
|
2013-05-28 11:05:48 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2015-02-03 02:05:59 +01:00
|
|
|
path = strjoina(config_path, "/" SPECIAL_DEFAULT_TARGET);
|
2013-11-19 01:09:12 +01:00
|
|
|
|
2013-11-19 21:12:59 +01:00
|
|
|
r = create_symlink(i->path, path, force, changes, n_changes);
|
2013-05-28 11:05:48 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int unit_file_get_default(
|
|
|
|
UnitFileScope scope,
|
|
|
|
const char *root_dir,
|
|
|
|
char **name) {
|
|
|
|
|
|
|
|
_cleanup_lookup_paths_free_ LookupPaths paths = {};
|
|
|
|
char **p;
|
|
|
|
int r;
|
|
|
|
|
2013-11-19 01:09:12 +01:00
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
|
|
|
assert(name);
|
|
|
|
|
2014-04-24 07:44:10 +02:00
|
|
|
r = lookup_paths_init_from_scope(&paths, scope, root_dir);
|
2013-05-28 11:05:48 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
STRV_FOREACH(p, paths.unit_path) {
|
|
|
|
_cleanup_free_ char *path = NULL, *tmp = NULL;
|
2013-11-08 13:54:18 +01:00
|
|
|
char *n;
|
2013-05-28 11:05:48 +02:00
|
|
|
|
2014-07-26 20:47:31 +02:00
|
|
|
path = path_join(root_dir, *p, SPECIAL_DEFAULT_TARGET);
|
2013-05-28 11:05:48 +02:00
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
r = readlink_malloc(path, &tmp);
|
|
|
|
if (r == -ENOENT)
|
|
|
|
continue;
|
2013-11-19 21:02:16 +01:00
|
|
|
else if (r == -EINVAL)
|
|
|
|
/* not a symlink */
|
|
|
|
n = strdup(SPECIAL_DEFAULT_TARGET);
|
|
|
|
else if (r < 0)
|
2013-05-28 11:05:48 +02:00
|
|
|
return r;
|
2013-11-19 21:02:16 +01:00
|
|
|
else
|
2013-12-07 03:29:55 +01:00
|
|
|
n = strdup(basename(tmp));
|
2013-05-28 11:05:48 +02:00
|
|
|
|
2013-11-08 13:54:18 +01:00
|
|
|
if (!n)
|
2013-05-28 11:05:48 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-11-08 13:54:18 +01:00
|
|
|
*name = n;
|
2013-05-28 11:05:48 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
2015-03-15 02:46:59 +01:00
|
|
|
UnitFileState unit_file_lookup_state(
|
2011-07-22 04:21:18 +02:00
|
|
|
UnitFileScope scope,
|
|
|
|
const char *root_dir,
|
2015-03-15 02:46:59 +01:00
|
|
|
const LookupPaths *paths,
|
2011-07-22 04:21:18 +02:00
|
|
|
const char *name) {
|
|
|
|
|
|
|
|
UnitFileState state = _UNIT_FILE_STATE_INVALID;
|
2013-01-29 02:33:10 +01:00
|
|
|
char **i;
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char *path = NULL;
|
2015-03-27 12:02:49 +01:00
|
|
|
int r = 0;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2015-03-15 02:46:59 +01:00
|
|
|
assert(paths);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!unit_name_is_valid(name, UNIT_NAME_ANY))
|
2011-07-22 04:21:18 +02:00
|
|
|
return -EINVAL;
|
|
|
|
|
2015-03-15 02:46:59 +01:00
|
|
|
STRV_FOREACH(i, paths->unit_path) {
|
2011-07-22 04:21:18 +02:00
|
|
|
struct stat st;
|
2014-04-24 07:44:10 +02:00
|
|
|
char *partial;
|
2014-11-07 21:21:05 +01:00
|
|
|
bool also = false;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
free(path);
|
2014-07-26 20:47:31 +02:00
|
|
|
path = path_join(root_dir, *i, name);
|
2013-01-29 02:33:10 +01:00
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-04-24 07:44:10 +02:00
|
|
|
if (root_dir)
|
2014-07-26 20:47:31 +02:00
|
|
|
partial = path + strlen(root_dir);
|
2014-04-24 07:44:10 +02:00
|
|
|
else
|
|
|
|
partial = path;
|
|
|
|
|
2013-05-19 15:45:48 +02:00
|
|
|
/*
|
|
|
|
* Search for a unit file in our default paths, to
|
|
|
|
* be sure, that there are no broken symlinks.
|
|
|
|
*/
|
2011-07-22 04:21:18 +02:00
|
|
|
if (lstat(path, &st) < 0) {
|
2012-02-09 10:36:56 +01:00
|
|
|
r = -errno;
|
2013-05-19 15:45:48 +02:00
|
|
|
if (errno != ENOENT)
|
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!unit_name_is_valid(name, UNIT_NAME_INSTANCE))
|
2013-05-19 15:45:48 +02:00
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
if (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode))
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
r = null_or_empty_path(path);
|
|
|
|
if (r < 0 && r != -ENOENT)
|
|
|
|
return r;
|
|
|
|
else if (r > 0) {
|
2015-04-30 20:21:00 +02:00
|
|
|
state = path_startswith(*i, "/run") ? UNIT_FILE_MASKED_RUNTIME : UNIT_FILE_MASKED;
|
2013-05-19 15:45:48 +02:00
|
|
|
return state;
|
|
|
|
}
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
r = find_symlinks_in_scope(scope, root_dir, name, &state);
|
2013-01-29 02:33:10 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
else if (r > 0)
|
|
|
|
return state;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2015-03-15 02:46:59 +01:00
|
|
|
r = unit_file_can_install(paths, root_dir, partial, true, &also);
|
2013-04-12 00:57:42 +02:00
|
|
|
if (r < 0 && errno != ENOENT)
|
2013-01-29 02:33:10 +01:00
|
|
|
return r;
|
|
|
|
else if (r > 0)
|
|
|
|
return UNIT_FILE_DISABLED;
|
2014-11-07 21:21:05 +01:00
|
|
|
else if (r == 0) {
|
|
|
|
if (also)
|
|
|
|
return UNIT_FILE_INDIRECT;
|
2013-01-29 02:33:10 +01:00
|
|
|
return UNIT_FILE_STATIC;
|
2014-11-07 21:21:05 +01:00
|
|
|
}
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return r < 0 ? r : state;
|
|
|
|
}
|
|
|
|
|
2015-03-15 02:46:59 +01:00
|
|
|
UnitFileState unit_file_get_state(
|
|
|
|
UnitFileScope scope,
|
|
|
|
const char *root_dir,
|
|
|
|
const char *name) {
|
|
|
|
|
|
|
|
_cleanup_lookup_paths_free_ LookupPaths paths = {};
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
|
|
|
assert(name);
|
|
|
|
|
|
|
|
if (root_dir && scope != UNIT_FILE_SYSTEM)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
r = lookup_paths_init_from_scope(&paths, scope, root_dir);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return unit_file_lookup_state(scope, root_dir, &paths, name);
|
|
|
|
}
|
|
|
|
|
2014-06-16 20:33:29 +02:00
|
|
|
int unit_file_query_preset(UnitFileScope scope, const char *root_dir, const char *name) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_strv_free_ char **files = NULL;
|
2014-06-20 04:07:04 +02:00
|
|
|
char **p;
|
2011-07-22 04:21:18 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
|
|
|
assert(name);
|
|
|
|
|
|
|
|
if (scope == UNIT_FILE_SYSTEM)
|
2014-06-16 20:33:29 +02:00
|
|
|
r = conf_files_list(&files, ".preset", root_dir,
|
2012-06-27 14:34:24 +02:00
|
|
|
"/etc/systemd/system-preset",
|
|
|
|
"/usr/local/lib/systemd/system-preset",
|
|
|
|
"/usr/lib/systemd/system-preset",
|
2012-06-21 23:22:53 +02:00
|
|
|
#ifdef HAVE_SPLIT_USR
|
2012-06-27 14:34:24 +02:00
|
|
|
"/lib/systemd/system-preset",
|
2012-06-21 23:22:53 +02:00
|
|
|
#endif
|
2011-07-22 04:21:18 +02:00
|
|
|
NULL);
|
|
|
|
else if (scope == UNIT_FILE_GLOBAL)
|
2014-06-16 20:33:29 +02:00
|
|
|
r = conf_files_list(&files, ".preset", root_dir,
|
2012-06-27 14:34:24 +02:00
|
|
|
"/etc/systemd/user-preset",
|
|
|
|
"/usr/local/lib/systemd/user-preset",
|
|
|
|
"/usr/lib/systemd/user-preset",
|
2011-07-22 04:21:18 +02:00
|
|
|
NULL);
|
|
|
|
else
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2014-06-20 04:07:04 +02:00
|
|
|
STRV_FOREACH(p, files) {
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_fclose_ FILE *f;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-20 04:07:04 +02:00
|
|
|
f = fopen(*p, "re");
|
2011-07-22 04:21:18 +02:00
|
|
|
if (!f) {
|
|
|
|
if (errno == ENOENT)
|
|
|
|
continue;
|
|
|
|
|
2013-01-29 02:33:10 +01:00
|
|
|
return -errno;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
char line[LINE_MAX], *l;
|
|
|
|
|
|
|
|
if (!fgets(line, sizeof(line), f))
|
|
|
|
break;
|
|
|
|
|
|
|
|
l = strstrip(line);
|
|
|
|
if (!*l)
|
|
|
|
continue;
|
|
|
|
|
2013-04-14 02:22:53 +02:00
|
|
|
if (strchr(COMMENTS "\n", *l))
|
2011-07-22 04:21:18 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (first_word(l, "enable")) {
|
|
|
|
l += 6;
|
|
|
|
l += strspn(l, WHITESPACE);
|
|
|
|
|
2014-06-16 20:33:29 +02:00
|
|
|
if (fnmatch(l, name, FNM_NOESCAPE) == 0) {
|
|
|
|
log_debug("Preset file says enable %s.", name);
|
2013-01-29 02:33:10 +01:00
|
|
|
return 1;
|
2014-06-16 20:33:29 +02:00
|
|
|
}
|
2013-01-29 02:33:10 +01:00
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
} else if (first_word(l, "disable")) {
|
|
|
|
l += 7;
|
|
|
|
l += strspn(l, WHITESPACE);
|
|
|
|
|
2014-06-16 20:33:29 +02:00
|
|
|
if (fnmatch(l, name, FNM_NOESCAPE) == 0) {
|
|
|
|
log_debug("Preset file says disable %s.", name);
|
2013-01-29 02:33:10 +01:00
|
|
|
return 0;
|
2014-06-16 20:33:29 +02:00
|
|
|
}
|
2013-01-29 02:33:10 +01:00
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
} else
|
|
|
|
log_debug("Couldn't parse line '%s'", l);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Default is "enable" */
|
2014-06-16 20:33:29 +02:00
|
|
|
log_debug("Preset file doesn't say anything about %s, enabling.", name);
|
2013-01-29 02:33:10 +01:00
|
|
|
return 1;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int unit_file_preset(
|
|
|
|
UnitFileScope scope,
|
|
|
|
bool runtime,
|
|
|
|
const char *root_dir,
|
2013-12-27 06:16:39 +01:00
|
|
|
char **files,
|
2014-06-16 19:49:31 +02:00
|
|
|
UnitFilePresetMode mode,
|
2011-07-22 04:21:18 +02:00
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
2014-08-21 19:08:30 +02:00
|
|
|
_cleanup_(install_context_done) InstallContext plus = {}, minus = {};
|
2014-06-16 17:19:30 +02:00
|
|
|
_cleanup_lookup_paths_free_ LookupPaths paths = {};
|
|
|
|
_cleanup_free_ char *config_path = NULL;
|
|
|
|
char **i;
|
2011-07-22 04:21:18 +02:00
|
|
|
int r, q;
|
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
2014-07-10 04:29:24 +02:00
|
|
|
assert(mode < _UNIT_FILE_PRESET_MAX);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-04-24 07:44:10 +02:00
|
|
|
r = lookup_paths_init_from_scope(&paths, scope, root_dir);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = get_config_path(scope, runtime, root_dir, &config_path);
|
|
|
|
if (r < 0)
|
2013-01-29 02:33:10 +01:00
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
STRV_FOREACH(i, files) {
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!unit_name_is_valid(*i, UNIT_NAME_ANY))
|
2013-01-29 02:33:10 +01:00
|
|
|
return -EINVAL;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-16 20:33:29 +02:00
|
|
|
r = unit_file_query_preset(scope, root_dir, *i);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
2013-01-29 02:33:10 +01:00
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-16 19:49:31 +02:00
|
|
|
if (r && mode != UNIT_FILE_PRESET_DISABLE_ONLY)
|
2011-07-22 04:21:18 +02:00
|
|
|
r = install_info_add_auto(&plus, *i);
|
2014-06-16 19:49:31 +02:00
|
|
|
else if (!r && mode != UNIT_FILE_PRESET_ENABLE_ONLY)
|
2011-07-22 04:21:18 +02:00
|
|
|
r = install_info_add_auto(&minus, *i);
|
2014-06-16 19:49:31 +02:00
|
|
|
else
|
|
|
|
r = 0;
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
2013-01-29 02:33:10 +01:00
|
|
|
return r;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
2014-06-16 19:49:31 +02:00
|
|
|
r = 0;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-16 19:49:31 +02:00
|
|
|
if (mode != UNIT_FILE_PRESET_ENABLE_ONLY) {
|
|
|
|
_cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-16 19:49:31 +02:00
|
|
|
r = install_context_mark_for_removal(&minus, &paths, &remove_symlinks_to, config_path, root_dir);
|
|
|
|
|
|
|
|
q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, files);
|
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mode != UNIT_FILE_PRESET_DISABLE_ONLY) {
|
|
|
|
/* Returns number of symlinks that where supposed to be installed. */
|
|
|
|
q = install_context_apply(&plus, &paths, config_path, root_dir, force, changes, n_changes);
|
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
int unit_file_preset_all(
|
|
|
|
UnitFileScope scope,
|
|
|
|
bool runtime,
|
|
|
|
const char *root_dir,
|
|
|
|
UnitFilePresetMode mode,
|
|
|
|
bool force,
|
|
|
|
UnitFileChange **changes,
|
|
|
|
unsigned *n_changes) {
|
|
|
|
|
2014-08-21 19:08:30 +02:00
|
|
|
_cleanup_(install_context_done) InstallContext plus = {}, minus = {};
|
2014-06-16 19:49:31 +02:00
|
|
|
_cleanup_lookup_paths_free_ LookupPaths paths = {};
|
|
|
|
_cleanup_free_ char *config_path = NULL;
|
|
|
|
char **i;
|
|
|
|
int r, q;
|
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
2014-07-10 04:29:24 +02:00
|
|
|
assert(mode < _UNIT_FILE_PRESET_MAX);
|
2014-06-16 19:49:31 +02:00
|
|
|
|
|
|
|
r = lookup_paths_init_from_scope(&paths, scope, root_dir);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = get_config_path(scope, runtime, root_dir, &config_path);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
STRV_FOREACH(i, paths.unit_path) {
|
|
|
|
_cleanup_closedir_ DIR *d = NULL;
|
2014-07-26 20:47:31 +02:00
|
|
|
_cleanup_free_ char *units_dir;
|
2014-06-16 19:49:31 +02:00
|
|
|
|
2014-07-26 20:47:31 +02:00
|
|
|
units_dir = path_join(root_dir, *i, NULL);
|
|
|
|
if (!units_dir)
|
|
|
|
return -ENOMEM;
|
2014-06-16 19:49:31 +02:00
|
|
|
|
|
|
|
d = opendir(units_dir);
|
|
|
|
if (!d) {
|
|
|
|
if (errno == ENOENT)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
struct dirent *de;
|
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
de = readdir(d);
|
|
|
|
if (!de && errno != 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
if (!de)
|
|
|
|
break;
|
|
|
|
|
2014-12-19 20:03:36 +01:00
|
|
|
if (hidden_file(de->d_name))
|
2014-06-16 19:49:31 +02:00
|
|
|
continue;
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!unit_name_is_valid(de->d_name, UNIT_NAME_ANY))
|
2014-06-16 19:49:31 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
dirent_ensure_type(d, de);
|
|
|
|
|
|
|
|
if (de->d_type != DT_REG)
|
|
|
|
continue;
|
|
|
|
|
2014-06-16 20:33:29 +02:00
|
|
|
r = unit_file_query_preset(scope, root_dir, de->d_name);
|
2014-06-16 19:49:31 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
if (r && mode != UNIT_FILE_PRESET_DISABLE_ONLY)
|
|
|
|
r = install_info_add_auto(&plus, de->d_name);
|
|
|
|
else if (!r && mode != UNIT_FILE_PRESET_ENABLE_ONLY)
|
|
|
|
r = install_info_add_auto(&minus, de->d_name);
|
|
|
|
else
|
|
|
|
r = 0;
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
r = 0;
|
|
|
|
|
|
|
|
if (mode != UNIT_FILE_PRESET_ENABLE_ONLY) {
|
|
|
|
_cleanup_set_free_free_ Set *remove_symlinks_to = NULL;
|
|
|
|
|
|
|
|
r = install_context_mark_for_removal(&minus, &paths, &remove_symlinks_to, config_path, root_dir);
|
|
|
|
|
|
|
|
q = remove_marked_symlinks(remove_symlinks_to, config_path, changes, n_changes, NULL);
|
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mode != UNIT_FILE_PRESET_DISABLE_ONLY) {
|
|
|
|
q = install_context_apply(&plus, &paths, config_path, root_dir, force, changes, n_changes);
|
|
|
|
if (r == 0)
|
|
|
|
r = q;
|
|
|
|
}
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2014-08-21 19:08:30 +02:00
|
|
|
static void unit_file_list_free_one(UnitFileList *f) {
|
|
|
|
if (!f)
|
2013-01-29 02:33:10 +01:00
|
|
|
return;
|
|
|
|
|
2014-08-21 19:08:30 +02:00
|
|
|
free(f->path);
|
|
|
|
free(f);
|
2013-01-29 02:33:10 +01:00
|
|
|
}
|
2014-08-21 19:08:30 +02:00
|
|
|
|
|
|
|
DEFINE_TRIVIAL_CLEANUP_FUNC(UnitFileList*, unit_file_list_free_one);
|
2013-01-29 02:33:10 +01:00
|
|
|
|
2011-07-22 04:21:18 +02:00
|
|
|
int unit_file_get_list(
|
|
|
|
UnitFileScope scope,
|
|
|
|
const char *root_dir,
|
|
|
|
Hashmap *h) {
|
|
|
|
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_lookup_paths_free_ LookupPaths paths = {};
|
2013-01-29 02:33:10 +01:00
|
|
|
char **i;
|
2011-07-22 04:21:18 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(scope >= 0);
|
|
|
|
assert(scope < _UNIT_FILE_SCOPE_MAX);
|
|
|
|
assert(h);
|
|
|
|
|
|
|
|
if (root_dir && scope != UNIT_FILE_SYSTEM)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-08-19 20:53:29 +02:00
|
|
|
if (root_dir) {
|
|
|
|
r = access(root_dir, F_OK);
|
|
|
|
if (r < 0)
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
2014-04-24 07:44:10 +02:00
|
|
|
r = lookup_paths_init_from_scope(&paths, scope, root_dir);
|
2011-07-22 04:21:18 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
STRV_FOREACH(i, paths.unit_path) {
|
2014-06-16 17:19:30 +02:00
|
|
|
_cleanup_closedir_ DIR *d = NULL;
|
2014-07-26 20:47:31 +02:00
|
|
|
_cleanup_free_ char *units_dir;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-07-26 20:47:31 +02:00
|
|
|
units_dir = path_join(root_dir, *i, NULL);
|
|
|
|
if (!units_dir)
|
|
|
|
return -ENOMEM;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
d = opendir(units_dir);
|
|
|
|
if (!d) {
|
|
|
|
if (errno == ENOENT)
|
|
|
|
continue;
|
|
|
|
|
2013-01-29 02:33:10 +01:00
|
|
|
return -errno;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
2014-08-21 19:08:30 +02:00
|
|
|
_cleanup_(unit_file_list_free_onep) UnitFileList *f = NULL;
|
2014-06-16 19:49:31 +02:00
|
|
|
struct dirent *de;
|
2014-08-26 13:33:08 +02:00
|
|
|
_cleanup_free_ char *path = NULL;
|
2015-06-25 16:44:22 +02:00
|
|
|
bool also = false;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2013-12-19 11:59:19 +01:00
|
|
|
errno = 0;
|
|
|
|
de = readdir(d);
|
|
|
|
if (!de && errno != 0)
|
|
|
|
return -errno;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
if (!de)
|
|
|
|
break;
|
|
|
|
|
2014-12-19 20:03:36 +01:00
|
|
|
if (hidden_file(de->d_name))
|
2011-07-22 04:21:18 +02:00
|
|
|
continue;
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
if (!unit_name_is_valid(de->d_name, UNIT_NAME_ANY))
|
2011-07-22 04:21:18 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (hashmap_get(h, de->d_name))
|
|
|
|
continue;
|
|
|
|
|
2014-06-16 17:19:30 +02:00
|
|
|
dirent_ensure_type(d, de);
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-06-16 17:19:30 +02:00
|
|
|
if (!IN_SET(de->d_type, DT_LNK, DT_REG))
|
2011-07-22 04:21:18 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
f = new0(UnitFileList, 1);
|
2013-01-29 02:33:10 +01:00
|
|
|
if (!f)
|
|
|
|
return -ENOMEM;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-08-26 04:03:24 +02:00
|
|
|
f->path = path_make_absolute(de->d_name, units_dir);
|
2013-01-29 02:33:10 +01:00
|
|
|
if (!f->path)
|
|
|
|
return -ENOMEM;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
r = null_or_empty_path(f->path);
|
2013-01-29 02:33:10 +01:00
|
|
|
if (r < 0 && r != -ENOENT)
|
|
|
|
return r;
|
|
|
|
else if (r > 0) {
|
2011-07-22 04:21:18 +02:00
|
|
|
f->state =
|
|
|
|
path_startswith(*i, "/run") ?
|
|
|
|
UNIT_FILE_MASKED_RUNTIME : UNIT_FILE_MASKED;
|
|
|
|
goto found;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = find_symlinks_in_scope(scope, root_dir, de->d_name, &f->state);
|
2013-01-29 02:33:10 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
else if (r > 0) {
|
2012-09-11 01:11:32 +02:00
|
|
|
f->state = UNIT_FILE_ENABLED;
|
2011-07-22 04:21:18 +02:00
|
|
|
goto found;
|
2012-09-11 01:11:32 +02:00
|
|
|
}
|
2011-07-22 04:21:18 +02:00
|
|
|
|
2014-08-26 13:33:08 +02:00
|
|
|
path = path_make_absolute(de->d_name, *i);
|
|
|
|
if (!path)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-06-25 16:44:22 +02:00
|
|
|
r = unit_file_can_install(&paths, root_dir, path, true, &also);
|
2012-09-11 01:11:32 +02:00
|
|
|
if (r == -EINVAL || /* Invalid setting? */
|
|
|
|
r == -EBADMSG || /* Invalid format? */
|
|
|
|
r == -ENOENT /* Included file not found? */)
|
|
|
|
f->state = UNIT_FILE_INVALID;
|
2013-01-29 02:33:10 +01:00
|
|
|
else if (r < 0)
|
|
|
|
return r;
|
|
|
|
else if (r > 0)
|
2011-07-22 04:21:18 +02:00
|
|
|
f->state = UNIT_FILE_DISABLED;
|
2012-09-11 01:11:32 +02:00
|
|
|
else
|
2015-06-25 16:44:22 +02:00
|
|
|
f->state = also ? UNIT_FILE_INDIRECT : UNIT_FILE_STATIC;
|
2011-07-22 04:21:18 +02:00
|
|
|
|
|
|
|
found:
|
2013-12-07 03:29:55 +01:00
|
|
|
r = hashmap_put(h, basename(f->path), f);
|
2013-01-29 02:33:10 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
f = NULL; /* prevent cleanup */
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-25 16:06:40 +02:00
|
|
|
return 0;
|
2011-07-22 04:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char* const unit_file_state_table[_UNIT_FILE_STATE_MAX] = {
|
|
|
|
[UNIT_FILE_ENABLED] = "enabled",
|
2012-04-19 12:03:28 +02:00
|
|
|
[UNIT_FILE_ENABLED_RUNTIME] = "enabled-runtime",
|
2011-07-22 04:21:18 +02:00
|
|
|
[UNIT_FILE_LINKED] = "linked",
|
|
|
|
[UNIT_FILE_LINKED_RUNTIME] = "linked-runtime",
|
|
|
|
[UNIT_FILE_MASKED] = "masked",
|
|
|
|
[UNIT_FILE_MASKED_RUNTIME] = "masked-runtime",
|
|
|
|
[UNIT_FILE_STATIC] = "static",
|
2012-09-11 01:11:32 +02:00
|
|
|
[UNIT_FILE_DISABLED] = "disabled",
|
2014-11-07 21:21:05 +01:00
|
|
|
[UNIT_FILE_INDIRECT] = "indirect",
|
2012-09-11 01:11:32 +02:00
|
|
|
[UNIT_FILE_INVALID] = "invalid",
|
2011-07-22 04:21:18 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(unit_file_state, UnitFileState);
|
2011-07-23 03:44:47 +02:00
|
|
|
|
|
|
|
static const char* const unit_file_change_type_table[_UNIT_FILE_CHANGE_TYPE_MAX] = {
|
|
|
|
[UNIT_FILE_SYMLINK] = "symlink",
|
|
|
|
[UNIT_FILE_UNLINK] = "unlink",
|
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(unit_file_change_type, UnitFileChangeType);
|
2014-06-16 19:49:31 +02:00
|
|
|
|
2014-07-10 04:29:24 +02:00
|
|
|
static const char* const unit_file_preset_mode_table[_UNIT_FILE_PRESET_MAX] = {
|
2014-06-16 19:49:31 +02:00
|
|
|
[UNIT_FILE_PRESET_FULL] = "full",
|
|
|
|
[UNIT_FILE_PRESET_ENABLE_ONLY] = "enable-only",
|
|
|
|
[UNIT_FILE_PRESET_DISABLE_ONLY] = "disable-only",
|
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(unit_file_preset_mode, UnitFilePresetMode);
|