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

326 lines
9.5 KiB
C
Raw Normal View History

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
systemd is free software; you can redistribute it and/or modify it
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
(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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
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
}
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
}
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_runtime(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;
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
const char *e;
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: reuse manager_get_runtime_prefix() at more places
2016-02-25 02:30:32 +03:00
e = manager_get_runtime_prefix(u->manager);
if (!e)
return -EOPNOTSUPP;
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
n = strdup(e);
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
static int specifier_user_name(char specifier, void *data, void *userdata, char **ret) {
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
char *t;
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
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
/* If we are UID 0 (root), this will not result in NSS,
* otherwise it might. This is good, as we want to be able to
* run this in PID 1, where our user ID is 0, but where NSS
* lookups are not allowed. */
unit: add %U for uids in units
2012-12-07 09:01:15 +04:00
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
t = getusername_malloc();
if (!t)
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;
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
*ret = t;
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 0;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
static int specifier_user_id(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
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
if (asprintf(ret, UID_FMT, getuid()) < 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
return -ENOMEM;
return 0;
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
}
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
static int specifier_user_home(char specifier, void *data, void *userdata, char **ret) {
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
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
/* On PID 1 (which runs as root) this will not result in NSS,
* which is good. See above */
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
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
return get_home_dir(ret);
}
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
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
static int specifier_user_shell(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
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
/* On PID 1 (which runs as root) this will not result in NSS,
* which is good. See above */
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
return get_shell(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_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: 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: 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
* %t: the runtime directory to place sockets in (e.g. "/run" or $XDG_RUNTIME_DIR)
*
* %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
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 },
{ 'P', specifier_prefix_unescaped, NULL },
{ 'i', specifier_string, u->instance },
{ 'I', specifier_instance_unescaped, NULL },
{ 'f', specifier_filename, NULL },
{ 'c', specifier_cgroup, NULL },
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
{ 'r', specifier_cgroup_slice, NULL },
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
{ 'R', specifier_cgroup_root, NULL },
{ 't', specifier_runtime, NULL },
core: simplify handling of %u, %U, %s and %h unit file specifiers Previously, the %u, %U, %s and %h specifiers would resolve to the user name, numeric user ID, shell and home directory of the user configured in the User= setting of a unit file, or the user of the manager instance if no User= setting was configured. That at least was the theory. In real-life this was not ever actually useful: - For the systemd --user instance it made no sense to ever set User=, since the instance runs in user context after all, and hence the privileges to change user IDs don't even exist. The four specifiers were actually not useful at all in this case. - For the systemd --system instance we did not allow any resolving that would require NSS. Hence, %s and %h were not supported, unless User=root was set, in which case they would be hardcoded to /bin/sh and /root, to avoid NSS. Then, %u would actually resolve to whatever was set with User=, but %U would only resolve to the numeric UID of that setting if the User= was specified in numeric form, or happened to be root (in which case 0 was hardcoded as mapping). Two of the specifiers are entirely useless in this case, one is realistically also useless, and one is pretty pointless. - Resolving of these settings would only happen if User= was actually set *before* the specifiers where resolved. This behaviour was undocumented and is really ugly, as specifiers should actually be considered something that applies to the whole file equally, independently of order... With this change, %u, %U, %s and %h are drastically simplified: they now always refer to the user that is running the service instance, and the user configured in the unit file is irrelevant. For the system instance of systemd this means they always resolve to "root", "0", "/bin/sh" and "/root", thus avoiding NSS. For the user instance, to the data for the specific user. The new behaviour is identical to the old behaviour in all --user cases and for all units that have no User= set (or set to "0" or "root").
2015-11-01 00:12:51 +03:00
{ 'U', specifier_user_id, NULL },
unit: split unit_printf() and friends into its own .c file
2012-09-18 13:27:56 +04:00
{ 'u', specifier_user_name, NULL },
{ 'h', specifier_user_home, NULL },
{ 's', specifier_user_shell, NULL },
unit-printf: add specifiers for the host name, machine id, boot id
2012-09-18 13:53:47 +04:00
{ 'm', specifier_machine_id, NULL },
{ 'H', specifier_host_name, NULL },
{ 'b', specifier_boot_id, NULL },
core: add %v specifier
2013-07-19 10:45:27 +04:00
{ 'v', specifier_kernel_release, NULL },
{}
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