shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2024-11-06 16:59:03 +03:00
Code
b294e5943f
systemd/src/core/unit-printf.c

320 lines
9.9 KiB
C
Raw Normal View History

Add SPDX license identifiers to source files under the LGPL This follows what the kernel is doing, c.f. https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=5fd54ace4721fc5ce2bb5aef6318fcf17f421460.
2017-11-18 19:09:20 +03:00
/* SPDX-License-Identifier: LGPL-2.1+ */
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
/***
This file is part of systemd.
Copyright 2010 Lennart Poettering
***/
util-lib: split out allocation calls into alloc-util.[ch]
2015-10-27 05:01:06 +03:00
#include "alloc-util.h"
util-lib: split our string related calls from util.[ch] into its own file string-util.[ch] There are more than enough calls doing string manipulations to deserve its own files, hence do something about it. This patch also sorts the #include blocks of all files that needed to be updated, according to the sorting suggestions from CODING_STYLE. Since pretty much every file needs our string manipulation functions this effectively means that most files have sorted #include blocks now. Also touches a few unrelated include files.
2015-10-24 23:58:24 +03:00
#include "cgroup-util.h"
Rename formats-util.h to format-util.h We don't have plural in the name of any other -util files and this inconsistency trips me up every time I try to type this file name from memory. "formats-util" is even hard to pronounce.
2016-11-07 18:14:59 +03:00
#include "format-util.h"
util-lib: split our string related calls from util.[ch] into its own file string-util.[ch] There are more than enough calls doing string manipulations to deserve its own files, hence do something about it. This patch also sorts the #include blocks of all files that needed to be updated, according to the sorting suggestions from CODING_STYLE. Since pretty much every file needs our string manipulation functions this effectively means that most files have sorted #include blocks now. Also touches a few unrelated include files.
2015-10-24 23:58:24 +03:00
#include "macro.h"
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
#include "specifier.h"
util-lib: split our string related calls from util.[ch] into its own file string-util.[ch] There are more than enough calls doing string manipulations to deserve its own files, hence do something about it. This patch also sorts the #include blocks of all files that needed to be updated, according to the sorting suggestions from CODING_STYLE. Since pretty much every file needs our string manipulation functions this effectively means that most files have sorted #include blocks now. Also touches a few unrelated include files.
2015-10-24 23:58:24 +03:00
#include "string-util.h"
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
#include "strv.h"
#include "unit-name.h"
#include "unit-printf.h"
util-lib: split out user/group/uid/gid calls into user-util.[ch]
2015-10-26 00:32:30 +03:00
#include "unit.h"
#include "user-util.h"
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
static int specifier_prefix_and_instance(char specifier, void *data, void *userdata, char **ret) {
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
Unit *u = userdata;
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
assert(u);
core: rework unit name validation and manipulation logic A variety of changes: - Make sure all our calls distuingish OOM from other errors if OOM is not the only error possible. - Be much stricter when parsing escaped paths, do not accept trailing or leading escaped slashes. - Change unit validation to take a bit mask for allowing plain names, instance names or template names or an combination thereof. - Refuse manipulating invalid unit name
2015-04-30 21:21:00 +03:00
return unit_name_to_prefix_and_instance(u->id, ret);
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
static int specifier_prefix(char specifier, void *data, void *userdata, char **ret) {
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
Unit *u = userdata;
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
assert(u);
core: rework unit name validation and manipulation logic A variety of changes: - Make sure all our calls distuingish OOM from other errors if OOM is not the only error possible. - Be much stricter when parsing escaped paths, do not accept trailing or leading escaped slashes. - Change unit validation to take a bit mask for allowing plain names, instance names or template names or an combination thereof. - Refuse manipulating invalid unit name
2015-04-30 21:21:00 +03:00
return unit_name_to_prefix(u->id, ret);
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
static int specifier_prefix_unescaped(char specifier, void *data, void *userdata, char **ret) {
_cleanup_free_ char *p = NULL;
core: rework unit name validation and manipulation logic A variety of changes: - Make sure all our calls distuingish OOM from other errors if OOM is not the only error possible. - Be much stricter when parsing escaped paths, do not accept trailing or leading escaped slashes. - Change unit validation to take a bit mask for allowing plain names, instance names or template names or an combination thereof. - Refuse manipulating invalid unit name
2015-04-30 21:21:00 +03:00
Unit *u = userdata;
int r;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
assert(u);
core: rework unit name validation and manipulation logic A variety of changes: - Make sure all our calls distuingish OOM from other errors if OOM is not the only error possible. - Be much stricter when parsing escaped paths, do not accept trailing or leading escaped slashes. - Change unit validation to take a bit mask for allowing plain names, instance names or template names or an combination thereof. - Refuse manipulating invalid unit name
2015-04-30 21:21:00 +03:00
r = unit_name_to_prefix(u->id, &p);
if (r < 0)
return r;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
core: rework unit name validation and manipulation logic A variety of changes: - Make sure all our calls distuingish OOM from other errors if OOM is not the only error possible. - Be much stricter when parsing escaped paths, do not accept trailing or leading escaped slashes. - Change unit validation to take a bit mask for allowing plain names, instance names or template names or an combination thereof. - Refuse manipulating invalid unit name
2015-04-30 21:21:00 +03:00
return unit_name_unescape(p, ret);
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
static int specifier_instance_unescaped(char specifier, void *data, void *userdata, char **ret) {
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
Unit *u = userdata;
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
assert(u);
core: various small fixes to unit-printf * check memory allocation errors in specifier_cgroup_slice * %I doesn't fail for non-instantiated units (%i doesn't fail too) * EOPNOTSUPP for consistency
2015-10-24 23:55:56 +03:00
return unit_name_unescape(strempty(u->instance), ret);
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
Add %j/%J unit specifiers Those are quite similar to %i/%I, but refer to the last dash-separated component of the name prefix. The new functionality of dash-dropins could largely supersede the template functionality, so it would be tempting to overload %i/%I. But that would not be backwards compatible. So let's add the two new letters instead.
2018-04-23 23:43:20 +03:00
static int specifier_last_component(char specifier, void *data, void *userdata, char **ret) {
Unit *u = userdata;
_cleanup_free_ char *prefix = NULL;
char *dash;
int r;
assert(u);
r = unit_name_to_prefix(u->id, &prefix);
if (r < 0)
return r;
dash = strrchr(prefix, '-');
if (dash)
return specifier_string(specifier, dash + 1, userdata, ret);
*ret = TAKE_PTR(prefix);
return 0;
}
static int specifier_last_component_unescaped(char specifier, void *data, void *userdata, char **ret) {
_cleanup_free_ char *p = NULL;
int r;
r = specifier_last_component(specifier, data, userdata, &p);
if (r < 0)
return r;
return unit_name_unescape(p, ret);
}
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
static int specifier_filename(char specifier, void *data, void *userdata, char **ret) {
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
Unit *u = userdata;
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
assert(u);
if (u->instance)
core: rework unit name validation and manipulation logic A variety of changes: - Make sure all our calls distuingish OOM from other errors if OOM is not the only error possible. - Be much stricter when parsing escaped paths, do not accept trailing or leading escaped slashes. - Change unit validation to take a bit mask for allowing plain names, instance names or template names or an combination thereof. - Refuse manipulating invalid unit name
2015-04-30 21:21:00 +03:00
return unit_name_path_unescape(u->instance, ret);
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
else
core: rework unit name validation and manipulation logic A variety of changes: - Make sure all our calls distuingish OOM from other errors if OOM is not the only error possible. - Be much stricter when parsing escaped paths, do not accept trailing or leading escaped slashes. - Change unit validation to take a bit mask for allowing plain names, instance names or template names or an combination thereof. - Refuse manipulating invalid unit name
2015-04-30 21:21:00 +03:00
return unit_name_to_path(u->id, ret);
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
core: deprecate %c, %r, %R specifiers %c and %r rely on settings made in the unit files themselves and hence resolve to different values depending on whether they are used before or after Slice=. Let's simply deprecate them and drop them from the documentation, as that's not really possible to fix. Moreover they are actually redundant, as the same information may always be queried from /proc/self/cgroup and /proc/1/cgroup. (Accurately speaking, %R is actually not broken like this as it is constant. However, let's remove all cgroup-related specifiers at once, as it is also redundant, and doesn't really make much sense alone.)
2016-12-07 20:58:09 +03:00
static void bad_specifier(Unit *u, char specifier) {
log_unit_warning(u, "Specifier '%%%c' used in unit configuration, which is deprecated. Please update your unit file, as it does not work as intended.", specifier);
}
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
static int specifier_cgroup(char specifier, void *data, void *userdata, char **ret) {
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
Unit *u = userdata;
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
char *n;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
assert(u);
core: deprecate %c, %r, %R specifiers %c and %r rely on settings made in the unit files themselves and hence resolve to different values depending on whether they are used before or after Slice=. Let's simply deprecate them and drop them from the documentation, as that's not really possible to fix. Moreover they are actually redundant, as the same information may always be queried from /proc/self/cgroup and /proc/1/cgroup. (Accurately speaking, %R is actually not broken like this as it is constant. However, let's remove all cgroup-related specifiers at once, as it is also redundant, and doesn't really make much sense alone.)
2016-12-07 20:58:09 +03:00
bad_specifier(u, specifier);
core: refuse doing %h, %s, %U specifier resolving in PID 1 These specifiers require NSS lookups to work, and we really shouldn't do them from PID 1 hence. With this change they are now only supported for user systemd instance, or when the configured user for a unit is root.
2013-12-16 07:59:31 +04:00
if (u->cgroup_path)
n = strdup(u->cgroup_path);
else
n = unit_default_cgroup_path(u);
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
if (!n)
return -ENOMEM;
*ret = n;
return 0;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
static int specifier_cgroup_root(char specifier, void *data, void *userdata, char **ret) {
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
Unit *u = userdata;
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
char *n;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
logind: add infrastructure to keep track of machines, and move to slices - This changes all logind cgroup objects to use slice objects rather than fixed croup locations. - logind can now collect minimal information about running VMs/containers. As fixed cgroup locations can no longer be used we need an entity that keeps track of machine cgroups in whatever slice they might be located. Since logind already keeps track of users, sessions and seats this is a trivial addition. - nspawn will now register with logind and pass various bits of metadata along. A new option "--slice=" has been added to place the container in a specific slice. - loginctl gained commands to list, introspect and terminate machines. - user.slice and machine.slice will now be pulled in by logind.service, since only logind.service requires this slice.
2013-06-20 05:45:08 +04:00
assert(u);
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
core: deprecate %c, %r, %R specifiers %c and %r rely on settings made in the unit files themselves and hence resolve to different values depending on whether they are used before or after Slice=. Let's simply deprecate them and drop them from the documentation, as that's not really possible to fix. Moreover they are actually redundant, as the same information may always be queried from /proc/self/cgroup and /proc/1/cgroup. (Accurately speaking, %R is actually not broken like this as it is constant. However, let's remove all cgroup-related specifiers at once, as it is also redundant, and doesn't really make much sense alone.)
2016-12-07 20:58:09 +03:00
bad_specifier(u, specifier);
core: simplify %r and %R logic a bit Do not calculate the cgroup path manually, just use normal unit fields and calls for that.
2015-04-30 13:33:54 +03:00
n = strdup(u->manager->cgroup_root);
if (!n)
return -ENOMEM;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
core: simplify %r and %R logic a bit Do not calculate the cgroup path manually, just use normal unit fields and calls for that.
2015-04-30 13:33:54 +03:00
*ret = n;
return 0;
}
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
core: simplify %r and %R logic a bit Do not calculate the cgroup path manually, just use normal unit fields and calls for that.
2015-04-30 13:33:54 +03:00
static int specifier_cgroup_slice(char specifier, void *data, void *userdata, char **ret) {
Unit *u = userdata;
char *n;
assert(u);
core: deprecate %c, %r, %R specifiers %c and %r rely on settings made in the unit files themselves and hence resolve to different values depending on whether they are used before or after Slice=. Let's simply deprecate them and drop them from the documentation, as that's not really possible to fix. Moreover they are actually redundant, as the same information may always be queried from /proc/self/cgroup and /proc/1/cgroup. (Accurately speaking, %R is actually not broken like this as it is constant. However, let's remove all cgroup-related specifiers at once, as it is also redundant, and doesn't really make much sense alone.)
2016-12-07 20:58:09 +03:00
bad_specifier(u, specifier);
core: simplify %r and %R logic a bit Do not calculate the cgroup path manually, just use normal unit fields and calls for that.
2015-04-30 13:33:54 +03:00
if (UNIT_ISSET(u->slice)) {
Unit *slice;
slice = UNIT_DEREF(u->slice);
if (slice->cgroup_path)
n = strdup(slice->cgroup_path);
else
n = unit_default_cgroup_path(slice);
} else
n = strdup(u->manager->cgroup_root);
core: various small fixes to unit-printf * check memory allocation errors in specifier_cgroup_slice * %I doesn't fail for non-instantiated units (%i doesn't fail too) * EOPNOTSUPP for consistency
2015-10-24 23:55:56 +03:00
if (!n)
return -ENOMEM;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
*ret = n;
return 0;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
core: add support for expanding state/cache/log directory root in unit files This augments %t which already resolves to the runtime directory root, and should be useful for units that want to pass any of these paths in command line arguments. Example: ExecStart=/usr/bin/mydaemon --datadir=%S/mydaemon Why not expose a specifier resolving directly to the configured state/runtime/cache/log dir? Three reasons: 1. Specifiers should be independent of configuration of the unit itself, and StateDirectory= and friends are unit configuration. See 03fc9c723cfc59467a7fccc305f34273f8564b25 and related work. 2. We permit multiple StateDirectory= values per unit, and it hence wouldn't be clear which one is passed. 3. We already have %t for the runtime directory root, and we should continue with the same scheme.
2017-10-11 15:02:36 +03:00
static int specifier_special_directory(char specifier, void *data, void *userdata, char **ret) {
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
Unit *u = userdata;
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
char *n = NULL;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
assert(u);
core: add support for expanding state/cache/log directory root in unit files This augments %t which already resolves to the runtime directory root, and should be useful for units that want to pass any of these paths in command line arguments. Example: ExecStart=/usr/bin/mydaemon --datadir=%S/mydaemon Why not expose a specifier resolving directly to the configured state/runtime/cache/log dir? Three reasons: 1. Specifiers should be independent of configuration of the unit itself, and StateDirectory= and friends are unit configuration. See 03fc9c723cfc59467a7fccc305f34273f8564b25 and related work. 2. We permit multiple StateDirectory= values per unit, and it hence wouldn't be clear which one is passed. 3. We already have %t for the runtime directory root, and we should continue with the same scheme.
2017-10-11 15:02:36 +03:00
n = strdup(u->manager->prefix[PTR_TO_UINT(data)]);
core: refuse doing %h, %s, %U specifier resolving in PID 1 These specifiers require NSS lookups to work, and we really shouldn't do them from PID 1 hence. With this change they are now only supported for user systemd instance, or when the configured user for a unit is root.
2013-12-16 07:59:31 +04:00
if (!n)
return -ENOMEM;
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
*ret = n;
return 0;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
int unit_name_printf(Unit *u, const char* format, char **ret) {
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
/*
core: resolve more specifiers in unit_name_printf() unit_name_printf() is usually what we use when the resulting string shall qualify as unit name, and it hence avoids resolving specifiers that almost certainly won't result in valid unit names. Add a couple of more specifiers that unit_full_printf() resolves also to the list unit_name_printf() resolves, as they are likely to be useful in valid unit names too. (Note that there might be cases where this doesn't hold, but we should still permit this, as more often than not they are safe, and if people want to use them that way, they should be able to.)
2016-12-05 21:12:54 +03:00
* This will use the passed string as format string and replace the following specifiers (which should all be
* safe for inclusion in unit names):
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
*
* %n: the full id of the unit (foo@bar.waldo)
* %N: the id of the unit without the suffix (foo@bar)
* %p: the prefix (foo)
* %i: the instance (bar)
core: resolve more specifiers in unit_name_printf() unit_name_printf() is usually what we use when the resulting string shall qualify as unit name, and it hence avoids resolving specifiers that almost certainly won't result in valid unit names. Add a couple of more specifiers that unit_full_printf() resolves also to the list unit_name_printf() resolves, as they are likely to be useful in valid unit names too. (Note that there might be cases where this doesn't hold, but we should still permit this, as more often than not they are safe, and if people want to use them that way, they should be able to.)
2016-12-05 21:12:54 +03:00
*
* %U: the UID of the running user
* %u: the username of the running user
*
* %m: the machine ID of the running system
* %H: the host name of the running system
* %b: the boot ID of the running system
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
*/
const Specifier table[] = {
{ 'n', specifier_string, u->id },
{ 'N', specifier_prefix_and_instance, NULL },
{ 'p', specifier_prefix, NULL },
{ 'i', specifier_string, u->instance },
core: resolve more specifiers in unit_name_printf() unit_name_printf() is usually what we use when the resulting string shall qualify as unit name, and it hence avoids resolving specifiers that almost certainly won't result in valid unit names. Add a couple of more specifiers that unit_full_printf() resolves also to the list unit_name_printf() resolves, as they are likely to be useful in valid unit names too. (Note that there might be cases where this doesn't hold, but we should still permit this, as more often than not they are safe, and if people want to use them that way, they should be able to.)
2016-12-05 21:12:54 +03:00
{ 'U', specifier_user_id, NULL },
{ 'u', specifier_user_name, NULL },
{ 'm', specifier_machine_id, NULL },
{ 'H', specifier_host_name, NULL },
{ 'b', specifier_boot_id, NULL },
{}
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
};
assert(u);
assert(format);
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
assert(ret);
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
return specifier_printf(format, table, u, ret);
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
int unit_full_printf(Unit *u, const char *format, char **ret) {
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
core: resolve more specifiers in unit_name_printf() unit_name_printf() is usually what we use when the resulting string shall qualify as unit name, and it hence avoids resolving specifiers that almost certainly won't result in valid unit names. Add a couple of more specifiers that unit_full_printf() resolves also to the list unit_name_printf() resolves, as they are likely to be useful in valid unit names too. (Note that there might be cases where this doesn't hold, but we should still permit this, as more often than not they are safe, and if people want to use them that way, they should be able to.)
2016-12-05 21:12:54 +03:00
/* This is similar to unit_name_printf() but also supports unescaping. Also, adds a couple of additional codes
* (which are likely not suitable for unescaped inclusion in unit names):
*
* %f: the unescaped instance if set, otherwise the id unescaped as path
core: add support for expanding state/cache/log directory root in unit files This augments %t which already resolves to the runtime directory root, and should be useful for units that want to pass any of these paths in command line arguments. Example: ExecStart=/usr/bin/mydaemon --datadir=%S/mydaemon Why not expose a specifier resolving directly to the configured state/runtime/cache/log dir? Three reasons: 1. Specifiers should be independent of configuration of the unit itself, and StateDirectory= and friends are unit configuration. See 03fc9c723cfc59467a7fccc305f34273f8564b25 and related work. 2. We permit multiple StateDirectory= values per unit, and it hence wouldn't be clear which one is passed. 3. We already have %t for the runtime directory root, and we should continue with the same scheme.
2017-10-11 15:02:36 +03:00
*
core: deprecate %c, %r, %R specifiers %c and %r rely on settings made in the unit files themselves and hence resolve to different values depending on whether they are used before or after Slice=. Let's simply deprecate them and drop them from the documentation, as that's not really possible to fix. Moreover they are actually redundant, as the same information may always be queried from /proc/self/cgroup and /proc/1/cgroup. (Accurately speaking, %R is actually not broken like this as it is constant. However, let's remove all cgroup-related specifiers at once, as it is also redundant, and doesn't really make much sense alone.)
2016-12-07 20:58:09 +03:00
* %c: cgroup path of unit (deprecated)
* %r: where units in this slice are placed in the cgroup tree (deprecated)
* %R: the root of this systemd's instance tree (deprecated)
core: add support for expanding state/cache/log directory root in unit files This augments %t which already resolves to the runtime directory root, and should be useful for units that want to pass any of these paths in command line arguments. Example: ExecStart=/usr/bin/mydaemon --datadir=%S/mydaemon Why not expose a specifier resolving directly to the configured state/runtime/cache/log dir? Three reasons: 1. Specifiers should be independent of configuration of the unit itself, and StateDirectory= and friends are unit configuration. See 03fc9c723cfc59467a7fccc305f34273f8564b25 and related work. 2. We permit multiple StateDirectory= values per unit, and it hence wouldn't be clear which one is passed. 3. We already have %t for the runtime directory root, and we should continue with the same scheme.
2017-10-11 15:02:36 +03:00
*
* %t: the runtime directory root (e.g. /run or $XDG_RUNTIME_DIR)
* %S: the state directory root (e.g. /var/lib or $XDG_CONFIG_HOME)
* %C: the cache directory root (e.g. /var/cache or $XDG_CACHE_HOME)
* %L: the log directory root (e.g. /var/log or $XDG_CONFIG_HOME/log)
core: introduce specifiers for /tmp and /var/tmp This corresponds nicely with the specifiers we already pass for /var/lib, /var/cache, /run and so on. This is particular useful to update the test-path service files to operate without guessable files, thus allowing multiple parallel test-path invocations to pass without issues (the idea is to set $TMPDIR early on in the test to some private directory, and then only use the new %T or %V specifier to refer to it).
2018-05-29 12:25:26 +03:00
* %T: the temporary directory (e.g. /tmp, or $TMPDIR, $TEMP, $TMP)
* %V: the temporary directory for large, persistent stuff (e.g. /var/tmp, or $TMPDIR, $TEMP, $TMP)
core: resolve more specifiers in unit_name_printf() unit_name_printf() is usually what we use when the resulting string shall qualify as unit name, and it hence avoids resolving specifiers that almost certainly won't result in valid unit names. Add a couple of more specifiers that unit_full_printf() resolves also to the list unit_name_printf() resolves, as they are likely to be useful in valid unit names too. (Note that there might be cases where this doesn't hold, but we should still permit this, as more often than not they are safe, and if people want to use them that way, they should be able to.)
2016-12-05 21:12:54 +03:00
*
* %h: the homedir of the running user
* %s: the shell of the running user
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
*
core: resolve more specifiers in unit_name_printf() unit_name_printf() is usually what we use when the resulting string shall qualify as unit name, and it hence avoids resolving specifiers that almost certainly won't result in valid unit names. Add a couple of more specifiers that unit_full_printf() resolves also to the list unit_name_printf() resolves, as they are likely to be useful in valid unit names too. (Note that there might be cases where this doesn't hold, but we should still permit this, as more often than not they are safe, and if people want to use them that way, they should be able to.)
2016-12-05 21:12:54 +03:00
* %v: `uname -r` of the running system
core: add a note clarifying that we should be careful when adding new specifiers
2016-12-07 21:03:22 +03:00
*
* NOTICE: When you add new entries here, please be careful: specifiers which depend on settings of the unit
* file itself are broken by design, as they would resolve differently depending on whether they are used
* before or after the relevant configuration setting. Hence: don't add them.
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
*/
const Specifier table[] = {
Add %j/%J unit specifiers Those are quite similar to %i/%I, but refer to the last dash-separated component of the name prefix. The new functionality of dash-dropins could largely supersede the template functionality, so it would be tempting to overload %i/%I. But that would not be backwards compatible. So let's add the two new letters instead.
2018-04-23 23:43:20 +03:00
{ 'n', specifier_string, u->id },
{ 'N', specifier_prefix_and_instance, NULL },
{ 'p', specifier_prefix, NULL },
{ 'P', specifier_prefix_unescaped, NULL },
{ 'i', specifier_string, u->instance },
{ 'I', specifier_instance_unescaped, NULL },
{ 'j', specifier_last_component, NULL },
{ 'J', specifier_last_component_unescaped, NULL },
{ 'f', specifier_filename, NULL },
{ 'c', specifier_cgroup, NULL },
{ 'r', specifier_cgroup_slice, NULL },
{ 'R', specifier_cgroup_root, NULL },
core: introduce specifiers for /tmp and /var/tmp This corresponds nicely with the specifiers we already pass for /var/lib, /var/cache, /run and so on. This is particular useful to update the test-path service files to operate without guessable files, thus allowing multiple parallel test-path invocations to pass without issues (the idea is to set $TMPDIR early on in the test to some private directory, and then only use the new %T or %V specifier to refer to it).
2018-05-29 12:25:26 +03:00
Add %j/%J unit specifiers Those are quite similar to %i/%I, but refer to the last dash-separated component of the name prefix. The new functionality of dash-dropins could largely supersede the template functionality, so it would be tempting to overload %i/%I. But that would not be backwards compatible. So let's add the two new letters instead.
2018-04-23 23:43:20 +03:00
{ 't', specifier_special_directory, UINT_TO_PTR(EXEC_DIRECTORY_RUNTIME) },
{ 'S', specifier_special_directory, UINT_TO_PTR(EXEC_DIRECTORY_STATE) },
{ 'C', specifier_special_directory, UINT_TO_PTR(EXEC_DIRECTORY_CACHE) },
{ 'L', specifier_special_directory, UINT_TO_PTR(EXEC_DIRECTORY_LOGS) },
core: introduce specifiers for /tmp and /var/tmp This corresponds nicely with the specifiers we already pass for /var/lib, /var/cache, /run and so on. This is particular useful to update the test-path service files to operate without guessable files, thus allowing multiple parallel test-path invocations to pass without issues (the idea is to set $TMPDIR early on in the test to some private directory, and then only use the new %T or %V specifier to refer to it).
2018-05-29 12:25:26 +03:00
{ 'T', specifier_tmp_dir, NULL },
{ 'V', specifier_var_tmp_dir, NULL },
Add %j/%J unit specifiers Those are quite similar to %i/%I, but refer to the last dash-separated component of the name prefix. The new functionality of dash-dropins could largely supersede the template functionality, so it would be tempting to overload %i/%I. But that would not be backwards compatible. So let's add the two new letters instead.
2018-04-23 23:43:20 +03:00
{ 'U', specifier_user_id, NULL },
{ 'u', specifier_user_name, NULL },
{ 'h', specifier_user_home, NULL },
{ 's', specifier_user_shell, NULL },
{ 'm', specifier_machine_id, NULL },
{ 'H', specifier_host_name, NULL },
{ 'b', specifier_boot_id, NULL },
{ 'v', specifier_kernel_release, NULL },
core: add %v specifier
2013-07-19 10:45:27 +04:00
{}
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
};
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
assert(u);
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
assert(format);
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
assert(ret);
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
return specifier_printf(format, table, u, ret);
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
int unit_full_printf_strv(Unit *u, char **l, char ***ret) {
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
size_t n;
char **r, **i, **j;
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
int q;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
/* Applies unit_full_printf to every entry in l */
assert(u);
n = strv_length(l);
r = new(char*, n+1);
if (!r)
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
return -ENOMEM;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
for (i = l, j = r; *i; i++, j++) {
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
q = unit_full_printf(u, *i, j);
if (q < 0)
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
goto fail;
}
*j = NULL;
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
*ret = r;
return 0;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
fail:
for (j--; j >= r; j--)
free(*j);
free(r);
specifier: rework specifier calls to return proper error message Previously the specifier calls could only indicate OOM by returning NULL. With this change they will return negative errno-style error codes like everything else.
2013-09-17 19:03:46 +04:00
return q;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
Copy Permalink