blob: f1890f326131da4fe3589d927b12f747a4a3c373 [file] [log] [blame]
Zbigniew Jędrzejewski-Szmek53e1b682017-11-18 17:09:20 +01001/* SPDX-License-Identifier: LGPL-2.1+ */
Lennart Poettering5008d582010-09-28 02:34:02 +02002/***
3 This file is part of systemd.
4
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02005 Copyright 2010 Lennart Poettering, Kay Sievers
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05006 Copyright 2015 Zbigniew Jędrzejewski-Szmek
Lennart Poettering5008d582010-09-28 02:34:02 +02007
8 systemd is free software; you can redistribute it and/or modify it
Lennart Poettering5430f7f2012-04-12 00:20:58 +02009 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
Lennart Poettering5008d582010-09-28 02:34:02 +020011 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lennart Poettering5430f7f2012-04-12 00:20:58 +020016 Lesser General Public License for more details.
Lennart Poettering5008d582010-09-28 02:34:02 +020017
Lennart Poettering5430f7f2012-04-12 00:20:58 +020018 You should have received a copy of the GNU Lesser General Public License
Lennart Poettering5008d582010-09-28 02:34:02 +020019 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
Lennart Poettering3f6fd1b2015-09-23 03:01:06 +020022#include <errno.h>
23#include <fcntl.h>
24#include <fnmatch.h>
25#include <getopt.h>
26#include <glob.h>
27#include <limits.h>
28#include <linux/fs.h>
29#include <stdbool.h>
30#include <stddef.h>
Lennart Poettering3b63d2d2010-10-18 22:38:41 +020031#include <stdio.h>
32#include <stdlib.h>
Lennart Poettering3f6fd1b2015-09-23 03:01:06 +020033#include <string.h>
Zbigniew Jędrzejewski-Szmek505ef0e2015-01-09 01:10:02 -050034#include <sys/stat.h>
Maciej Wereskiebf4e802014-12-04 10:32:10 +010035#include <sys/xattr.h>
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +010036#include <sysexits.h>
Lennart Poettering3f6fd1b2015-09-23 03:01:06 +020037#include <time.h>
38#include <unistd.h>
Lennart Poettering5008d582010-09-28 02:34:02 +020039
Zbigniew Jędrzejewski-Szmek5a8575e2017-11-23 13:56:32 +010040#include "sd-path.h"
41
Lennart Poettering3f6fd1b2015-09-23 03:01:06 +020042#include "acl-util.h"
Lennart Poetteringb5efdb82015-10-27 03:01:06 +010043#include "alloc-util.h"
Lennart Poettering3f6fd1b2015-09-23 03:01:06 +020044#include "btrfs-util.h"
Lennart Poettering430f0182015-10-26 23:32:16 +010045#include "capability-util.h"
Lennart Poetteringc8b30942015-10-26 20:39:23 +010046#include "chattr-util.h"
Lennart Poettering3f6fd1b2015-09-23 03:01:06 +020047#include "conf-files.h"
48#include "copy.h"
Lennart Poetteringa0f29c72015-11-03 12:26:12 +010049#include "def.h"
Reverend Homer8fb3f002016-12-09 12:04:30 +030050#include "dirent-util.h"
Lennart Poettering4f5dd392015-10-23 18:52:53 +020051#include "escape.h"
Lennart Poettering3ffd4af2015-10-25 13:14:12 +010052#include "fd-util.h"
Lennart Poettering0d39fa92015-10-26 18:05:03 +010053#include "fileio.h"
Zbigniew Jędrzejewski-Szmekf97b34a2016-11-07 10:14:59 -050054#include "format-util.h"
Lennart Poetteringf4f15632015-10-26 21:16:26 +010055#include "fs-util.h"
Lennart Poettering7d50b322015-10-27 01:48:17 +010056#include "glob-util.h"
Lennart Poetteringc0044932015-10-25 14:08:25 +010057#include "io-util.h"
Lennart Poettering3f6fd1b2015-09-23 03:01:06 +020058#include "label.h"
Lennart Poettering5008d582010-09-28 02:34:02 +020059#include "log.h"
Dave Reisner54693d92012-09-15 12:58:49 -040060#include "macro.h"
Zbigniew Jędrzejewski-Szmekd39efe72013-03-13 20:20:54 -040061#include "missing.h"
Kay Sievers49e942b2012-04-10 21:54:31 +020062#include "mkdir.h"
Lennart Poettering4e036b72015-10-27 13:45:00 +010063#include "mount-util.h"
Lennart Poettering6bedfcb2015-10-26 16:18:16 +010064#include "parse-util.h"
Zbigniew Jędrzejewski-Szmekf2b5ca02017-11-23 11:20:29 +010065#include "path-lookup.h"
Kay Sievers9eb977d2012-05-07 21:36:12 +020066#include "path-util.h"
Lennart Poetteringc6878632015-04-04 11:52:57 +020067#include "rm-rf.h"
Lennart Poetteringd7b8eec2014-12-27 18:46:36 +010068#include "selinux-util.h"
Lennart Poettering3f6fd1b2015-09-23 03:01:06 +020069#include "set.h"
70#include "specifier.h"
Lennart Poettering8fcde012015-10-26 22:01:44 +010071#include "stat-util.h"
Lennart Poettering15a5e952015-10-27 01:26:31 +010072#include "stdio-util.h"
Lennart Poettering8b434402015-10-26 22:31:05 +010073#include "string-table.h"
Lennart Poettering07630ce2015-10-24 22:58:24 +020074#include "string-util.h"
Lennart Poettering3f6fd1b2015-09-23 03:01:06 +020075#include "strv.h"
Lennart Poetteringaffb60b2015-10-26 23:20:41 +010076#include "umask-util.h"
Lennart Poetteringb1d4f8e2015-10-25 22:32:30 +010077#include "user-util.h"
Lennart Poettering3f6fd1b2015-09-23 03:01:06 +020078#include "util.h"
Lennart Poettering5008d582010-09-28 02:34:02 +020079
Andreas Jaeger01000472010-09-29 10:08:24 +020080/* This reads all files listed in /etc/tmpfiles.d/?*.conf and creates
Lennart Poettering5008d582010-09-28 02:34:02 +020081 * them in the file system. This is intended to be used to create
Kay Sieversdb019b82011-04-04 15:33:00 +020082 * properly owned directories beneath /tmp, /var/tmp, /run, which are
83 * volatile and hence need to be recreated on bootup. */
Lennart Poettering5008d582010-09-28 02:34:02 +020084
Michal Schmidt66ccd032011-12-15 21:31:14 +010085typedef enum ItemType {
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +010086 /* These ones take file names */
Lennart Poettering3b63d2d2010-10-18 22:38:41 +020087 CREATE_FILE = 'f',
88 TRUNCATE_FILE = 'F',
89 CREATE_DIRECTORY = 'd',
90 TRUNCATE_DIRECTORY = 'D',
Lennart Poetteringd7b8eec2014-12-27 18:46:36 +010091 CREATE_SUBVOLUME = 'v',
Lennart Poettering5fb13eb2015-10-21 19:46:23 +020092 CREATE_SUBVOLUME_INHERIT_QUOTA = 'q',
93 CREATE_SUBVOLUME_NEW_QUOTA = 'Q',
Lennart Poetteringee17ee72011-07-12 03:56:56 +020094 CREATE_FIFO = 'p',
Lennart Poettering468d7262012-01-17 15:04:12 +010095 CREATE_SYMLINK = 'L',
96 CREATE_CHAR_DEVICE = 'c',
97 CREATE_BLOCK_DEVICE = 'b',
Lennart Poettering849958d2014-06-10 23:02:40 +020098 COPY_FILES = 'C',
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +010099
100 /* These ones take globs */
Lennart Poettering17493fa2015-04-10 16:22:22 +0200101 WRITE_FILE = 'w',
Zbigniew Jędrzejewski-Szmekdf8dee82016-04-20 00:06:25 -0400102 EMPTY_DIRECTORY = 'e',
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -0500103 SET_XATTR = 't',
104 RECURSIVE_SET_XATTR = 'T',
105 SET_ACL = 'a',
106 RECURSIVE_SET_ACL = 'A',
Lennart Poettering17493fa2015-04-10 16:22:22 +0200107 SET_ATTRIBUTE = 'h',
108 RECURSIVE_SET_ATTRIBUTE = 'H',
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200109 IGNORE_PATH = 'x',
Michal Sekletar78a92a52013-01-18 16:13:08 +0100110 IGNORE_DIRECTORY_PATH = 'X',
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200111 REMOVE_PATH = 'r',
Michal Schmidta8d88782011-12-15 23:11:07 +0100112 RECURSIVE_REMOVE_PATH = 'R',
Michal Schmidt777b87e2011-12-16 18:27:35 +0100113 RELABEL_PATH = 'z',
Lennart Poetteringe73a03e2014-06-10 23:42:16 +0200114 RECURSIVE_RELABEL_PATH = 'Z',
Lennart Poettering17493fa2015-04-10 16:22:22 +0200115 ADJUST_MODE = 'm', /* legacy, 'z' is identical to this */
Michal Schmidt66ccd032011-12-15 21:31:14 +0100116} ItemType;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200117
118typedef struct Item {
Michal Schmidt66ccd032011-12-15 21:31:14 +0100119 ItemType type;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200120
121 char *path;
Lennart Poettering468d7262012-01-17 15:04:12 +0100122 char *argument;
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100123 char **xattrs;
Zbigniew Jędrzejewski-Szmek349cc4a2017-10-03 10:41:51 +0200124#if HAVE_ACL
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -0500125 acl_t acl_access;
126 acl_t acl_default;
127#endif
Lennart Poettering5008d582010-09-28 02:34:02 +0200128 uid_t uid;
129 gid_t gid;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200130 mode_t mode;
131 usec_t age;
132
Lennart Poettering468d7262012-01-17 15:04:12 +0100133 dev_t major_minor;
Lennart Poettering88ec4df2015-04-08 22:35:52 +0200134 unsigned attribute_value;
135 unsigned attribute_mask;
Lennart Poettering468d7262012-01-17 15:04:12 +0100136
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200137 bool uid_set:1;
138 bool gid_set:1;
139 bool mode_set:1;
140 bool age_set:1;
Lennart Poetteringabef3f92014-06-11 10:14:07 +0200141 bool mask_perms:1;
Lennart Poettering88ec4df2015-04-08 22:35:52 +0200142 bool attribute_set:1;
Lennart Poettering24f3a372012-06-20 09:05:50 +0200143
144 bool keep_first_level:1;
Lennart Poettering1910cd02014-06-11 01:37:35 +0200145
Lennart Poettering2e78fa72014-06-16 13:21:07 +0200146 bool force:1;
147
Lennart Poettering1910cd02014-06-11 01:37:35 +0200148 bool done:1;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200149} Item;
150
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -0500151typedef struct ItemArray {
152 Item *items;
153 size_t count;
154 size_t size;
155} ItemArray;
156
Zbigniew Jędrzejewski-Szmek5a8575e2017-11-23 13:56:32 +0100157typedef enum DirectoryType {
158 DIRECTORY_RUNTIME = 0,
159 DIRECTORY_STATE,
160 DIRECTORY_CACHE,
161 DIRECTORY_LOGS,
162 _DIRECTORY_TYPE_MAX,
163} DirectoryType;
164
Zbigniew Jędrzejewski-Szmekf2b5ca02017-11-23 11:20:29 +0100165static bool arg_user = false;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200166static bool arg_create = false;
167static bool arg_clean = false;
168static bool arg_remove = false;
Zbigniew Jędrzejewski-Szmek81815652013-12-30 13:00:38 -0500169static bool arg_boot = false;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200170
Lennart Poettering7bc040f2014-06-11 01:26:28 +0200171static char **arg_include_prefixes = NULL;
172static char **arg_exclude_prefixes = NULL;
Michael Marineaucf9a4ab2014-03-13 21:32:13 -0700173static char *arg_root = NULL;
Zbigniew Jędrzejewski-Szmeka6d84742018-02-05 14:53:11 +0100174static char *arg_replace = NULL;
Lennart Poetteringfba6e682011-02-13 14:00:54 +0100175
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200176#define MAX_DEPTH 256
177
Lennart Poetteringef43a392015-04-22 18:18:56 +0200178static OrderedHashmap *items = NULL, *globs = NULL;
Lennart Poettering7bc040f2014-06-11 01:26:28 +0200179static Set *unix_sockets = NULL;
180
Franck Bui4cef1922017-11-16 11:27:29 +0100181static int specifier_machine_id_safe(char specifier, void *data, void *userdata, char **ret);
Zbigniew Jędrzejewski-Szmek5a8575e2017-11-23 13:56:32 +0100182static int specifier_directory(char specifier, void *data, void *userdata, char **ret);
Franck Bui4cef1922017-11-16 11:27:29 +0100183
Lennart Poetteringbd550f72015-04-10 16:03:24 +0200184static const Specifier specifier_table[] = {
Franck Bui4cef1922017-11-16 11:27:29 +0100185 { 'm', specifier_machine_id_safe, NULL },
Zbigniew Jędrzejewski-Szmek5a8575e2017-11-23 13:56:32 +0100186 { 'b', specifier_boot_id, NULL },
187 { 'H', specifier_host_name, NULL },
188 { 'v', specifier_kernel_release, NULL },
ayekatca23eeb2017-11-24 12:44:08 +0100189
Zbigniew Jędrzejewski-Szmek5a8575e2017-11-23 13:56:32 +0100190 { 'U', specifier_user_id, NULL },
191 { 'u', specifier_user_name, NULL },
192 { 'h', specifier_user_home, NULL },
193 { 't', specifier_directory, UINT_TO_PTR(DIRECTORY_RUNTIME) },
194 { 'S', specifier_directory, UINT_TO_PTR(DIRECTORY_STATE) },
195 { 'C', specifier_directory, UINT_TO_PTR(DIRECTORY_CACHE) },
196 { 'L', specifier_directory, UINT_TO_PTR(DIRECTORY_LOGS) },
Lennart Poetteringbd550f72015-04-10 16:03:24 +0200197 {}
198};
199
Franck Bui4cef1922017-11-16 11:27:29 +0100200static int specifier_machine_id_safe(char specifier, void *data, void *userdata, char **ret) {
201 int r;
202
Franck Buid8dab752018-01-10 23:28:44 +0100203 /* If /etc/machine_id is missing or empty (e.g. in a chroot environment)
204 * return a recognizable error so that the caller can skip the rule
Franck Bui4cef1922017-11-16 11:27:29 +0100205 * gracefully. */
206
207 r = specifier_machine_id(specifier, data, userdata, ret);
Franck Buid8dab752018-01-10 23:28:44 +0100208 if (IN_SET(r, -ENOENT, -ENOMEDIUM))
Zbigniew Jędrzejewski-Szmek5a8575e2017-11-23 13:56:32 +0100209 return -ENXIO;
Franck Bui4cef1922017-11-16 11:27:29 +0100210
211 return r;
212}
213
Zbigniew Jędrzejewski-Szmek5a8575e2017-11-23 13:56:32 +0100214static int specifier_directory(char specifier, void *data, void *userdata, char **ret) {
215 struct table_entry {
216 uint64_t type;
217 const char *suffix;
218 };
219
220 static const struct table_entry paths_system[] = {
221 [DIRECTORY_RUNTIME] = { SD_PATH_SYSTEM_RUNTIME },
222 [DIRECTORY_STATE] = { SD_PATH_SYSTEM_STATE_PRIVATE },
223 [DIRECTORY_CACHE] = { SD_PATH_SYSTEM_STATE_CACHE },
224 [DIRECTORY_LOGS] = { SD_PATH_SYSTEM_STATE_LOGS },
225 };
226
227 static const struct table_entry paths_user[] = {
228 [DIRECTORY_RUNTIME] = { SD_PATH_USER_RUNTIME },
229 [DIRECTORY_STATE] = { SD_PATH_USER_CONFIGURATION },
230 [DIRECTORY_CACHE] = { SD_PATH_USER_STATE_CACHE },
231 [DIRECTORY_LOGS] = { SD_PATH_USER_CONFIGURATION, "log" },
232 };
233
234 unsigned i;
235 const struct table_entry *paths;
236
237 assert_cc(ELEMENTSOF(paths_system) == ELEMENTSOF(paths_user));
238 paths = arg_user ? paths_user : paths_system;
239
240 i = PTR_TO_UINT(data);
241 assert(i < ELEMENTSOF(paths_system));
242
243 return sd_path_home(paths[i].type, paths[i].suffix, ret);
244}
245
Franck Bui4cef1922017-11-16 11:27:29 +0100246static int log_unresolvable_specifier(const char *filename, unsigned line) {
247 static bool notified = false;
248
Zbigniew Jędrzejewski-Szmek5a8575e2017-11-23 13:56:32 +0100249 /* In system mode, this is called when /etc is not fully initialized (e.g.
250 * in a chroot environment) where some specifiers are unresolvable. In user
251 * mode, this is called when some variables are not defined. These cases are
252 * not considered as an error so log at LOG_NOTICE only for the first time
253 * and then downgrade this to LOG_DEBUG for the rest. */
Franck Bui4cef1922017-11-16 11:27:29 +0100254
255 log_full(notified ? LOG_DEBUG : LOG_NOTICE,
Zbigniew Jędrzejewski-Szmek5a8575e2017-11-23 13:56:32 +0100256 "[%s:%u] Failed to resolve specifier: %s, skipping",
257 filename, line,
258 arg_user ? "Required $XDG_... variable not defined" : "uninitialized /etc detected");
Franck Bui4cef1922017-11-16 11:27:29 +0100259
260 if (!notified)
261 log_notice("All rules containing unresolvable specifiers will be skipped.");
262
263 notified = true;
264 return 0;
265}
266
Zbigniew Jędrzejewski-Szmekf2b5ca02017-11-23 11:20:29 +0100267static int user_config_paths(char*** ret) {
268 _cleanup_strv_free_ char **config_dirs = NULL, **data_dirs = NULL;
269 _cleanup_free_ char *persistent_config = NULL, *runtime_config = NULL, *data_home = NULL;
270 _cleanup_strv_free_ char **res = NULL;
271 int r;
272
273 r = xdg_user_dirs(&config_dirs, &data_dirs);
274 if (r < 0)
275 return r;
276
277 r = xdg_user_config_dir(&persistent_config, "/user-tmpfiles.d");
278 if (r < 0 && r != -ENXIO)
279 return r;
280
281 r = xdg_user_runtime_dir(&runtime_config, "/user-tmpfiles.d");
282 if (r < 0 && r != -ENXIO)
283 return r;
284
285 r = xdg_user_data_dir(&data_home, "/user-tmpfiles.d");
286 if (r < 0 && r != -ENXIO)
287 return r;
288
289 r = strv_extend_strv_concat(&res, config_dirs, "/user-tmpfiles.d");
290 if (r < 0)
291 return r;
292
293 r = strv_extend(&res, persistent_config);
294 if (r < 0)
295 return r;
296
297 r = strv_extend(&res, runtime_config);
298 if (r < 0)
299 return r;
300
301 r = strv_extend(&res, data_home);
302 if (r < 0)
303 return r;
304
305 r = strv_extend_strv_concat(&res, data_dirs, "/user-tmpfiles.d");
306 if (r < 0)
307 return r;
308
309 r = path_strv_make_absolute_cwd(res);
310 if (r < 0)
311 return r;
312
313 *ret = res;
314 res = NULL;
315 return 0;
316}
317
Michal Schmidt66ccd032011-12-15 21:31:14 +0100318static bool needs_glob(ItemType t) {
Lennart Poetteringcde684a2014-06-10 22:50:46 +0200319 return IN_SET(t,
320 WRITE_FILE,
321 IGNORE_PATH,
322 IGNORE_DIRECTORY_PATH,
323 REMOVE_PATH,
324 RECURSIVE_REMOVE_PATH,
Zbigniew Jędrzejewski-Szmekdf8dee82016-04-20 00:06:25 -0400325 EMPTY_DIRECTORY,
Lennart Poetteringe73a03e2014-06-10 23:42:16 +0200326 ADJUST_MODE,
Lennart Poetteringcde684a2014-06-10 22:50:46 +0200327 RELABEL_PATH,
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -0500328 RECURSIVE_RELABEL_PATH,
329 SET_XATTR,
330 RECURSIVE_SET_XATTR,
331 SET_ACL,
Lennart Poettering34f64532015-04-09 13:12:06 +0200332 RECURSIVE_SET_ACL,
333 SET_ATTRIBUTE,
334 RECURSIVE_SET_ATTRIBUTE);
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +0100335}
336
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -0500337static bool takes_ownership(ItemType t) {
338 return IN_SET(t,
339 CREATE_FILE,
340 TRUNCATE_FILE,
341 CREATE_DIRECTORY,
Zbigniew Jędrzejewski-Szmekdf8dee82016-04-20 00:06:25 -0400342 EMPTY_DIRECTORY,
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -0500343 TRUNCATE_DIRECTORY,
344 CREATE_SUBVOLUME,
Lennart Poettering5fb13eb2015-10-21 19:46:23 +0200345 CREATE_SUBVOLUME_INHERIT_QUOTA,
346 CREATE_SUBVOLUME_NEW_QUOTA,
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -0500347 CREATE_FIFO,
348 CREATE_SYMLINK,
349 CREATE_CHAR_DEVICE,
350 CREATE_BLOCK_DEVICE,
351 COPY_FILES,
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -0500352 WRITE_FILE,
353 IGNORE_PATH,
354 IGNORE_DIRECTORY_PATH,
355 REMOVE_PATH,
356 RECURSIVE_REMOVE_PATH);
357}
358
Lennart Poetteringef43a392015-04-22 18:18:56 +0200359static struct Item* find_glob(OrderedHashmap *h, const char *match) {
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -0500360 ItemArray *j;
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +0100361 Iterator i;
362
Lennart Poetteringef43a392015-04-22 18:18:56 +0200363 ORDERED_HASHMAP_FOREACH(j, h, i) {
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -0500364 unsigned n;
365
366 for (n = 0; n < j->count; n++) {
367 Item *item = j->items + n;
368
369 if (fnmatch(item->path, match, FNM_PATHNAME|FNM_PERIOD) == 0)
370 return item;
371 }
372 }
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +0100373
374 return NULL;
375}
376
Lennart Poettering17b90522011-02-14 21:55:06 +0100377static void load_unix_sockets(void) {
Harald Hoyer7fd1b192013-04-18 09:11:22 +0200378 _cleanup_fclose_ FILE *f = NULL;
Lennart Poetteringf1ff7342018-01-10 17:28:03 +0100379 int r;
Lennart Poettering17b90522011-02-14 21:55:06 +0100380
381 if (unix_sockets)
382 return;
383
Lennart Poetteringf1ff7342018-01-10 17:28:03 +0100384 /* We maintain a cache of the sockets we found in /proc/net/unix to speed things up a little. */
Lennart Poettering17b90522011-02-14 21:55:06 +0100385
Lennart Poettering548f6932018-02-08 18:58:35 +0100386 unix_sockets = set_new(&path_hash_ops);
387 if (!unix_sockets) {
388 log_oom();
Lennart Poettering17b90522011-02-14 21:55:06 +0100389 return;
Lennart Poettering548f6932018-02-08 18:58:35 +0100390 }
Lennart Poettering17b90522011-02-14 21:55:06 +0100391
Lennart Poetteringfdcad0c2012-01-11 22:07:35 +0100392 f = fopen("/proc/net/unix", "re");
Lennart Poetteringf1ff7342018-01-10 17:28:03 +0100393 if (!f) {
394 log_full_errno(errno == ENOENT ? LOG_DEBUG : LOG_WARNING, errno,
395 "Failed to open /proc/net/unix, ignoring: %m");
396 goto fail;
397 }
Lennart Poettering17b90522011-02-14 21:55:06 +0100398
Lennart Poetteringfdcad0c2012-01-11 22:07:35 +0100399 /* Skip header */
Lennart Poetteringf1ff7342018-01-10 17:28:03 +0100400 r = read_line(f, LONG_LINE_MAX, NULL);
401 if (r < 0) {
402 log_warning_errno(r, "Failed to skip /proc/net/unix header line: %m");
Lennart Poettering17b90522011-02-14 21:55:06 +0100403 goto fail;
Lennart Poetteringf1ff7342018-01-10 17:28:03 +0100404 }
405 if (r == 0) {
406 log_warning("Premature end of file reading /proc/net/unix.");
407 goto fail;
408 }
Lennart Poettering17b90522011-02-14 21:55:06 +0100409
410 for (;;) {
Lennart Poetteringf1ff7342018-01-10 17:28:03 +0100411 _cleanup_free_ char *line = NULL;
Lennart Poettering17b90522011-02-14 21:55:06 +0100412 char *p, *s;
Lennart Poettering17b90522011-02-14 21:55:06 +0100413
Lennart Poetteringf1ff7342018-01-10 17:28:03 +0100414 r = read_line(f, LONG_LINE_MAX, &line);
415 if (r < 0) {
416 log_warning_errno(r, "Failed to read /proc/net/unix line, ignoring: %m");
417 goto fail;
418 }
419 if (r == 0) /* EOF */
Lennart Poettering17b90522011-02-14 21:55:06 +0100420 break;
421
Lennart Poetteringfdcad0c2012-01-11 22:07:35 +0100422 p = strchr(line, ':');
423 if (!p)
Lennart Poettering17b90522011-02-14 21:55:06 +0100424 continue;
425
Lennart Poetteringfdcad0c2012-01-11 22:07:35 +0100426 if (strlen(p) < 37)
427 continue;
428
429 p += 37;
Lennart Poettering17b90522011-02-14 21:55:06 +0100430 p += strspn(p, WHITESPACE);
Lennart Poetteringfdcad0c2012-01-11 22:07:35 +0100431 p += strcspn(p, WHITESPACE); /* skip one more word */
Lennart Poettering17b90522011-02-14 21:55:06 +0100432 p += strspn(p, WHITESPACE);
433
434 if (*p != '/')
435 continue;
436
Lennart Poetteringfdcad0c2012-01-11 22:07:35 +0100437 s = strdup(p);
Lennart Poetteringf1ff7342018-01-10 17:28:03 +0100438 if (!s) {
439 log_oom();
Lennart Poettering17b90522011-02-14 21:55:06 +0100440 goto fail;
Lennart Poetteringf1ff7342018-01-10 17:28:03 +0100441 }
Lennart Poettering17b90522011-02-14 21:55:06 +0100442
Lennart Poettering4ff21d82011-02-17 13:13:34 +0100443 path_kill_slashes(s);
444
Lennart Poetteringf1ff7342018-01-10 17:28:03 +0100445 r = set_consume(unix_sockets, s);
446 if (r < 0 && r != -EEXIST) {
447 log_warning_errno(r, "Failed to add AF_UNIX socket to set, ignoring: %m");
Zbigniew Jędrzejewski-Szmekef422022013-04-22 23:12:15 -0400448 goto fail;
Lennart Poetteringf1ff7342018-01-10 17:28:03 +0100449 }
Lennart Poettering17b90522011-02-14 21:55:06 +0100450 }
451
452 return;
453
454fail:
Lennart Poetteringf1ff7342018-01-10 17:28:03 +0100455 unix_sockets = set_free_free(unix_sockets);
Lennart Poettering17b90522011-02-14 21:55:06 +0100456}
457
458static bool unix_socket_alive(const char *fn) {
459 assert(fn);
460
461 load_unix_sockets();
462
463 if (unix_sockets)
464 return !!set_get(unix_sockets, (char*) fn);
465
466 /* We don't know, so assume yes */
467 return true;
468}
469
Kay Sievers99d680a2013-03-13 13:12:36 +0100470static int dir_is_mount_point(DIR *d, const char *subdir) {
Lennart Poetteringcde684a2014-06-10 22:50:46 +0200471
Kay Sievers99d680a2013-03-13 13:12:36 +0100472 int mount_id_parent, mount_id;
473 int r_p, r;
474
Lennart Poetteringcbfb8672017-11-20 15:29:53 +0100475 r_p = name_to_handle_at_loop(dirfd(d), ".", NULL, &mount_id_parent, 0);
Kay Sievers99d680a2013-03-13 13:12:36 +0100476 if (r_p < 0)
477 r_p = -errno;
478
Lennart Poetteringcbfb8672017-11-20 15:29:53 +0100479 r = name_to_handle_at_loop(dirfd(d), subdir, NULL, &mount_id, 0);
Kay Sievers99d680a2013-03-13 13:12:36 +0100480 if (r < 0)
481 r = -errno;
482
483 /* got no handle; make no assumptions, return error */
484 if (r_p < 0 && r < 0)
485 return r_p;
486
487 /* got both handles; if they differ, it is a mount point */
488 if (r_p >= 0 && r >= 0)
489 return mount_id_parent != mount_id;
490
491 /* got only one handle; assume different mount points if one
492 * of both queries was not supported by the filesystem */
Yu Watanabe4c701092017-10-04 23:01:32 +0900493 if (IN_SET(r_p, -ENOSYS, -EOPNOTSUPP) || IN_SET(r, -ENOSYS, -EOPNOTSUPP))
Kay Sievers99d680a2013-03-13 13:12:36 +0100494 return true;
495
496 /* return error */
497 if (r_p < 0)
498 return r_p;
499 return r;
500}
501
Zbigniew Jędrzejewski-Szmekdf99a9e2014-01-02 00:02:31 -0500502static DIR* xopendirat_nomod(int dirfd, const char *path) {
503 DIR *dir;
504
505 dir = xopendirat(dirfd, path, O_NOFOLLOW|O_NOATIME);
Lennart Poettering15322272015-03-23 18:54:31 +0700506 if (dir)
507 return dir;
508
509 log_debug_errno(errno, "Cannot open %sdirectory \"%s\": %m", dirfd == AT_FDCWD ? "" : "sub", path);
510 if (errno != EPERM)
511 return NULL;
512
513 dir = xopendirat(dirfd, path, O_NOFOLLOW);
514 if (!dir)
515 log_debug_errno(errno, "Cannot open %sdirectory \"%s\": %m", dirfd == AT_FDCWD ? "" : "sub", path);
Zbigniew Jędrzejewski-Szmekdf99a9e2014-01-02 00:02:31 -0500516
517 return dir;
518}
519
520static DIR* opendir_nomod(const char *path) {
521 return xopendirat_nomod(AT_FDCWD, path);
522}
523
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200524static int dir_cleanup(
Michal Sekletar78a92a52013-01-18 16:13:08 +0100525 Item *i,
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200526 const char *p,
527 DIR *d,
528 const struct stat *ds,
529 usec_t cutoff,
530 dev_t rootdev,
531 bool mountpoint,
Lennart Poettering24f3a372012-06-20 09:05:50 +0200532 int maxdepth,
Lennart Poettering265ffa12013-09-17 16:33:30 -0500533 bool keep_this_level) {
534
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200535 struct dirent *dent;
536 struct timespec times[2];
537 bool deleted = false;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200538 int r = 0;
539
Reverend Homer8fb3f002016-12-09 12:04:30 +0300540 FOREACH_DIRENT_ALL(dent, d, break) {
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200541 struct stat s;
542 usec_t age;
Harald Hoyer7fd1b192013-04-18 09:11:22 +0200543 _cleanup_free_ char *sub_path = NULL;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200544
Lennart Poettering49bfc872017-02-02 00:06:18 +0100545 if (dot_or_dot_dot(dent->d_name))
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200546 continue;
547
548 if (fstatat(dirfd(d), dent->d_name, &s, AT_SYMLINK_NOFOLLOW) < 0) {
Kay Sieversca2f4172013-10-17 03:20:46 +0200549 if (errno == ENOENT)
550 continue;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200551
Kay Sieversca2f4172013-10-17 03:20:46 +0200552 /* FUSE, NFS mounts, SELinux might return EACCES */
Lennart Poetteringecc17092018-01-22 15:29:30 +0100553 r = log_full_errno(errno == EACCES ? LOG_DEBUG : LOG_ERR, errno,
554 "stat(%s/%s) failed: %m", p, dent->d_name);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200555 continue;
556 }
557
558 /* Stay on the same filesystem */
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500559 if (s.st_dev != rootdev) {
560 log_debug("Ignoring \"%s/%s\": different filesystem.", p, dent->d_name);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200561 continue;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500562 }
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200563
Kay Sievers99d680a2013-03-13 13:12:36 +0100564 /* Try to detect bind mounts of the same filesystem instance; they
565 * do not differ in device major/minors. This type of query is not
566 * supported on all kernels or filesystem types though. */
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500567 if (S_ISDIR(s.st_mode) && dir_is_mount_point(d, dent->d_name) > 0) {
568 log_debug("Ignoring \"%s/%s\": different mount of the same filesystem.",
569 p, dent->d_name);
Kay Sievers99d680a2013-03-13 13:12:36 +0100570 continue;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500571 }
Kay Sievers99d680a2013-03-13 13:12:36 +0100572
Zbigniew Jędrzejewski-Szmek605405c2016-10-23 11:43:27 -0400573 sub_path = strjoin(p, "/", dent->d_name);
Lennart Poetteringcde684a2014-06-10 22:50:46 +0200574 if (!sub_path) {
Shawn Landden0d0f0c52012-07-25 14:55:59 -0700575 r = log_oom();
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200576 goto finish;
577 }
578
579 /* Is there an item configured for this path? */
Lennart Poetteringef43a392015-04-22 18:18:56 +0200580 if (ordered_hashmap_get(items, sub_path)) {
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500581 log_debug("Ignoring \"%s\": a separate entry exists.", sub_path);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200582 continue;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500583 }
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200584
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500585 if (find_glob(globs, sub_path)) {
586 log_debug("Ignoring \"%s\": a separate glob exists.", sub_path);
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +0100587 continue;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500588 }
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +0100589
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200590 if (S_ISDIR(s.st_mode)) {
591
592 if (mountpoint &&
593 streq(dent->d_name, "lost+found") &&
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500594 s.st_uid == 0) {
595 log_debug("Ignoring \"%s\".", sub_path);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200596 continue;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500597 }
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200598
599 if (maxdepth <= 0)
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500600 log_warning("Reached max depth on \"%s\".", sub_path);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200601 else {
Harald Hoyer7fd1b192013-04-18 09:11:22 +0200602 _cleanup_closedir_ DIR *sub_dir;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200603 int q;
604
Zbigniew Jędrzejewski-Szmekdf99a9e2014-01-02 00:02:31 -0500605 sub_dir = xopendirat_nomod(dirfd(d), dent->d_name);
Lennart Poetteringcde684a2014-06-10 22:50:46 +0200606 if (!sub_dir) {
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500607 if (errno != ENOENT)
608 r = log_error_errno(errno, "opendir(%s) failed: %m", sub_path);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200609
610 continue;
611 }
612
Michal Sekletar78a92a52013-01-18 16:13:08 +0100613 q = dir_cleanup(i, sub_path, sub_dir, &s, cutoff, rootdev, false, maxdepth-1, false);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200614 if (q < 0)
615 r = q;
616 }
617
Lennart Poettering24f3a372012-06-20 09:05:50 +0200618 /* Note: if you are wondering why we don't
619 * support the sticky bit for excluding
620 * directories from cleaning like we do it for
621 * other file system objects: well, the sticky
622 * bit already has a meaning for directories,
623 * so we don't want to overload that. */
624
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500625 if (keep_this_level) {
626 log_debug("Keeping \"%s\".", sub_path);
Lennart Poettering24f3a372012-06-20 09:05:50 +0200627 continue;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500628 }
Lennart Poettering24f3a372012-06-20 09:05:50 +0200629
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200630 /* Ignore ctime, we change it when deleting */
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500631 age = timespec_load(&s.st_mtim);
632 if (age >= cutoff) {
633 char a[FORMAT_TIMESTAMP_MAX];
634 /* Follows spelling in stat(1). */
635 log_debug("Directory \"%s\": modify time %s is too new.",
636 sub_path,
637 format_timestamp_us(a, sizeof(a), age));
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200638 continue;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500639 }
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200640
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500641 age = timespec_load(&s.st_atim);
642 if (age >= cutoff) {
643 char a[FORMAT_TIMESTAMP_MAX];
644 log_debug("Directory \"%s\": access time %s is too new.",
645 sub_path,
646 format_timestamp_us(a, sizeof(a), age));
647 continue;
648 }
649
Zbigniew Jędrzejewski-Szmek61253222015-01-31 01:03:09 -0500650 log_debug("Removing directory \"%s\".", sub_path);
651 if (unlinkat(dirfd(d), dent->d_name, AT_REMOVEDIR) < 0)
Lennart Poettering920ce822018-01-22 15:31:01 +0100652 if (!IN_SET(errno, ENOENT, ENOTEMPTY))
653 r = log_error_errno(errno, "rmdir(%s): %m", sub_path);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200654
655 } else {
Lennart Poettering9c737362010-11-14 20:12:51 +0100656 /* Skip files for which the sticky bit is
657 * set. These are semantics we define, and are
658 * unknown elsewhere. See XDG_RUNTIME_DIR
659 * specification for details. */
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500660 if (s.st_mode & S_ISVTX) {
661 log_debug("Skipping \"%s\": sticky bit set.", sub_path);
Lennart Poettering9c737362010-11-14 20:12:51 +0100662 continue;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200663 }
664
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500665 if (mountpoint && S_ISREG(s.st_mode))
Zbigniew Jędrzejewski-Szmek1542c012015-06-13 13:14:37 -0400666 if (s.st_uid == 0 && STR_IN_SET(dent->d_name,
667 ".journal",
668 "aquota.user",
669 "aquota.group")) {
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500670 log_debug("Skipping \"%s\".", sub_path);
671 continue;
672 }
673
Lennart Poettering17b90522011-02-14 21:55:06 +0100674 /* Ignore sockets that are listed in /proc/net/unix */
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500675 if (S_ISSOCK(s.st_mode) && unix_socket_alive(sub_path)) {
676 log_debug("Skipping \"%s\": live socket.", sub_path);
Lennart Poettering17b90522011-02-14 21:55:06 +0100677 continue;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500678 }
Lennart Poettering17b90522011-02-14 21:55:06 +0100679
Lennart Poettering78ab08e2011-02-19 14:20:16 +0100680 /* Ignore device nodes */
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500681 if (S_ISCHR(s.st_mode) || S_ISBLK(s.st_mode)) {
682 log_debug("Skipping \"%s\": a device.", sub_path);
Lennart Poettering78ab08e2011-02-19 14:20:16 +0100683 continue;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500684 }
Lennart Poettering78ab08e2011-02-19 14:20:16 +0100685
Lennart Poettering24f3a372012-06-20 09:05:50 +0200686 /* Keep files on this level around if this is
687 * requested */
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500688 if (keep_this_level) {
689 log_debug("Keeping \"%s\".", sub_path);
Lennart Poettering24f3a372012-06-20 09:05:50 +0200690 continue;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200691 }
692
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500693 age = timespec_load(&s.st_mtim);
694 if (age >= cutoff) {
695 char a[FORMAT_TIMESTAMP_MAX];
696 /* Follows spelling in stat(1). */
697 log_debug("File \"%s\": modify time %s is too new.",
698 sub_path,
699 format_timestamp_us(a, sizeof(a), age));
700 continue;
701 }
702
703 age = timespec_load(&s.st_atim);
704 if (age >= cutoff) {
705 char a[FORMAT_TIMESTAMP_MAX];
706 log_debug("File \"%s\": access time %s is too new.",
707 sub_path,
708 format_timestamp_us(a, sizeof(a), age));
709 continue;
710 }
711
712 age = timespec_load(&s.st_ctim);
713 if (age >= cutoff) {
714 char a[FORMAT_TIMESTAMP_MAX];
715 log_debug("File \"%s\": change time %s is too new.",
716 sub_path,
717 format_timestamp_us(a, sizeof(a), age));
718 continue;
719 }
720
721 log_debug("unlink \"%s\"", sub_path);
722
723 if (unlinkat(dirfd(d), dent->d_name, 0) < 0)
724 if (errno != ENOENT)
725 r = log_error_errno(errno, "unlink(%s): %m", sub_path);
726
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200727 deleted = true;
728 }
729 }
730
731finish:
732 if (deleted) {
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500733 usec_t age1, age2;
734 char a[FORMAT_TIMESTAMP_MAX], b[FORMAT_TIMESTAMP_MAX];
735
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200736 /* Restore original directory timestamps */
737 times[0] = ds->st_atim;
738 times[1] = ds->st_mtim;
739
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -0500740 age1 = timespec_load(&ds->st_atim);
741 age2 = timespec_load(&ds->st_mtim);
742 log_debug("Restoring access and modification time on \"%s\": %s, %s",
743 p,
744 format_timestamp_us(a, sizeof(a), age1),
745 format_timestamp_us(b, sizeof(b), age2));
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200746 if (futimens(dirfd(d), times) < 0)
Michal Schmidt56f64d92014-11-28 19:29:59 +0100747 log_error_errno(errno, "utimensat(%s): %m", p);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200748 }
749
Lennart Poettering3b63d2d2010-10-18 22:38:41 +0200750 return r;
751}
752
Lennart Poettering5579f852018-01-23 14:03:34 +0100753static bool dangerous_hardlinks(void) {
754 _cleanup_free_ char *value = NULL;
755 static int cached = -1;
756 int r;
757
758 /* Check whether the fs.protected_hardlinks sysctl is on. If we can't determine it we assume its off, as that's
759 * what the upstream default is. */
760
761 if (cached >= 0)
762 return cached;
763
764 r = read_one_line_file("/proc/sys/fs/protected_hardlinks", &value);
765 if (r < 0) {
766 log_debug_errno(r, "Failed to read fs.protected_hardlinks sysctl: %m");
767 return true;
768 }
769
770 r = parse_boolean(value);
771 if (r < 0) {
772 log_debug_errno(r, "Failed to parse fs.protected_hardlinks sysctl: %m");
773 return true;
774 }
775
776 cached = r == 0;
777 return cached;
778}
779
Franck Bui774f79b2018-03-02 16:13:07 +0100780static bool hardlink_vulnerable(const struct stat *st) {
Lennart Poettering5579f852018-01-23 14:03:34 +0100781 assert(st);
782
783 return !S_ISDIR(st->st_mode) && st->st_nlink > 1 && dangerous_hardlinks();
784}
785
Franck Bui936f6bd2018-03-02 17:19:32 +0100786static int fd_set_perms(Item *i, int fd, const struct stat *st) {
787 _cleanup_free_ char *path = NULL;
788 int r;
789
790 assert(i);
791 assert(fd);
792
793 r = fd_get_path(fd, &path);
794 if (r < 0)
795 return r;
796
797 if (!i->mode_set && !i->uid_set && !i->gid_set)
798 goto shortcut;
799
800 if (hardlink_vulnerable(st)) {
801 log_error("Refusing to set permissions on hardlinked file %s while the fs.protected_hardlinks sysctl is turned off.", path);
802 return -EPERM;
803 }
804
805 if (i->mode_set) {
806 if (S_ISLNK(st->st_mode))
807 log_debug("Skipping mode fix for symlink %s.", path);
808 else {
809 mode_t m = i->mode;
810
811 if (i->mask_perms) {
812 if (!(st->st_mode & 0111))
813 m &= ~0111;
814 if (!(st->st_mode & 0222))
815 m &= ~0222;
816 if (!(st->st_mode & 0444))
817 m &= ~0444;
818 if (!S_ISDIR(st->st_mode))
819 m &= ~07000; /* remove sticky/sgid/suid bit, unless directory */
820 }
821
822 if (m == (st->st_mode & 07777))
823 log_debug("\"%s\" has correct mode %o already.", path, st->st_mode);
824 else {
825 char procfs_path[strlen("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
826
827 log_debug("Changing \"%s\" to mode %o.", path, m);
828
829 /* fchmodat() still doesn't have AT_EMPTY_PATH flag. */
830 xsprintf(procfs_path, "/proc/self/fd/%i", fd);
831
832 if (chmod(procfs_path, m) < 0)
833 return log_error_errno(errno, "chmod() of %s via %s failed: %m", path, procfs_path);
834 }
835 }
836 }
837
838 if ((i->uid_set && i->uid != st->st_uid) ||
839 (i->gid_set && i->gid != st->st_gid)) {
840 log_debug("Changing \"%s\" to owner "UID_FMT":"GID_FMT,
841 path,
842 i->uid_set ? i->uid : UID_INVALID,
843 i->gid_set ? i->gid : GID_INVALID);
844
845 if (fchownat(fd,
846 "",
847 i->uid_set ? i->uid : UID_INVALID,
848 i->gid_set ? i->gid : GID_INVALID,
849 AT_EMPTY_PATH) < 0)
850 return log_error_errno(errno, "fchownat() of %s failed: %m", path);
851 }
852
853shortcut:
854 return label_fix(path, false, false);
855}
856
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -0500857static int path_set_perms(Item *i, const char *path) {
Lennart Poettering48b8aaa2015-04-13 15:16:54 +0200858 _cleanup_close_ int fd = -1;
Michael Olbrich1924a972014-08-17 09:45:00 +0200859 struct stat st;
Michael Olbrich1924a972014-08-17 09:45:00 +0200860
Lennart Poetteringcde684a2014-06-10 22:50:46 +0200861 assert(i);
862 assert(path);
863
Alexander Kuleshovc4b69152016-03-02 00:25:09 +0600864 fd = open(path, O_NOFOLLOW|O_CLOEXEC|O_PATH);
Michal Sekletar780e2ee2017-08-31 12:45:25 +0200865 if (fd < 0) {
866 int level = LOG_ERR, r = -errno;
867
868 /* Option "e" operates only on existing objects. Do not
869 * print errors about non-existent files or directories */
870 if (i->type == EMPTY_DIRECTORY && errno == ENOENT) {
871 level = LOG_DEBUG;
872 r = 0;
873 }
874
875 log_full_errno(level, errno, "Adjusting owner and mode for %s failed: %m", path);
Michal Sekletar780e2ee2017-08-31 12:45:25 +0200876 return r;
877 }
Lennart Poetteringabef3f92014-06-11 10:14:07 +0200878
Franck Bui56114d42018-03-02 16:25:56 +0100879 if (fstat(fd, &st) < 0)
Lennart Poettering48b8aaa2015-04-13 15:16:54 +0200880 return log_error_errno(errno, "Failed to fstat() file %s: %m", path);
881
Franck Bui936f6bd2018-03-02 17:19:32 +0100882 return fd_set_perms(i, fd, &st);
Michal Schmidt062e01b2011-12-16 18:00:11 +0100883}
884
Lennart Poetteringbd550f72015-04-10 16:03:24 +0200885static int parse_xattrs_from_arg(Item *i) {
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100886 const char *p;
887 int r;
888
889 assert(i);
Zbigniew Jędrzejewski-Szmek505ef0e2015-01-09 01:10:02 -0500890 assert(i->argument);
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100891
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100892 p = i->argument;
893
Lennart Poettering4034a062015-03-23 18:55:36 +0700894 for (;;) {
Franck Bui4cef1922017-11-16 11:27:29 +0100895 _cleanup_free_ char *name = NULL, *value = NULL, *xattr = NULL;
Lennart Poettering4034a062015-03-23 18:55:36 +0700896
Richard Maw12ba2c42015-06-23 16:26:49 +0000897 r = extract_first_word(&p, &xattr, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE);
Lennart Poettering4034a062015-03-23 18:55:36 +0700898 if (r < 0)
Lennart Poetteringbd550f72015-04-10 16:03:24 +0200899 log_warning_errno(r, "Failed to parse extended attribute '%s', ignoring: %m", p);
Lennart Poettering4034a062015-03-23 18:55:36 +0700900 if (r <= 0)
901 break;
Zbigniew Jędrzejewski-Szmek505ef0e2015-01-09 01:10:02 -0500902
Franck Bui4cef1922017-11-16 11:27:29 +0100903 r = split_pair(xattr, "=", &name, &value);
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100904 if (r < 0) {
Lennart Poettering4034a062015-03-23 18:55:36 +0700905 log_warning_errno(r, "Failed to parse extended attribute, ignoring: %s", xattr);
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100906 continue;
907 }
Zbigniew Jędrzejewski-Szmek505ef0e2015-01-09 01:10:02 -0500908
Lennart Poettering4034a062015-03-23 18:55:36 +0700909 if (isempty(name) || isempty(value)) {
Lennart Poetteringbd550f72015-04-10 16:03:24 +0200910 log_warning("Malformed extended attribute found, ignoring: %s", xattr);
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100911 continue;
912 }
Zbigniew Jędrzejewski-Szmek505ef0e2015-01-09 01:10:02 -0500913
Lennart Poettering4034a062015-03-23 18:55:36 +0700914 if (strv_push_pair(&i->xattrs, name, value) < 0)
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100915 return log_oom();
Zbigniew Jędrzejewski-Szmek505ef0e2015-01-09 01:10:02 -0500916
Lennart Poettering4034a062015-03-23 18:55:36 +0700917 name = value = NULL;
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100918 }
919
Lennart Poettering4034a062015-03-23 18:55:36 +0700920 return 0;
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100921}
922
Franck Bui936f6bd2018-03-02 17:19:32 +0100923static int fd_set_xattrs(Item *i, int fd, const struct stat *st) {
924 char procfs_path[strlen("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
925 _cleanup_free_ char *path = NULL;
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100926 char **name, **value;
Franck Bui936f6bd2018-03-02 17:19:32 +0100927 int r;
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100928
929 assert(i);
Franck Bui936f6bd2018-03-02 17:19:32 +0100930 assert(fd);
931
932 r = fd_get_path(fd, &path);
933 if (r < 0)
934 return r;
935
936 xsprintf(procfs_path, "/proc/self/fd/%i", fd);
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100937
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100938 STRV_FOREACH_PAIR(name, value, i->xattrs) {
Lennart Poetteringbd550f72015-04-10 16:03:24 +0200939 log_debug("Setting extended attribute '%s=%s' on %s.", *name, *value, path);
Franck Bui936f6bd2018-03-02 17:19:32 +0100940 if (setxattr(procfs_path, *name, *value, strlen(*value), 0) < 0)
Zbigniew Jędrzejewski-Szmek25f027c2017-05-13 11:26:55 -0400941 return log_error_errno(errno, "Setting extended attribute %s=%s on %s failed: %m",
942 *name, *value, path);
Maciej Wereskiebf4e802014-12-04 10:32:10 +0100943 }
944 return 0;
945}
946
Franck Bui936f6bd2018-03-02 17:19:32 +0100947static int path_set_xattrs(Item *i, const char *path) {
948 _cleanup_close_ int fd = -1;
949
950 assert(i);
951 assert(path);
952
953 fd = open(path, O_CLOEXEC|O_NOFOLLOW|O_PATH);
954 if (fd < 0)
955 return log_error_errno(errno, "Cannot open '%s': %m", path);
956
957 return fd_set_xattrs(i, fd, NULL);
958}
959
Lennart Poetteringbd550f72015-04-10 16:03:24 +0200960static int parse_acls_from_arg(Item *item) {
Zbigniew Jędrzejewski-Szmek349cc4a2017-10-03 10:41:51 +0200961#if HAVE_ACL
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -0500962 int r;
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -0500963
964 assert(item);
965
Zbigniew Jędrzejewski-Szmek50d9e462015-01-18 05:02:47 -0500966 /* If force (= modify) is set, we will not modify the acl
967 * afterwards, so the mask can be added now if necessary. */
Lennart Poetteringbd550f72015-04-10 16:03:24 +0200968
Zbigniew Jędrzejewski-Szmek50d9e462015-01-18 05:02:47 -0500969 r = parse_acl(item->argument, &item->acl_access, &item->acl_default, !item->force);
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -0500970 if (r < 0)
Lennart Poettering4034a062015-03-23 18:55:36 +0700971 log_warning_errno(r, "Failed to parse ACL \"%s\": %m. Ignoring", item->argument);
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -0500972#else
973 log_warning_errno(ENOSYS, "ACLs are not supported. Ignoring");
974#endif
975
976 return 0;
977}
978
Zbigniew Jędrzejewski-Szmek349cc4a2017-10-03 10:41:51 +0200979#if HAVE_ACL
Lennart Poettering48b8aaa2015-04-13 15:16:54 +0200980static int path_set_acl(const char *path, const char *pretty, acl_type_t type, acl_t acl, bool modify) {
981 _cleanup_(acl_free_charpp) char *t = NULL;
Zbigniew Jędrzejewski-Szmekdd4105b2015-01-18 18:22:27 -0500982 _cleanup_(acl_freep) acl_t dup = NULL;
Zbigniew Jędrzejewski-Szmek50d9e462015-01-18 05:02:47 -0500983 int r;
984
Hans-Peter Deifeld873e872015-03-03 00:35:08 +0100985 /* Returns 0 for success, positive error if already warned,
986 * negative error otherwise. */
987
Zbigniew Jędrzejewski-Szmek50d9e462015-01-18 05:02:47 -0500988 if (modify) {
Zbigniew Jędrzejewski-Szmekdd4105b2015-01-18 18:22:27 -0500989 r = acls_for_file(path, type, acl, &dup);
Zbigniew Jędrzejewski-Szmek50d9e462015-01-18 05:02:47 -0500990 if (r < 0)
991 return r;
Zbigniew Jędrzejewski-Szmek50d9e462015-01-18 05:02:47 -0500992
Zbigniew Jędrzejewski-Szmekdd4105b2015-01-18 18:22:27 -0500993 r = calc_acl_mask_if_needed(&dup);
994 if (r < 0)
995 return r;
996 } else {
997 dup = acl_dup(acl);
998 if (!dup)
999 return -errno;
1000
1001 /* the mask was already added earlier if needed */
1002 }
1003
1004 r = add_base_acls_if_needed(&dup, path);
1005 if (r < 0)
1006 return r;
1007
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001008 t = acl_to_any_text(dup, NULL, ',', TEXT_ABBREVIATE);
Lennart Poettering48b8aaa2015-04-13 15:16:54 +02001009 log_debug("Setting %s ACL %s on %s.",
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001010 type == ACL_TYPE_ACCESS ? "access" : "default",
Lennart Poettering48b8aaa2015-04-13 15:16:54 +02001011 strna(t), pretty);
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001012
Zbigniew Jędrzejewski-Szmekdd4105b2015-01-18 18:22:27 -05001013 r = acl_set_file(path, type, dup);
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001014 if (r < 0)
Lennart Poettering3ea40b72015-04-10 14:44:52 +02001015 /* Return positive to indicate we already warned */
1016 return -log_error_errno(errno,
1017 "Setting %s ACL \"%s\" on %s failed: %m",
1018 type == ACL_TYPE_ACCESS ? "access" : "default",
Lennart Poettering48b8aaa2015-04-13 15:16:54 +02001019 strna(t), pretty);
Hans-Peter Deifeld873e872015-03-03 00:35:08 +01001020
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001021 return 0;
Zbigniew Jędrzejewski-Szmek50d9e462015-01-18 05:02:47 -05001022}
Zbigniew Jędrzejewski-Szmek35888b62015-02-02 20:28:39 -05001023#endif
Zbigniew Jędrzejewski-Szmek50d9e462015-01-18 05:02:47 -05001024
Franck Bui936f6bd2018-03-02 17:19:32 +01001025static int fd_set_acls(Item *item, int fd, const struct stat *st) {
Hans-Peter Deifeld873e872015-03-03 00:35:08 +01001026 int r = 0;
Zbigniew Jędrzejewski-Szmek349cc4a2017-10-03 10:41:51 +02001027#if HAVE_ACL
Franck Bui936f6bd2018-03-02 17:19:32 +01001028 char procfs_path[strlen("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
1029 _cleanup_free_ char *path = NULL;
1030
1031 assert(item);
1032 assert(fd);
1033 assert(st);
1034
1035 r = fd_get_path(fd, &path);
1036 if (r < 0)
1037 return r;
1038
1039 if (hardlink_vulnerable(st)) {
1040 log_error("Refusing to set ACLs on hardlinked file %s while the fs.protected_hardlinks sysctl is turned off.", path);
1041 return -EPERM;
1042 }
1043
1044 if (S_ISLNK(st->st_mode)) {
1045 log_debug("Skipping ACL fix for symlink %s.", path);
1046 return 0;
1047 }
1048
1049 xsprintf(procfs_path, "/proc/self/fd/%i", fd);
1050
1051 if (item->acl_access)
1052 r = path_set_acl(procfs_path, path, ACL_TYPE_ACCESS, item->acl_access, item->force);
1053
1054 if (r == 0 && item->acl_default)
1055 r = path_set_acl(procfs_path, path, ACL_TYPE_DEFAULT, item->acl_default, item->force);
1056
1057 if (r > 0)
1058 return -r; /* already warned */
1059 if (r == -EOPNOTSUPP) {
1060 log_debug_errno(r, "ACLs not supported by file system at %s", path);
1061 return 0;
1062 }
1063 if (r < 0)
1064 return log_error_errno(r, "ACL operation on \"%s\" failed: %m", path);
1065#endif
1066 return r;
1067}
1068
1069static int path_set_acls(Item *item, const char *path) {
1070 int r = 0;
1071#ifdef HAVE_ACL
Lennart Poettering48b8aaa2015-04-13 15:16:54 +02001072 _cleanup_close_ int fd = -1;
1073 struct stat st;
1074
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -05001075 assert(item);
1076 assert(path);
1077
Alexander Kuleshovc4b69152016-03-02 00:25:09 +06001078 fd = open(path, O_NOFOLLOW|O_CLOEXEC|O_PATH);
Lennart Poettering48b8aaa2015-04-13 15:16:54 +02001079 if (fd < 0)
1080 return log_error_errno(errno, "Adjusting ACL of %s failed: %m", path);
1081
Franck Bui56114d42018-03-02 16:25:56 +01001082 if (fstat(fd, &st) < 0)
Lennart Poettering48b8aaa2015-04-13 15:16:54 +02001083 return log_error_errno(errno, "Failed to fstat() file %s: %m", path);
1084
Franck Bui936f6bd2018-03-02 17:19:32 +01001085 r = fd_set_acls(item, fd, &st);
1086 #endif
1087 return r;
1088 }
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -05001089
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001090#define ATTRIBUTES_ALL \
1091 (FS_NOATIME_FL | \
1092 FS_SYNC_FL | \
1093 FS_DIRSYNC_FL | \
1094 FS_APPEND_FL | \
1095 FS_COMPR_FL | \
1096 FS_NODUMP_FL | \
1097 FS_EXTENT_FL | \
1098 FS_IMMUTABLE_FL | \
1099 FS_JOURNAL_DATA_FL | \
1100 FS_SECRM_FL | \
1101 FS_UNRM_FL | \
1102 FS_NOTAIL_FL | \
1103 FS_TOPDIR_FL | \
1104 FS_NOCOW_FL)
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001105
Lennart Poetteringbd550f72015-04-10 16:03:24 +02001106static int parse_attribute_from_arg(Item *item) {
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001107
1108 static const struct {
1109 char character;
1110 unsigned value;
1111 } attributes[] = {
1112 { 'A', FS_NOATIME_FL }, /* do not update atime */
1113 { 'S', FS_SYNC_FL }, /* Synchronous updates */
1114 { 'D', FS_DIRSYNC_FL }, /* dirsync behaviour (directories only) */
1115 { 'a', FS_APPEND_FL }, /* writes to file may only append */
1116 { 'c', FS_COMPR_FL }, /* Compress file */
1117 { 'd', FS_NODUMP_FL }, /* do not dump file */
kpengboy8c35b2c2016-05-29 08:31:14 -07001118 { 'e', FS_EXTENT_FL }, /* Extents */
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001119 { 'i', FS_IMMUTABLE_FL }, /* Immutable file */
1120 { 'j', FS_JOURNAL_DATA_FL }, /* Reserved for ext3 */
1121 { 's', FS_SECRM_FL }, /* Secure deletion */
1122 { 'u', FS_UNRM_FL }, /* Undelete */
1123 { 't', FS_NOTAIL_FL }, /* file tail should not be merged */
AsciiWolf13e785f2017-02-24 18:14:02 +01001124 { 'T', FS_TOPDIR_FL }, /* Top of directory hierarchies */
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001125 { 'C', FS_NOCOW_FL }, /* Do not cow file */
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001126 };
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001127
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001128 enum {
1129 MODE_ADD,
1130 MODE_DEL,
1131 MODE_SET
1132 } mode = MODE_ADD;
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001133
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001134 unsigned value = 0, mask = 0;
1135 const char *p;
1136
1137 assert(item);
1138
1139 p = item->argument;
1140 if (p) {
1141 if (*p == '+') {
1142 mode = MODE_ADD;
1143 p++;
1144 } else if (*p == '-') {
1145 mode = MODE_DEL;
1146 p++;
1147 } else if (*p == '=') {
1148 mode = MODE_SET;
1149 p++;
1150 }
1151 }
1152
1153 if (isempty(p) && mode != MODE_SET) {
1154 log_error("Setting file attribute on '%s' needs an attribute specification.", item->path);
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001155 return -EINVAL;
1156 }
1157
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001158 for (; p && *p ; p++) {
1159 unsigned i, v;
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001160
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001161 for (i = 0; i < ELEMENTSOF(attributes); i++)
1162 if (*p == attributes[i].character)
1163 break;
1164
1165 if (i >= ELEMENTSOF(attributes)) {
1166 log_error("Unknown file attribute '%c' on '%s'.", *p, item->path);
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001167 return -EINVAL;
1168 }
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001169
1170 v = attributes[i].value;
1171
Andreas Rammhold37420952017-09-29 00:37:23 +02001172 SET_FLAG(value, v, IN_SET(mode, MODE_ADD, MODE_SET));
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001173
1174 mask |= v;
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001175 }
1176
1177 if (mode == MODE_SET)
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001178 mask |= ATTRIBUTES_ALL;
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001179
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001180 assert(mask != 0);
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001181
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001182 item->attribute_mask = mask;
1183 item->attribute_value = value;
1184 item->attribute_set = true;
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001185
1186 return 0;
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001187}
1188
Franck Bui936f6bd2018-03-02 17:19:32 +01001189static int fd_set_attribute(Item *item, int fd, const struct stat *st) {
1190 char procfs_path[strlen("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
1191 _cleanup_close_ int procfs_fd = -1;
1192 _cleanup_free_ char *path = NULL;
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001193 unsigned f;
1194 int r;
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001195
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001196 if (!item->attribute_set || item->attribute_mask == 0)
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001197 return 0;
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001198
Franck Bui936f6bd2018-03-02 17:19:32 +01001199 r = fd_get_path(fd, &path);
1200 if (r < 0)
1201 return r;
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001202
1203 /* Issuing the file attribute ioctls on device nodes is not
1204 * safe, as that will be delivered to the drivers, not the
1205 * file system containing the device node. */
Franck Bui936f6bd2018-03-02 17:19:32 +01001206 if (!S_ISREG(st->st_mode) && !S_ISDIR(st->st_mode)) {
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001207 log_error("Setting file flags is only supported on regular files and directories, cannot set on '%s'.", path);
1208 return -EINVAL;
1209 }
1210
1211 f = item->attribute_value & item->attribute_mask;
1212
1213 /* Mask away directory-specific flags */
Franck Bui936f6bd2018-03-02 17:19:32 +01001214 if (!S_ISDIR(st->st_mode))
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001215 f &= ~FS_DIRSYNC_FL;
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001216
Franck Bui936f6bd2018-03-02 17:19:32 +01001217 xsprintf(procfs_path, "/proc/self/fd/%i", fd);
1218
1219 procfs_fd = open(procfs_path, O_RDONLY|O_CLOEXEC|O_NOATIME);
1220 if (procfs_fd < 0)
1221 return -errno;
1222
1223 r = chattr_fd(procfs_fd, f, item->attribute_mask);
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001224 if (r < 0)
Yu Watanabe4c701092017-10-04 23:01:32 +09001225 log_full_errno(IN_SET(r, -ENOTTY, -EOPNOTSUPP) ? LOG_DEBUG : LOG_WARNING,
Lennart Poetteringad75a972015-07-22 22:02:14 +02001226 r,
1227 "Cannot set file attribute for '%s', value=0x%08x, mask=0x%08x: %m",
1228 path, item->attribute_value, item->attribute_mask);
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001229
1230 return 0;
1231}
1232
Franck Bui936f6bd2018-03-02 17:19:32 +01001233static int path_set_attribute(Item *item, const char *path) {
1234 _cleanup_close_ int fd = -1;
1235 struct stat st;
1236
1237 if (!item->attribute_set || item->attribute_mask == 0)
1238 return 0;
1239
1240 fd = open(path, O_CLOEXEC|O_NOFOLLOW|O_PATH);
1241 if (fd < 0)
1242 return log_error_errno(errno, "Cannot open '%s': %m", path);
1243
1244 if (fstat(fd, &st) < 0)
1245 return log_error_errno(errno, "Cannot stat '%s': %m", path);
1246
1247 return fd_set_attribute(item, fd, &st);
1248}
1249
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001250static int write_one_file(Item *i, const char *path) {
Lennart Poettering43ad6e32014-06-18 00:01:39 +02001251 _cleanup_close_ int fd = -1;
1252 int flags, r = 0;
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001253 struct stat st;
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001254
Lennart Poettering874f1942014-06-10 22:48:56 +02001255 assert(i);
1256 assert(path);
1257
Lennart Poettering49e87292018-01-24 10:54:10 +01001258 flags = i->type == CREATE_FILE ? O_CREAT|O_EXCL|O_NOFOLLOW :
Lennart Poettering43ad6e32014-06-18 00:01:39 +02001259 i->type == TRUNCATE_FILE ? O_CREAT|O_TRUNC|O_NOFOLLOW : 0;
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001260
Lennart Poettering43ad6e32014-06-18 00:01:39 +02001261 RUN_WITH_UMASK(0000) {
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001262 mac_selinux_create_file_prepare(path, S_IFREG);
Lennart Poettering43ad6e32014-06-18 00:01:39 +02001263 fd = open(path, flags|O_NDELAY|O_CLOEXEC|O_WRONLY|O_NOCTTY, i->mode);
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001264 mac_selinux_create_file_clear();
Lennart Poettering5c0d3982013-04-04 03:39:39 +02001265 }
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001266
1267 if (fd < 0) {
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001268 if (i->type == WRITE_FILE && errno == ENOENT) {
Lennart Poettering49e87292018-01-24 10:54:10 +01001269 log_debug_errno(errno, "Not writing missing file \"%s\": %m", path);
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001270 return 0;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001271 }
Lennart Poettering49e87292018-01-24 10:54:10 +01001272 if (i->type == CREATE_FILE && errno == EEXIST) {
1273 log_debug_errno(errno, "Not writing to pre-existing file \"%s\": %m", path);
1274 goto done;
1275 }
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001276
Michael Olbrichf44b28f2015-04-30 20:50:38 +02001277 r = -errno;
1278 if (!i->argument && errno == EROFS && stat(path, &st) == 0 &&
1279 (i->type == CREATE_FILE || st.st_size == 0))
1280 goto check_mode;
1281
1282 return log_error_errno(r, "Failed to create file %s: %m", path);
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001283 }
1284
1285 if (i->argument) {
Lennart Poettering4034a062015-03-23 18:55:36 +07001286 log_debug("%s to \"%s\".", i->type == CREATE_FILE ? "Appending" : "Writing", path);
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001287
Franck Bui4cef1922017-11-16 11:27:29 +01001288 r = loop_write(fd, i->argument, strlen(i->argument), false);
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001289 if (r < 0)
1290 return log_error_errno(r, "Failed to write file \"%s\": %m", path);
1291 } else
1292 log_debug("\"%s\" has been created.", path);
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001293
Lennart Poettering43ad6e32014-06-18 00:01:39 +02001294 fd = safe_close(fd);
Dave Reisner3612fbc2012-09-12 16:21:00 -04001295
Lennart Poettering49e87292018-01-24 10:54:10 +01001296done:
Michal Schmidt4a62c712014-11-28 19:57:32 +01001297 if (stat(path, &st) < 0)
1298 return log_error_errno(errno, "stat(%s) failed: %m", path);
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001299
Michael Olbrichf44b28f2015-04-30 20:50:38 +02001300 check_mode:
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001301 if (!S_ISREG(st.st_mode)) {
1302 log_error("%s is not a file.", path);
1303 return -EEXIST;
1304 }
1305
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -05001306 r = path_set_perms(i, path);
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001307 if (r < 0)
1308 return r;
1309
1310 return 0;
1311}
1312
Zbigniew Jędrzejewski-Szmek081043c2015-01-18 01:33:39 -05001313typedef int (*action_t)(Item *, const char *);
Franck Bui936f6bd2018-03-02 17:19:32 +01001314typedef int (*fdaction_t)(Item *, int fd, const struct stat *st);
Zbigniew Jędrzejewski-Szmek081043c2015-01-18 01:33:39 -05001315
Franck Bui936f6bd2018-03-02 17:19:32 +01001316static int item_do(Item *i, int fd, const struct stat *st, fdaction_t action) {
1317 int r = 0, q;
Lennart Poetteringe73a03e2014-06-10 23:42:16 +02001318
1319 assert(i);
Franck Bui936f6bd2018-03-02 17:19:32 +01001320 assert(fd >= 0);
1321 assert(st);
Michal Schmidta8d88782011-12-15 23:11:07 +01001322
1323 /* This returns the first error we run into, but nevertheless
1324 * tries to go on */
Franck Bui936f6bd2018-03-02 17:19:32 +01001325 r = action(i, fd, st);
Michal Schmidta8d88782011-12-15 23:11:07 +01001326
Franck Bui936f6bd2018-03-02 17:19:32 +01001327 if (S_ISDIR(st->st_mode)) {
1328 char procfs_path[strlen("/proc/self/fd/") + DECIMAL_STR_MAX(int)];
1329 _cleanup_closedir_ DIR *d = NULL;
1330 struct dirent *de;
Michal Schmidta8d88782011-12-15 23:11:07 +01001331
Franck Bui936f6bd2018-03-02 17:19:32 +01001332 /* The passed 'fd' was opened with O_PATH. We need to convert
1333 * it into a 'regular' fd before reading the directory content. */
1334 xsprintf(procfs_path, "/proc/self/fd/%i", fd);
Michal Schmidta8d88782011-12-15 23:11:07 +01001335
Franck Bui936f6bd2018-03-02 17:19:32 +01001336 d = opendir(procfs_path);
1337 if (!d) {
1338 r = r ?: -errno;
1339 goto finish;
1340 }
Michal Schmidta8d88782011-12-15 23:11:07 +01001341
Franck Bui936f6bd2018-03-02 17:19:32 +01001342 FOREACH_DIRENT_ALL(de, d, q = -errno; goto finish) {
1343 struct stat de_st;
1344 int de_fd;
Michal Schmidta8d88782011-12-15 23:11:07 +01001345
Franck Bui936f6bd2018-03-02 17:19:32 +01001346 if (dot_or_dot_dot(de->d_name))
1347 continue;
Michal Schmidta8d88782011-12-15 23:11:07 +01001348
Franck Bui936f6bd2018-03-02 17:19:32 +01001349 de_fd = openat(fd, de->d_name, O_NOFOLLOW|O_CLOEXEC|O_PATH);
1350 if (de_fd >= 0 && fstat(de_fd, &de_st) >= 0)
1351 /* pass ownership of dirent fd over */
1352 q = item_do(i, de_fd, &de_st, action);
1353 else
1354 q = -errno;
1355
Lennart Poetteringe73a03e2014-06-10 23:42:16 +02001356 if (q < 0 && r == 0)
1357 r = q;
Michal Schmidta8d88782011-12-15 23:11:07 +01001358 }
Michal Schmidta8d88782011-12-15 23:11:07 +01001359 }
Franck Bui936f6bd2018-03-02 17:19:32 +01001360finish:
1361 safe_close(fd);
Lennart Poetteringe73a03e2014-06-10 23:42:16 +02001362 return r;
Michal Schmidta8d88782011-12-15 23:11:07 +01001363}
1364
Franck Bui936f6bd2018-03-02 17:19:32 +01001365static int glob_item(Item *i, action_t action) {
Zbigniew Jędrzejewski-Szmekdf99a9e2014-01-02 00:02:31 -05001366 _cleanup_globfree_ glob_t g = {
Zbigniew Jędrzejewski-Szmekebf31a12015-01-26 10:39:03 -05001367 .gl_opendir = (void *(*)(const char *)) opendir_nomod,
Zbigniew Jędrzejewski-Szmekdf99a9e2014-01-02 00:02:31 -05001368 };
Lennart Poetteringe73a03e2014-06-10 23:42:16 +02001369 int r = 0, k;
Michal Schmidt99e68c02011-12-15 23:45:26 +01001370 char **fn;
1371
Zbigniew Jędrzejewski-Szmek84e72b52017-04-25 23:50:35 -04001372 k = safe_glob(i->path, GLOB_NOSORT|GLOB_BRACE, &g);
1373 if (k < 0 && k != -ENOENT)
1374 return log_error_errno(k, "glob(%s) failed: %m", i->path);
Zbigniew Jędrzejewski-Szmekc84a9482013-03-24 19:09:19 -04001375
1376 STRV_FOREACH(fn, g.gl_pathv) {
1377 k = action(i, *fn);
Lennart Poetteringe73a03e2014-06-10 23:42:16 +02001378 if (k < 0 && r == 0)
Zbigniew Jędrzejewski-Szmekc84a9482013-03-24 19:09:19 -04001379 r = k;
Franck Bui936f6bd2018-03-02 17:19:32 +01001380 }
Zbigniew Jędrzejewski-Szmek081043c2015-01-18 01:33:39 -05001381
Franck Bui936f6bd2018-03-02 17:19:32 +01001382 return r;
1383}
1384
1385static int glob_item_recursively(Item *i, fdaction_t action) {
1386 _cleanup_globfree_ glob_t g = {
1387 .gl_opendir = (void *(*)(const char *)) opendir_nomod,
1388 };
1389 int r = 0, k;
1390 char **fn;
1391
1392 k = safe_glob(i->path, GLOB_NOSORT|GLOB_BRACE, &g);
1393 if (k < 0 && k != -ENOENT)
1394 return log_error_errno(k, "glob(%s) failed: %m", i->path);
1395
1396 STRV_FOREACH(fn, g.gl_pathv) {
1397 _cleanup_close_ int fd = -1;
1398 struct stat st;
1399
1400 /* Make sure we won't trigger/follow file object (such as
1401 * device nodes, automounts, ...) pointed out by 'fn' with
1402 * O_PATH. Note, when O_PATH is used, flags other than
1403 * O_CLOEXEC, O_DIRECTORY, and O_NOFOLLOW are ignored. */
1404
1405 fd = open(*fn, O_CLOEXEC|O_NOFOLLOW|O_PATH);
1406 if (fd < 0) {
1407 r = r ?: -errno;
1408 continue;
Zbigniew Jędrzejewski-Szmek081043c2015-01-18 01:33:39 -05001409 }
Franck Bui936f6bd2018-03-02 17:19:32 +01001410
1411 if (fstat(fd, &st) < 0) {
1412 r = r ?: -errno;
1413 continue;
1414 }
1415
1416 k = item_do(i, fd, &st, action);
1417 if (k < 0 && r == 0)
1418 r = k;
1419
1420 /* we passed fd ownership to the previous call */
1421 fd = -1;
Michal Schmidt99e68c02011-12-15 23:45:26 +01001422 }
1423
Michal Schmidt99e68c02011-12-15 23:45:26 +01001424 return r;
1425}
1426
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001427typedef enum {
1428 CREATION_NORMAL,
1429 CREATION_EXISTING,
1430 CREATION_FORCE,
Lennart Poettering7a7d5db2015-02-02 21:34:09 +01001431 _CREATION_MODE_MAX,
1432 _CREATION_MODE_INVALID = -1
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001433} CreationMode;
1434
Lennart Poettering7a7d5db2015-02-02 21:34:09 +01001435static const char *creation_mode_verb_table[_CREATION_MODE_MAX] = {
1436 [CREATION_NORMAL] = "Created",
1437 [CREATION_EXISTING] = "Found existing",
1438 [CREATION_FORCE] = "Created replacement",
1439};
1440
1441DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(creation_mode_verb, CreationMode);
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001442
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001443static int create_item(Item *i) {
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001444 struct stat st;
Kay Sieversdf28bc02013-10-21 15:24:18 +02001445 int r = 0;
Evgeny Vereshchagin114a17d2016-02-01 04:21:06 +00001446 int q = 0;
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001447 CreationMode creation;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001448
1449 assert(i);
1450
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001451 log_debug("Running create action for entry %c %s", (char) i->type, i->path);
1452
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001453 switch (i->type) {
1454
1455 case IGNORE_PATH:
Michal Sekletar78a92a52013-01-18 16:13:08 +01001456 case IGNORE_DIRECTORY_PATH:
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001457 case REMOVE_PATH:
1458 case RECURSIVE_REMOVE_PATH:
1459 return 0;
1460
1461 case CREATE_FILE:
Lennart Poettering31ed59c2012-01-18 16:39:04 +01001462 case TRUNCATE_FILE:
Lennart Poettering7fa10742018-01-23 14:14:19 +01001463 RUN_WITH_UMASK(0000)
1464 (void) mkdir_parents_label(i->path, 0755);
1465
Dave Reisner1845fdd2012-09-27 20:48:13 -04001466 r = write_one_file(i, i->path);
1467 if (r < 0)
1468 return r;
1469 break;
Lennart Poettering265ffa12013-09-17 16:33:30 -05001470
Lennart Poettering5c5ccf12015-04-10 18:07:04 +02001471 case COPY_FILES: {
Lennart Poettering7fa10742018-01-23 14:14:19 +01001472
1473 RUN_WITH_UMASK(0000)
1474 (void) mkdir_parents_label(i->path, 0755);
1475
Franck Bui4cef1922017-11-16 11:27:29 +01001476 log_debug("Copying tree \"%s\" to \"%s\".", i->argument, i->path);
Lennart Poettering7fa10742018-01-23 14:14:19 +01001477 r = copy_tree(i->argument, i->path,
1478 i->uid_set ? i->uid : UID_INVALID,
1479 i->gid_set ? i->gid : GID_INVALID,
1480 COPY_REFLINK);
Michael Olbrichf44b28f2015-04-30 20:50:38 +02001481
1482 if (r == -EROFS && stat(i->path, &st) == 0)
1483 r = -EEXIST;
1484
Lennart Poettering849958d2014-06-10 23:02:40 +02001485 if (r < 0) {
Lennart Poetteringe1563472014-06-19 19:36:08 +02001486 struct stat a, b;
1487
Michal Schmidt8d3d7072014-11-28 19:13:53 +01001488 if (r != -EEXIST)
1489 return log_error_errno(r, "Failed to copy files to %s: %m", i->path);
Lennart Poetteringe1563472014-06-19 19:36:08 +02001490
Franck Bui4cef1922017-11-16 11:27:29 +01001491 if (stat(i->argument, &a) < 0)
1492 return log_error_errno(errno, "stat(%s) failed: %m", i->argument);
Lennart Poetteringe1563472014-06-19 19:36:08 +02001493
Michal Schmidt4a62c712014-11-28 19:57:32 +01001494 if (stat(i->path, &b) < 0)
1495 return log_error_errno(errno, "stat(%s) failed: %m", i->path);
Lennart Poetteringe1563472014-06-19 19:36:08 +02001496
1497 if ((a.st_mode ^ b.st_mode) & S_IFMT) {
1498 log_debug("Can't copy to %s, file exists already and is of different type", i->path);
1499 return 0;
1500 }
Lennart Poettering849958d2014-06-10 23:02:40 +02001501 }
1502
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -05001503 r = path_set_perms(i, i->path);
Lennart Poettering849958d2014-06-10 23:02:40 +02001504 if (r < 0)
1505 return r;
1506
1507 break;
1508
Dave Reisnerd4e9eb92012-09-03 17:13:18 -04001509 case WRITE_FILE:
Franck Bui936f6bd2018-03-02 17:19:32 +01001510 r = glob_item(i, write_one_file);
Michal Schmidtf05bc3f2011-12-15 23:44:23 +01001511 if (r < 0)
1512 return r;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001513
1514 break;
1515
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001516 case CREATE_DIRECTORY:
Lennart Poetteringd7b8eec2014-12-27 18:46:36 +01001517 case TRUNCATE_DIRECTORY:
1518 case CREATE_SUBVOLUME:
Lennart Poettering5fb13eb2015-10-21 19:46:23 +02001519 case CREATE_SUBVOLUME_INHERIT_QUOTA:
1520 case CREATE_SUBVOLUME_NEW_QUOTA:
Lennart Poetteringd7b8eec2014-12-27 18:46:36 +01001521 RUN_WITH_UMASK(0000)
Lennart Poettering7fa10742018-01-23 14:14:19 +01001522 (void) mkdir_parents_label(i->path, 0755);
Lennart Poetteringd7b8eec2014-12-27 18:46:36 +01001523
Lennart Poettering5fb13eb2015-10-21 19:46:23 +02001524 if (IN_SET(i->type, CREATE_SUBVOLUME, CREATE_SUBVOLUME_INHERIT_QUOTA, CREATE_SUBVOLUME_NEW_QUOTA)) {
Lennart Poettering2904e942015-11-16 15:25:42 +01001525
1526 if (btrfs_is_subvol(isempty(arg_root) ? "/" : arg_root) <= 0)
1527
1528 /* Don't create a subvolume unless the
1529 * root directory is one, too. We do
1530 * this under the assumption that if
1531 * the root directory is just a plain
1532 * directory (i.e. very light-weight),
1533 * we shouldn't try to split it up
1534 * into subvolumes (i.e. more
1535 * heavy-weight). Thus, chroot()
1536 * environments and suchlike will get
1537 * a full brtfs subvolume set up below
1538 * their tree only if they
1539 * specifically set up a btrfs
1540 * subvolume for the root dir too. */
1541
1542 r = -ENOTTY;
1543 else {
1544 RUN_WITH_UMASK((~i->mode) & 0777)
1545 r = btrfs_subvol_make(i->path);
1546 }
Lennart Poettering5fb13eb2015-10-21 19:46:23 +02001547 } else
Lennart Poetteringd7b8eec2014-12-27 18:46:36 +01001548 r = 0;
1549
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001550 if (IN_SET(i->type, CREATE_DIRECTORY, TRUNCATE_DIRECTORY) || r == -ENOTTY)
Lennart Poetteringd7b8eec2014-12-27 18:46:36 +01001551 RUN_WITH_UMASK(0000)
1552 r = mkdir_label(i->path, i->mode);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001553
Lennart Poetteringe1563472014-06-19 19:36:08 +02001554 if (r < 0) {
Lennart Poettering7b135a72015-05-15 21:47:22 +02001555 int k;
1556
Yu Watanabe4c701092017-10-04 23:01:32 +09001557 if (!IN_SET(r, -EEXIST, -EROFS))
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001558 return log_error_errno(r, "Failed to create directory or subvolume \"%s\": %m", i->path);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001559
Lennart Poettering7b135a72015-05-15 21:47:22 +02001560 k = is_dir(i->path, false);
1561 if (k == -ENOENT && r == -EROFS)
1562 return log_error_errno(r, "%s does not exist and cannot be created as the file system is read-only.", i->path);
1563 if (k < 0)
1564 return log_error_errno(k, "Failed to check if %s exists: %m", i->path);
1565 if (!k) {
1566 log_warning("\"%s\" already exists and is not a directory.", i->path);
Lennart Poetteringe1563472014-06-19 19:36:08 +02001567 return 0;
1568 }
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001569
1570 creation = CREATION_EXISTING;
1571 } else
1572 creation = CREATION_NORMAL;
Lennart Poettering7b135a72015-05-15 21:47:22 +02001573
Lennart Poettering7a7d5db2015-02-02 21:34:09 +01001574 log_debug("%s directory \"%s\".", creation_mode_verb_to_string(creation), i->path);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001575
Lennart Poettering5fb13eb2015-10-21 19:46:23 +02001576 if (IN_SET(i->type, CREATE_SUBVOLUME_NEW_QUOTA, CREATE_SUBVOLUME_INHERIT_QUOTA)) {
1577 r = btrfs_subvol_auto_qgroup(i->path, 0, i->type == CREATE_SUBVOLUME_NEW_QUOTA);
Evgeny Vereshchagin114a17d2016-02-01 04:21:06 +00001578 if (r == -ENOTTY)
Zbigniew Jędrzejewski-Szmek022ffe42016-04-19 22:42:00 -04001579 log_debug_errno(r, "Couldn't adjust quota for subvolume \"%s\" (unsupported fs or dir not a subvolume): %m", i->path);
Evgeny Vereshchagin114a17d2016-02-01 04:21:06 +00001580 else if (r == -EROFS)
Zbigniew Jędrzejewski-Szmek022ffe42016-04-19 22:42:00 -04001581 log_debug_errno(r, "Couldn't adjust quota for subvolume \"%s\" (fs is read-only).", i->path);
Evgeny Vereshchagin114a17d2016-02-01 04:21:06 +00001582 else if (r == -ENOPROTOOPT)
Zbigniew Jędrzejewski-Szmek022ffe42016-04-19 22:42:00 -04001583 log_debug_errno(r, "Couldn't adjust quota for subvolume \"%s\" (quota support is disabled).", i->path);
Evgeny Vereshchagin114a17d2016-02-01 04:21:06 +00001584 else if (r < 0)
1585 q = log_error_errno(r, "Failed to adjust quota for subvolume \"%s\": %m", i->path);
1586 else if (r > 0)
Lennart Poettering5fb13eb2015-10-21 19:46:23 +02001587 log_debug("Adjusted quota for subvolume \"%s\".", i->path);
Evgeny Vereshchagin114a17d2016-02-01 04:21:06 +00001588 else if (r == 0)
Lennart Poettering5fb13eb2015-10-21 19:46:23 +02001589 log_debug("Quota for subvolume \"%s\" already in place, no change made.", i->path);
1590 }
1591
Shawn Landden48319812017-11-19 10:06:10 -08001592 _fallthrough_;
Zbigniew Jędrzejewski-Szmekdf8dee82016-04-20 00:06:25 -04001593 case EMPTY_DIRECTORY:
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -05001594 r = path_set_perms(i, i->path);
Evgeny Vereshchagin114a17d2016-02-01 04:21:06 +00001595 if (q < 0)
1596 return q;
Michal Schmidtf05bc3f2011-12-15 23:44:23 +01001597 if (r < 0)
1598 return r;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001599
1600 break;
Lennart Poetteringee17ee72011-07-12 03:56:56 +02001601
1602 case CREATE_FIFO:
Lennart Poettering5c0d3982013-04-04 03:39:39 +02001603 RUN_WITH_UMASK(0000) {
Lennart Poettering7fa10742018-01-23 14:14:19 +01001604 (void) mkdir_parents_label(i->path, 0755);
1605
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001606 mac_selinux_create_file_prepare(i->path, S_IFIFO);
Lennart Poettering5c0d3982013-04-04 03:39:39 +02001607 r = mkfifo(i->path, i->mode);
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001608 mac_selinux_create_file_clear();
Lennart Poetteringee17ee72011-07-12 03:56:56 +02001609 }
1610
Lennart Poettering1554afa2014-06-17 23:50:22 +02001611 if (r < 0) {
Michal Schmidt4a62c712014-11-28 19:57:32 +01001612 if (errno != EEXIST)
1613 return log_error_errno(errno, "Failed to create fifo %s: %m", i->path);
Lennart Poetteringee17ee72011-07-12 03:56:56 +02001614
Lennart Poetteringa542c4d2015-05-15 21:48:20 +02001615 if (lstat(i->path, &st) < 0)
Michal Schmidt4a62c712014-11-28 19:57:32 +01001616 return log_error_errno(errno, "stat(%s) failed: %m", i->path);
Lennart Poettering1554afa2014-06-17 23:50:22 +02001617
1618 if (!S_ISFIFO(st.st_mode)) {
1619
1620 if (i->force) {
Lennart Poettering1554afa2014-06-17 23:50:22 +02001621 RUN_WITH_UMASK(0000) {
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001622 mac_selinux_create_file_prepare(i->path, S_IFIFO);
Lennart Poettering1554afa2014-06-17 23:50:22 +02001623 r = mkfifo_atomic(i->path, i->mode);
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001624 mac_selinux_create_file_clear();
Lennart Poettering1554afa2014-06-17 23:50:22 +02001625 }
1626
Michal Schmidtf6479622014-11-28 18:50:43 +01001627 if (r < 0)
1628 return log_error_errno(r, "Failed to create fifo %s: %m", i->path);
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001629 creation = CREATION_FORCE;
Lennart Poettering1554afa2014-06-17 23:50:22 +02001630 } else {
Lennart Poetteringa542c4d2015-05-15 21:48:20 +02001631 log_warning("\"%s\" already exists and is not a fifo.", i->path);
Lennart Poettering1554afa2014-06-17 23:50:22 +02001632 return 0;
1633 }
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001634 } else
1635 creation = CREATION_EXISTING;
1636 } else
1637 creation = CREATION_NORMAL;
Lennart Poettering7a7d5db2015-02-02 21:34:09 +01001638 log_debug("%s fifo \"%s\".", creation_mode_verb_to_string(creation), i->path);
Lennart Poetteringee17ee72011-07-12 03:56:56 +02001639
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -05001640 r = path_set_perms(i, i->path);
Michal Schmidtf05bc3f2011-12-15 23:44:23 +01001641 if (r < 0)
1642 return r;
Lennart Poetteringee17ee72011-07-12 03:56:56 +02001643
1644 break;
Lennart Poettering5c5ccf12015-04-10 18:07:04 +02001645 }
Michal Schmidta8d88782011-12-15 23:11:07 +01001646
Lennart Poettering5c5ccf12015-04-10 18:07:04 +02001647 case CREATE_SYMLINK: {
Lennart Poettering7fa10742018-01-23 14:14:19 +01001648 RUN_WITH_UMASK(0000)
1649 (void) mkdir_parents_label(i->path, 0755);
1650
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001651 mac_selinux_create_file_prepare(i->path, S_IFLNK);
Franck Bui4cef1922017-11-16 11:27:29 +01001652 r = symlink(i->argument, i->path);
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001653 mac_selinux_create_file_clear();
Kay Sieverse9a5ef72012-04-17 16:05:03 +02001654
Lennart Poettering468d7262012-01-17 15:04:12 +01001655 if (r < 0) {
Lennart Poettering2e78fa72014-06-16 13:21:07 +02001656 _cleanup_free_ char *x = NULL;
Lennart Poettering468d7262012-01-17 15:04:12 +01001657
Michal Schmidt4a62c712014-11-28 19:57:32 +01001658 if (errno != EEXIST)
Franck Bui4cef1922017-11-16 11:27:29 +01001659 return log_error_errno(errno, "symlink(%s, %s) failed: %m", i->argument, i->path);
Lennart Poettering2e78fa72014-06-16 13:21:07 +02001660
1661 r = readlink_malloc(i->path, &x);
Franck Bui4cef1922017-11-16 11:27:29 +01001662 if (r < 0 || !streq(i->argument, x)) {
Lennart Poettering2e78fa72014-06-16 13:21:07 +02001663
1664 if (i->force) {
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001665 mac_selinux_create_file_prepare(i->path, S_IFLNK);
Franck Bui4cef1922017-11-16 11:27:29 +01001666 r = symlink_atomic(i->argument, i->path);
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001667 mac_selinux_create_file_clear();
Lennart Poettering2e78fa72014-06-16 13:21:07 +02001668
William Douglasb3f58972017-08-09 08:53:03 -07001669 if (IN_SET(r, -EEXIST, -ENOTEMPTY)) {
1670 r = rm_rf(i->path, REMOVE_ROOT|REMOVE_PHYSICAL);
1671 if (r < 0)
1672 return log_error_errno(r, "rm -fr %s failed: %m", i->path);
1673
1674 mac_selinux_create_file_prepare(i->path, S_IFLNK);
Franck Bui4cef1922017-11-16 11:27:29 +01001675 r = symlink(i->argument, i->path) < 0 ? -errno : 0;
William Douglasb3f58972017-08-09 08:53:03 -07001676 mac_selinux_create_file_clear();
1677 }
Michal Schmidtf6479622014-11-28 18:50:43 +01001678 if (r < 0)
Franck Bui4cef1922017-11-16 11:27:29 +01001679 return log_error_errno(r, "symlink(%s, %s) failed: %m", i->argument, i->path);
Lennart Poetteringa542c4d2015-05-15 21:48:20 +02001680
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001681 creation = CREATION_FORCE;
Lennart Poettering1554afa2014-06-17 23:50:22 +02001682 } else {
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001683 log_debug("\"%s\" is not a symlink or does not point to the correct path.", i->path);
Lennart Poettering1554afa2014-06-17 23:50:22 +02001684 return 0;
1685 }
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001686 } else
1687 creation = CREATION_EXISTING;
1688 } else
Lennart Poetteringa542c4d2015-05-15 21:48:20 +02001689
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001690 creation = CREATION_NORMAL;
Lennart Poettering7a7d5db2015-02-02 21:34:09 +01001691 log_debug("%s symlink \"%s\".", creation_mode_verb_to_string(creation), i->path);
Lennart Poettering468d7262012-01-17 15:04:12 +01001692 break;
Lennart Poettering5c5ccf12015-04-10 18:07:04 +02001693 }
Lennart Poettering468d7262012-01-17 15:04:12 +01001694
1695 case CREATE_BLOCK_DEVICE:
1696 case CREATE_CHAR_DEVICE: {
Lennart Poetteringcb7ed9d2012-09-05 23:39:55 -07001697 mode_t file_type;
1698
1699 if (have_effective_cap(CAP_MKNOD) == 0) {
1700 /* In a container we lack CAP_MKNOD. We
Anatol Pomozovab06eef2013-04-14 19:37:54 -07001701 shouldn't attempt to create the device node in
Lennart Poetteringcb7ed9d2012-09-05 23:39:55 -07001702 that case to avoid noise, and we don't support
1703 virtualized devices in containers anyway. */
1704
1705 log_debug("We lack CAP_MKNOD, skipping creation of device node %s.", i->path);
1706 return 0;
1707 }
1708
Lennart Poettering7fa10742018-01-23 14:14:19 +01001709 RUN_WITH_UMASK(0000)
1710 (void) mkdir_parents_label(i->path, 0755);
1711
Lennart Poettering1554afa2014-06-17 23:50:22 +02001712 file_type = i->type == CREATE_BLOCK_DEVICE ? S_IFBLK : S_IFCHR;
Lennart Poettering468d7262012-01-17 15:04:12 +01001713
Lennart Poettering5c0d3982013-04-04 03:39:39 +02001714 RUN_WITH_UMASK(0000) {
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001715 mac_selinux_create_file_prepare(i->path, file_type);
Lennart Poettering5c0d3982013-04-04 03:39:39 +02001716 r = mknod(i->path, i->mode | file_type, i->major_minor);
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001717 mac_selinux_create_file_clear();
Lennart Poettering5c0d3982013-04-04 03:39:39 +02001718 }
Lennart Poettering468d7262012-01-17 15:04:12 +01001719
Kay Sievers6555ad82014-06-13 04:11:11 +02001720 if (r < 0) {
1721 if (errno == EPERM) {
1722 log_debug("We lack permissions, possibly because of cgroup configuration; "
1723 "skipping creation of device node %s.", i->path);
1724 return 0;
1725 }
1726
Michal Schmidt4a62c712014-11-28 19:57:32 +01001727 if (errno != EEXIST)
1728 return log_error_errno(errno, "Failed to create device node %s: %m", i->path);
Lennart Poettering468d7262012-01-17 15:04:12 +01001729
Lennart Poetteringa542c4d2015-05-15 21:48:20 +02001730 if (lstat(i->path, &st) < 0)
Michal Schmidt4a62c712014-11-28 19:57:32 +01001731 return log_error_errno(errno, "stat(%s) failed: %m", i->path);
Lennart Poettering468d7262012-01-17 15:04:12 +01001732
Lennart Poettering1554afa2014-06-17 23:50:22 +02001733 if ((st.st_mode & S_IFMT) != file_type) {
1734
1735 if (i->force) {
1736
1737 RUN_WITH_UMASK(0000) {
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001738 mac_selinux_create_file_prepare(i->path, file_type);
Lennart Poettering1554afa2014-06-17 23:50:22 +02001739 r = mknod_atomic(i->path, i->mode | file_type, i->major_minor);
Lennart Poetteringecabcf82014-10-23 19:41:27 +02001740 mac_selinux_create_file_clear();
Lennart Poettering1554afa2014-06-17 23:50:22 +02001741 }
1742
Michal Schmidtf6479622014-11-28 18:50:43 +01001743 if (r < 0)
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001744 return log_error_errno(r, "Failed to create device node \"%s\": %m", i->path);
1745 creation = CREATION_FORCE;
Lennart Poettering1554afa2014-06-17 23:50:22 +02001746 } else {
1747 log_debug("%s is not a device node.", i->path);
1748 return 0;
1749 }
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001750 } else
1751 creation = CREATION_EXISTING;
1752 } else
1753 creation = CREATION_NORMAL;
Lennart Poetteringa542c4d2015-05-15 21:48:20 +02001754
Zbigniew Jędrzejewski-Szmek294929f2015-02-01 12:29:27 -05001755 log_debug("%s %s device node \"%s\" %u:%u.",
Lennart Poettering7a7d5db2015-02-02 21:34:09 +01001756 creation_mode_verb_to_string(creation),
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001757 i->type == CREATE_BLOCK_DEVICE ? "block" : "char",
1758 i->path, major(i->mode), minor(i->mode));
Lennart Poettering468d7262012-01-17 15:04:12 +01001759
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -05001760 r = path_set_perms(i, i->path);
Lennart Poettering468d7262012-01-17 15:04:12 +01001761 if (r < 0)
1762 return r;
1763
1764 break;
1765 }
1766
Lennart Poetteringe73a03e2014-06-10 23:42:16 +02001767 case ADJUST_MODE:
Michal Schmidt777b87e2011-12-16 18:27:35 +01001768 case RELABEL_PATH:
Franck Bui936f6bd2018-03-02 17:19:32 +01001769 r = glob_item(i, path_set_perms);
Michal Schmidt777b87e2011-12-16 18:27:35 +01001770 if (r < 0)
Lennart Poettering96ca8192013-06-21 15:57:42 +02001771 return r;
Michal Schmidt777b87e2011-12-16 18:27:35 +01001772 break;
1773
Michal Schmidta8d88782011-12-15 23:11:07 +01001774 case RECURSIVE_RELABEL_PATH:
Franck Bui936f6bd2018-03-02 17:19:32 +01001775 r = glob_item_recursively(i, fd_set_perms);
Michal Schmidta8d88782011-12-15 23:11:07 +01001776 if (r < 0)
1777 return r;
Maciej Wereskiebf4e802014-12-04 10:32:10 +01001778 break;
Lennart Poetteringe73a03e2014-06-10 23:42:16 +02001779
Maciej Wereskiebf4e802014-12-04 10:32:10 +01001780 case SET_XATTR:
Franck Bui936f6bd2018-03-02 17:19:32 +01001781 r = glob_item(i, path_set_xattrs);
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -05001782 if (r < 0)
1783 return r;
1784 break;
1785
1786 case RECURSIVE_SET_XATTR:
Franck Bui936f6bd2018-03-02 17:19:32 +01001787 r = glob_item_recursively(i, fd_set_xattrs);
Maciej Wereskiebf4e802014-12-04 10:32:10 +01001788 if (r < 0)
1789 return r;
Lennart Poetteringe73a03e2014-06-10 23:42:16 +02001790 break;
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -05001791
1792 case SET_ACL:
Franck Bui936f6bd2018-03-02 17:19:32 +01001793 r = glob_item(i, path_set_acls);
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -05001794 if (r < 0)
1795 return r;
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -05001796 break;
1797
1798 case RECURSIVE_SET_ACL:
Franck Bui936f6bd2018-03-02 17:19:32 +01001799 r = glob_item_recursively(i, fd_set_acls);
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -05001800 if (r < 0)
1801 return r;
1802 break;
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001803
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001804 case SET_ATTRIBUTE:
Franck Bui936f6bd2018-03-02 17:19:32 +01001805 r = glob_item(i, path_set_attribute);
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001806 if (r < 0)
1807 return r;
1808 break;
1809
Lennart Poettering88ec4df2015-04-08 22:35:52 +02001810 case RECURSIVE_SET_ATTRIBUTE:
Franck Bui936f6bd2018-03-02 17:19:32 +01001811 r = glob_item_recursively(i, fd_set_attribute);
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01001812 if (r < 0)
1813 return r;
1814 break;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001815 }
1816
Michal Schmidtf05bc3f2011-12-15 23:44:23 +01001817 return 0;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001818}
1819
Michal Schmidta0896122011-12-15 21:32:50 +01001820static int remove_item_instance(Item *i, const char *instance) {
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001821 int r;
1822
1823 assert(i);
1824
1825 switch (i->type) {
1826
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001827 case REMOVE_PATH:
Michal Schmidt4a62c712014-11-28 19:57:32 +01001828 if (remove(instance) < 0 && errno != ENOENT)
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05001829 return log_error_errno(errno, "rm(%s): %m", instance);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001830
1831 break;
1832
1833 case TRUNCATE_DIRECTORY:
1834 case RECURSIVE_REMOVE_PATH:
Lennart Poetteringd139b242012-06-20 14:31:00 +02001835 /* FIXME: we probably should use dir_cleanup() here
1836 * instead of rm_rf() so that 'x' is honoured. */
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001837 log_debug("rm -rf \"%s\"", instance);
Lennart Poettering1b26f092015-06-15 19:11:15 +02001838 r = rm_rf(instance, (i->type == RECURSIVE_REMOVE_PATH ? REMOVE_ROOT|REMOVE_SUBVOLUME : 0) | REMOVE_PHYSICAL);
Michal Schmidtf6479622014-11-28 18:50:43 +01001839 if (r < 0 && r != -ENOENT)
1840 return log_error_errno(r, "rm_rf(%s): %m", instance);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001841
1842 break;
Zbigniew Jędrzejewski-Szmek7fcb4b92015-01-22 23:35:34 -05001843
1844 default:
1845 assert_not_reached("wut?");
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001846 }
1847
1848 return 0;
1849}
1850
Michal Schmidta0896122011-12-15 21:32:50 +01001851static int remove_item(Item *i) {
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +01001852 assert(i);
1853
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001854 log_debug("Running remove action for entry %c %s", (char) i->type, i->path);
1855
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +01001856 switch (i->type) {
1857
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +01001858 case REMOVE_PATH:
1859 case TRUNCATE_DIRECTORY:
Michal Schmidt99e68c02011-12-15 23:45:26 +01001860 case RECURSIVE_REMOVE_PATH:
Franck Bui936f6bd2018-03-02 17:19:32 +01001861 return glob_item(i, remove_item_instance);
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +01001862
Zbigniew Jędrzejewski-Szmekdf8dee82016-04-20 00:06:25 -04001863 default:
1864 return 0;
1865 }
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +01001866}
1867
Michal Sekletar78a92a52013-01-18 16:13:08 +01001868static int clean_item_instance(Item *i, const char* instance) {
Harald Hoyer7fd1b192013-04-18 09:11:22 +02001869 _cleanup_closedir_ DIR *d = NULL;
Michal Sekletar78a92a52013-01-18 16:13:08 +01001870 struct stat s, ps;
1871 bool mountpoint;
Michal Sekletar78a92a52013-01-18 16:13:08 +01001872 usec_t cutoff, n;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001873 char timestamp[FORMAT_TIMESTAMP_MAX];
Michal Sekletar78a92a52013-01-18 16:13:08 +01001874
1875 assert(i);
1876
1877 if (!i->age_set)
1878 return 0;
1879
1880 n = now(CLOCK_REALTIME);
1881 if (n < i->age)
1882 return 0;
1883
1884 cutoff = n - i->age;
1885
Zbigniew Jędrzejewski-Szmekdf99a9e2014-01-02 00:02:31 -05001886 d = opendir_nomod(instance);
Michal Sekletar78a92a52013-01-18 16:13:08 +01001887 if (!d) {
Zbigniew Jędrzejewski-Szmekd710aaf2016-07-22 20:27:45 -04001888 if (IN_SET(errno, ENOENT, ENOTDIR)) {
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001889 log_debug_errno(errno, "Directory \"%s\": %m", instance);
Michal Sekletar78a92a52013-01-18 16:13:08 +01001890 return 0;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001891 }
Michal Sekletar78a92a52013-01-18 16:13:08 +01001892
Zbigniew Jędrzejewski-Szmekd710aaf2016-07-22 20:27:45 -04001893 return log_error_errno(errno, "Failed to open directory %s: %m", instance);
Michal Sekletar78a92a52013-01-18 16:13:08 +01001894 }
1895
Michal Schmidt4a62c712014-11-28 19:57:32 +01001896 if (fstat(dirfd(d), &s) < 0)
1897 return log_error_errno(errno, "stat(%s) failed: %m", i->path);
Michal Sekletar78a92a52013-01-18 16:13:08 +01001898
1899 if (!S_ISDIR(s.st_mode)) {
1900 log_error("%s is not a directory.", i->path);
Zbigniew Jędrzejewski-Szmek19fbec12013-03-03 18:42:52 -05001901 return -ENOTDIR;
Michal Sekletar78a92a52013-01-18 16:13:08 +01001902 }
1903
Michal Schmidt4a62c712014-11-28 19:57:32 +01001904 if (fstatat(dirfd(d), "..", &ps, AT_SYMLINK_NOFOLLOW) != 0)
1905 return log_error_errno(errno, "stat(%s/..) failed: %m", i->path);
Michal Sekletar78a92a52013-01-18 16:13:08 +01001906
Thomas Hindoe Paaboel Andersen2bb158c2015-10-23 20:15:17 +02001907 mountpoint = s.st_dev != ps.st_dev || s.st_ino == ps.st_ino;
Michal Sekletar78a92a52013-01-18 16:13:08 +01001908
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001909 log_debug("Cleanup threshold for %s \"%s\" is %s",
1910 mountpoint ? "mount point" : "directory",
1911 instance,
1912 format_timestamp_us(timestamp, sizeof(timestamp), cutoff));
1913
1914 return dir_cleanup(i, instance, d, &s, cutoff, s.st_dev, mountpoint,
1915 MAX_DEPTH, i->keep_first_level);
Michal Sekletar78a92a52013-01-18 16:13:08 +01001916}
1917
1918static int clean_item(Item *i) {
Michal Sekletar78a92a52013-01-18 16:13:08 +01001919 assert(i);
1920
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05001921 log_debug("Running clean action for entry %c %s", (char) i->type, i->path);
1922
Michal Sekletar78a92a52013-01-18 16:13:08 +01001923 switch (i->type) {
1924 case CREATE_DIRECTORY:
Lennart Poetteringd7b8eec2014-12-27 18:46:36 +01001925 case CREATE_SUBVOLUME:
Lennart Poettering5fb13eb2015-10-21 19:46:23 +02001926 case CREATE_SUBVOLUME_INHERIT_QUOTA:
1927 case CREATE_SUBVOLUME_NEW_QUOTA:
Michal Sekletar78a92a52013-01-18 16:13:08 +01001928 case TRUNCATE_DIRECTORY:
1929 case IGNORE_PATH:
Lennart Poettering849958d2014-06-10 23:02:40 +02001930 case COPY_FILES:
Michal Sekletar78a92a52013-01-18 16:13:08 +01001931 clean_item_instance(i, i->path);
Zbigniew Jędrzejewski-Szmekdf8dee82016-04-20 00:06:25 -04001932 return 0;
Zbigniew Jędrzejewski-Szmek65241c12017-11-22 15:16:48 +01001933 case EMPTY_DIRECTORY:
Michal Sekletar78a92a52013-01-18 16:13:08 +01001934 case IGNORE_DIRECTORY_PATH:
Franck Bui936f6bd2018-03-02 17:19:32 +01001935 return glob_item(i, clean_item_instance);
Michal Sekletar78a92a52013-01-18 16:13:08 +01001936 default:
Zbigniew Jędrzejewski-Szmekdf8dee82016-04-20 00:06:25 -04001937 return 0;
Michal Sekletar78a92a52013-01-18 16:13:08 +01001938 }
Michal Sekletar78a92a52013-01-18 16:13:08 +01001939}
1940
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05001941static int process_item_array(ItemArray *array);
1942
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001943static int process_item(Item *i) {
Lennart Poettering1e958932015-01-06 20:33:46 +01001944 int r, q, p, t = 0;
Zbigniew Jędrzejewski-Szmek9348f0e2014-10-01 07:33:22 -05001945 _cleanup_free_ char *prefix = NULL;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001946
1947 assert(i);
1948
Lennart Poettering1910cd02014-06-11 01:37:35 +02001949 if (i->done)
1950 return 0;
1951
1952 i->done = true;
1953
Zbigniew Jędrzejewski-Szmek9348f0e2014-10-01 07:33:22 -05001954 prefix = malloc(strlen(i->path) + 1);
1955 if (!prefix)
1956 return log_oom();
1957
Lennart Poettering1910cd02014-06-11 01:37:35 +02001958 PATH_FOREACH_PREFIX(prefix, i->path) {
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05001959 ItemArray *j;
Lennart Poettering1910cd02014-06-11 01:37:35 +02001960
Lennart Poetteringef43a392015-04-22 18:18:56 +02001961 j = ordered_hashmap_get(items, prefix);
Zbigniew Jędrzejewski-Szmek1db50422015-01-06 09:53:12 -05001962 if (j) {
1963 int s;
1964
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05001965 s = process_item_array(j);
Zbigniew Jędrzejewski-Szmek1db50422015-01-06 09:53:12 -05001966 if (s < 0 && t == 0)
1967 t = s;
1968 }
Lennart Poettering1910cd02014-06-11 01:37:35 +02001969 }
1970
NeilBrown655f2da2017-09-04 23:35:07 +10001971 if (chase_symlinks(i->path, NULL, CHASE_NO_AUTOFS, NULL) == -EREMOTE)
1972 return t;
1973
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001974 r = arg_create ? create_item(i) : 0;
Michal Schmidta0896122011-12-15 21:32:50 +01001975 q = arg_remove ? remove_item(i) : 0;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001976 p = arg_clean ? clean_item(i) : 0;
1977
Zbigniew Jędrzejewski-Szmek1db50422015-01-06 09:53:12 -05001978 return t < 0 ? t :
1979 r < 0 ? r :
1980 q < 0 ? q :
1981 p;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001982}
1983
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05001984static int process_item_array(ItemArray *array) {
1985 unsigned n;
1986 int r = 0, k;
Lennart Poettering753615e2014-06-12 23:07:17 +02001987
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05001988 assert(array);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02001989
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05001990 for (n = 0; n < array->count; n++) {
1991 k = process_item(array->items + n);
1992 if (k < 0 && r == 0)
1993 r = k;
1994 }
1995
1996 return r;
1997}
1998
1999static void item_free_contents(Item *i) {
2000 assert(i);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002001 free(i->path);
Lennart Poettering468d7262012-01-17 15:04:12 +01002002 free(i->argument);
Maciej Wereskiebf4e802014-12-04 10:32:10 +01002003 strv_free(i->xattrs);
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -05002004
Zbigniew Jędrzejewski-Szmek349cc4a2017-10-03 10:41:51 +02002005#if HAVE_ACL
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -05002006 acl_free(i->acl_access);
2007 acl_free(i->acl_default);
2008#endif
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002009}
2010
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002011static void item_array_free(ItemArray *a) {
2012 unsigned n;
Maciej Wereskie2f2fb72013-07-19 15:43:12 +02002013
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002014 if (!a)
2015 return;
2016
2017 for (n = 0; n < a->count; n++)
2018 item_free_contents(a->items + n);
2019 free(a->items);
2020 free(a);
2021}
2022
Lennart Poettering17493fa2015-04-10 16:22:22 +02002023static int item_compare(const void *a, const void *b) {
2024 const Item *x = a, *y = b;
2025
2026 /* Make sure that the ownership taking item is put first, so
2027 * that we first create the node, and then can adjust it */
2028
2029 if (takes_ownership(x->type) && !takes_ownership(y->type))
2030 return -1;
2031 if (!takes_ownership(x->type) && takes_ownership(y->type))
2032 return 1;
2033
2034 return (int) x->type - (int) y->type;
2035}
2036
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002037static bool item_compatible(Item *a, Item *b) {
Lennart Poetteringbfe95f32011-04-08 04:49:43 +02002038 assert(a);
2039 assert(b);
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002040 assert(streq(a->path, b->path));
Lennart Poetteringbfe95f32011-04-08 04:49:43 +02002041
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002042 if (takes_ownership(a->type) && takes_ownership(b->type))
2043 /* check if the items are the same */
2044 return streq_ptr(a->argument, b->argument) &&
Lennart Poetteringbfe95f32011-04-08 04:49:43 +02002045
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002046 a->uid_set == b->uid_set &&
2047 a->uid == b->uid &&
Lennart Poetteringbfe95f32011-04-08 04:49:43 +02002048
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002049 a->gid_set == b->gid_set &&
2050 a->gid == b->gid &&
Lennart Poetteringbfe95f32011-04-08 04:49:43 +02002051
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002052 a->mode_set == b->mode_set &&
2053 a->mode == b->mode &&
Lennart Poetteringbfe95f32011-04-08 04:49:43 +02002054
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002055 a->age_set == b->age_set &&
2056 a->age == b->age &&
Lennart Poetteringbfe95f32011-04-08 04:49:43 +02002057
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002058 a->mask_perms == b->mask_perms &&
Lennart Poetteringbfe95f32011-04-08 04:49:43 +02002059
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002060 a->keep_first_level == b->keep_first_level &&
Lennart Poettering468d7262012-01-17 15:04:12 +01002061
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002062 a->major_minor == b->major_minor;
Lennart Poettering468d7262012-01-17 15:04:12 +01002063
Lennart Poetteringbfe95f32011-04-08 04:49:43 +02002064 return true;
2065}
2066
Dave Reisnera2aced42013-07-24 11:10:05 -04002067static bool should_include_path(const char *path) {
2068 char **prefix;
2069
Lennart Poetteringabef3f92014-06-11 10:14:07 +02002070 STRV_FOREACH(prefix, arg_exclude_prefixes)
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05002071 if (path_startswith(path, *prefix)) {
2072 log_debug("Entry \"%s\" matches exclude prefix \"%s\", skipping.",
2073 path, *prefix);
Dave Reisner5c795112013-07-24 11:19:24 -04002074 return false;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05002075 }
Dave Reisnera2aced42013-07-24 11:10:05 -04002076
Lennart Poetteringabef3f92014-06-11 10:14:07 +02002077 STRV_FOREACH(prefix, arg_include_prefixes)
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05002078 if (path_startswith(path, *prefix)) {
2079 log_debug("Entry \"%s\" matches include prefix \"%s\".", path, *prefix);
Dave Reisnera2aced42013-07-24 11:10:05 -04002080 return true;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05002081 }
Dave Reisnera2aced42013-07-24 11:10:05 -04002082
Dave Reisner5c795112013-07-24 11:19:24 -04002083 /* no matches, so we should include this path only if we
2084 * have no whitelist at all */
Lennart Poettering7b943bb2017-11-29 12:40:22 +01002085 if (strv_isempty(arg_include_prefixes))
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05002086 return true;
2087
2088 log_debug("Entry \"%s\" does not match any include prefix, skipping.", path);
2089 return false;
Dave Reisnera2aced42013-07-24 11:10:05 -04002090}
2091
Franck Bui4cef1922017-11-16 11:27:29 +01002092static int specifier_expansion_from_arg(Item *i) {
2093 _cleanup_free_ char *unescaped = NULL, *resolved = NULL;
2094 char **xattr;
2095 int r;
2096
2097 assert(i);
2098
2099 if (i->argument == NULL)
2100 return 0;
2101
2102 switch (i->type) {
2103 case COPY_FILES:
2104 case CREATE_SYMLINK:
2105 case CREATE_FILE:
2106 case TRUNCATE_FILE:
2107 case WRITE_FILE:
2108 r = cunescape(i->argument, 0, &unescaped);
2109 if (r < 0)
2110 return log_error_errno(r, "Failed to unescape parameter to write: %s", i->argument);
2111
2112 r = specifier_printf(unescaped, specifier_table, NULL, &resolved);
2113 if (r < 0)
2114 return r;
2115
2116 free_and_replace(i->argument, resolved);
2117 break;
2118
2119 case SET_XATTR:
2120 case RECURSIVE_SET_XATTR:
2121 assert(i->xattrs);
2122
2123 STRV_FOREACH (xattr, i->xattrs) {
2124 r = specifier_printf(*xattr, specifier_table, NULL, &resolved);
2125 if (r < 0)
2126 return r;
2127
2128 free_and_replace(*xattr, resolved);
2129 }
2130 break;
2131
2132 default:
2133 break;
2134 }
2135 return 0;
2136}
2137
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002138static int parse_line(const char *fname, unsigned line, const char *buffer, bool *invalid_config) {
Lennart Poettering1731e342013-09-17 11:02:02 -05002139
Lennart Poetteringcde684a2014-06-10 22:50:46 +02002140 _cleanup_free_ char *action = NULL, *mode = NULL, *user = NULL, *group = NULL, *age = NULL, *path = NULL;
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002141 _cleanup_(item_free_contents) Item i = {};
2142 ItemArray *existing;
Lennart Poetteringef43a392015-04-22 18:18:56 +02002143 OrderedHashmap *h;
daurnimator657cf7f2015-03-09 15:11:44 -04002144 int r, pos;
Zbigniew Jędrzejewski-Szmek5f255142015-01-09 01:11:01 -05002145 bool force = false, boot = false;
Lennart Poettering5008d582010-09-28 02:34:02 +02002146
2147 assert(fname);
2148 assert(line >= 1);
2149 assert(buffer);
2150
Richard Maw68685602015-06-23 16:20:53 +00002151 r = extract_many_words(
Lennart Poettering4034a062015-03-23 18:55:36 +07002152 &buffer,
Richard Maw68685602015-06-23 16:20:53 +00002153 NULL,
Richard Maw12ba2c42015-06-23 16:26:49 +00002154 EXTRACT_QUOTES,
Lennart Poettering4034a062015-03-23 18:55:36 +07002155 &action,
2156 &path,
2157 &mode,
2158 &user,
2159 &group,
2160 &age,
2161 NULL);
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002162 if (r < 0) {
Zbigniew Jędrzejewski-Szmek751223f2017-11-24 12:19:40 +01002163 if (IN_SET(r, -EINVAL, -EBADSLT))
2164 /* invalid quoting and such or an unknown specifier */
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002165 *invalid_config = true;
daurnimator657cf7f2015-03-09 15:11:44 -04002166 return log_error_errno(r, "[%s:%u] Failed to parse line: %m", fname, line);
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002167 }
2168
daurnimator657cf7f2015-03-09 15:11:44 -04002169 else if (r < 2) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002170 *invalid_config = true;
Lennart Poettering5008d582010-09-28 02:34:02 +02002171 log_error("[%s:%u] Syntax error.", fname, line);
Zbigniew Jędrzejewski-Szmek7f2c1f42013-03-31 16:29:46 -04002172 return -EIO;
Lennart Poettering5008d582010-09-28 02:34:02 +02002173 }
2174
Lennart Poetteringaa5f6812015-04-21 01:10:19 +02002175 if (!isempty(buffer) && !streq(buffer, "-")) {
Lennart Poettering4034a062015-03-23 18:55:36 +07002176 i.argument = strdup(buffer);
2177 if (!i.argument)
2178 return log_oom();
2179 }
2180
Lennart Poettering2e78fa72014-06-16 13:21:07 +02002181 if (isempty(action)) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002182 *invalid_config = true;
Lennart Poettering2e78fa72014-06-16 13:21:07 +02002183 log_error("[%s:%u] Command too short '%s'.", fname, line, action);
Zbigniew Jędrzejewski-Szmekc4708f12013-12-20 20:25:39 -05002184 return -EINVAL;
Lennart Poettering2e78fa72014-06-16 13:21:07 +02002185 }
2186
Zbigniew Jędrzejewski-Szmek5f255142015-01-09 01:11:01 -05002187 for (pos = 1; action[pos]; pos++) {
2188 if (action[pos] == '!' && !boot)
2189 boot = true;
2190 else if (action[pos] == '+' && !force)
2191 force = true;
2192 else {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002193 *invalid_config = true;
Zbigniew Jędrzejewski-Szmek5f255142015-01-09 01:11:01 -05002194 log_error("[%s:%u] Unknown modifiers in command '%s'",
2195 fname, line, action);
2196 return -EINVAL;
2197 }
Lennart Poettering2e78fa72014-06-16 13:21:07 +02002198 }
2199
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05002200 if (boot && !arg_boot) {
2201 log_debug("Ignoring entry %s \"%s\" because --boot is not specified.",
2202 action, path);
Zbigniew Jędrzejewski-Szmekc4708f12013-12-20 20:25:39 -05002203 return 0;
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05002204 }
Zbigniew Jędrzejewski-Szmekc4708f12013-12-20 20:25:39 -05002205
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002206 i.type = action[0];
2207 i.force = force;
Lennart Poettering1731e342013-09-17 11:02:02 -05002208
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002209 r = specifier_printf(path, specifier_table, NULL, &i.path);
Zbigniew Jędrzejewski-Szmek5a8575e2017-11-23 13:56:32 +01002210 if (r == -ENXIO)
Franck Bui4cef1922017-11-16 11:27:29 +01002211 return log_unresolvable_specifier(fname, line);
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002212 if (r < 0) {
Zbigniew Jędrzejewski-Szmek751223f2017-11-24 12:19:40 +01002213 if (IN_SET(r, -EINVAL, -EBADSLT))
2214 *invalid_config = true;
Franck Bui4cef1922017-11-16 11:27:29 +01002215 return log_error_errno(r, "[%s:%u] Failed to replace specifiers: %s", fname, line, path);
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002216 }
Lennart Poettering1731e342013-09-17 11:02:02 -05002217
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002218 switch (i.type) {
Lennart Poettering468d7262012-01-17 15:04:12 +01002219
Michal Schmidt777b87e2011-12-16 18:27:35 +01002220 case CREATE_DIRECTORY:
Lennart Poetteringd7b8eec2014-12-27 18:46:36 +01002221 case CREATE_SUBVOLUME:
Lennart Poettering5fb13eb2015-10-21 19:46:23 +02002222 case CREATE_SUBVOLUME_INHERIT_QUOTA:
2223 case CREATE_SUBVOLUME_NEW_QUOTA:
Zbigniew Jędrzejewski-Szmekdf8dee82016-04-20 00:06:25 -04002224 case EMPTY_DIRECTORY:
Michal Schmidt777b87e2011-12-16 18:27:35 +01002225 case TRUNCATE_DIRECTORY:
2226 case CREATE_FIFO:
2227 case IGNORE_PATH:
Michal Sekletar78a92a52013-01-18 16:13:08 +01002228 case IGNORE_DIRECTORY_PATH:
Michal Schmidt777b87e2011-12-16 18:27:35 +01002229 case REMOVE_PATH:
2230 case RECURSIVE_REMOVE_PATH:
Lennart Poetteringe73a03e2014-06-10 23:42:16 +02002231 case ADJUST_MODE:
Michal Schmidt777b87e2011-12-16 18:27:35 +01002232 case RELABEL_PATH:
2233 case RECURSIVE_RELABEL_PATH:
Lennart Poetteringc82500c2015-04-10 14:46:05 +02002234 if (i.argument)
Lennart Poetteringbd550f72015-04-10 16:03:24 +02002235 log_warning("[%s:%u] %c lines don't take argument fields, ignoring.", fname, line, i.type);
Lennart Poetteringc82500c2015-04-10 14:46:05 +02002236
2237 break;
2238
2239 case CREATE_FILE:
2240 case TRUNCATE_FILE:
Michal Schmidt777b87e2011-12-16 18:27:35 +01002241 break;
Lennart Poettering468d7262012-01-17 15:04:12 +01002242
2243 case CREATE_SYMLINK:
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002244 if (!i.argument) {
2245 i.argument = strappend("/usr/share/factory/", i.path);
2246 if (!i.argument)
Kay Sievers2f3b8732014-06-20 15:57:43 +02002247 return log_oom();
Lennart Poettering468d7262012-01-17 15:04:12 +01002248 }
2249 break;
2250
Lennart Poettering31ed59c2012-01-18 16:39:04 +01002251 case WRITE_FILE:
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002252 if (!i.argument) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002253 *invalid_config = true;
Lennart Poettering31ed59c2012-01-18 16:39:04 +01002254 log_error("[%s:%u] Write file requires argument.", fname, line);
Zbigniew Jędrzejewski-Szmek7f2c1f42013-03-31 16:29:46 -04002255 return -EBADMSG;
Lennart Poettering31ed59c2012-01-18 16:39:04 +01002256 }
2257 break;
2258
Lennart Poettering849958d2014-06-10 23:02:40 +02002259 case COPY_FILES:
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002260 if (!i.argument) {
2261 i.argument = strappend("/usr/share/factory/", i.path);
2262 if (!i.argument)
Kay Sievers2f3b8732014-06-20 15:57:43 +02002263 return log_oom();
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002264 } else if (!path_is_absolute(i.argument)) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002265 *invalid_config = true;
Lennart Poettering849958d2014-06-10 23:02:40 +02002266 log_error("[%s:%u] Source path is not absolute.", fname, line);
2267 return -EBADMSG;
2268 }
2269
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002270 path_kill_slashes(i.argument);
Lennart Poettering849958d2014-06-10 23:02:40 +02002271 break;
2272
Lennart Poettering468d7262012-01-17 15:04:12 +01002273 case CREATE_CHAR_DEVICE:
2274 case CREATE_BLOCK_DEVICE: {
2275 unsigned major, minor;
2276
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002277 if (!i.argument) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002278 *invalid_config = true;
Lennart Poettering468d7262012-01-17 15:04:12 +01002279 log_error("[%s:%u] Device file requires argument.", fname, line);
Zbigniew Jędrzejewski-Szmek7f2c1f42013-03-31 16:29:46 -04002280 return -EBADMSG;
Lennart Poettering468d7262012-01-17 15:04:12 +01002281 }
2282
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002283 if (sscanf(i.argument, "%u:%u", &major, &minor) != 2) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002284 *invalid_config = true;
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002285 log_error("[%s:%u] Can't parse device file major/minor '%s'.", fname, line, i.argument);
Zbigniew Jędrzejewski-Szmek7f2c1f42013-03-31 16:29:46 -04002286 return -EBADMSG;
Lennart Poettering468d7262012-01-17 15:04:12 +01002287 }
2288
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002289 i.major_minor = makedev(major, minor);
Lennart Poettering468d7262012-01-17 15:04:12 +01002290 break;
2291 }
2292
Maciej Wereskiebf4e802014-12-04 10:32:10 +01002293 case SET_XATTR:
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -05002294 case RECURSIVE_SET_XATTR:
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002295 if (!i.argument) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002296 *invalid_config = true;
Maciej Wereskiebf4e802014-12-04 10:32:10 +01002297 log_error("[%s:%u] Set extended attribute requires argument.", fname, line);
2298 return -EBADMSG;
2299 }
Lennart Poetteringbd550f72015-04-10 16:03:24 +02002300 r = parse_xattrs_from_arg(&i);
Maciej Wereskiebf4e802014-12-04 10:32:10 +01002301 if (r < 0)
2302 return r;
2303 break;
2304
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -05002305 case SET_ACL:
Zbigniew Jędrzejewski-Szmekb705ab62015-01-18 02:10:00 -05002306 case RECURSIVE_SET_ACL:
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -05002307 if (!i.argument) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002308 *invalid_config = true;
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -05002309 log_error("[%s:%u] Set ACLs requires argument.", fname, line);
2310 return -EBADMSG;
2311 }
Lennart Poetteringbd550f72015-04-10 16:03:24 +02002312 r = parse_acls_from_arg(&i);
Zbigniew Jędrzejewski-Szmekf8eeeaf2015-01-17 23:27:39 -05002313 if (r < 0)
2314 return r;
2315 break;
2316
Lennart Poettering88ec4df2015-04-08 22:35:52 +02002317 case SET_ATTRIBUTE:
2318 case RECURSIVE_SET_ATTRIBUTE:
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01002319 if (!i.argument) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002320 *invalid_config = true;
Lennart Poettering88ec4df2015-04-08 22:35:52 +02002321 log_error("[%s:%u] Set file attribute requires argument.", fname, line);
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01002322 return -EBADMSG;
2323 }
Lennart Poetteringbd550f72015-04-10 16:03:24 +02002324 r = parse_attribute_from_arg(&i);
Zbigniew Jędrzejewski-Szmek751223f2017-11-24 12:19:40 +01002325 if (IN_SET(r, -EINVAL, -EBADSLT))
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002326 *invalid_config = true;
Goffredo Baroncelli22c3a6c2015-03-16 20:33:50 +01002327 if (r < 0)
2328 return r;
2329 break;
2330
Michal Schmidt777b87e2011-12-16 18:27:35 +01002331 default:
Zbigniew Jędrzejewski-Szmek582deb82015-01-24 01:54:05 -05002332 log_error("[%s:%u] Unknown command type '%c'.", fname, line, (char) i.type);
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002333 *invalid_config = true;
Zbigniew Jędrzejewski-Szmek7f2c1f42013-03-31 16:29:46 -04002334 return -EBADMSG;
Lennart Poettering5008d582010-09-28 02:34:02 +02002335 }
Lennart Poettering468d7262012-01-17 15:04:12 +01002336
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002337 if (!path_is_absolute(i.path)) {
2338 log_error("[%s:%u] Path '%s' not absolute.", fname, line, i.path);
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002339 *invalid_config = true;
Zbigniew Jędrzejewski-Szmek7f2c1f42013-03-31 16:29:46 -04002340 return -EBADMSG;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002341 }
2342
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002343 path_kill_slashes(i.path);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002344
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002345 if (!should_include_path(i.path))
Zbigniew Jędrzejewski-Szmek7f2c1f42013-03-31 16:29:46 -04002346 return 0;
Lennart Poettering5008d582010-09-28 02:34:02 +02002347
Franck Bui4cef1922017-11-16 11:27:29 +01002348 r = specifier_expansion_from_arg(&i);
Zbigniew Jędrzejewski-Szmek5a8575e2017-11-23 13:56:32 +01002349 if (r == -ENXIO)
Franck Bui4cef1922017-11-16 11:27:29 +01002350 return log_unresolvable_specifier(fname, line);
Zbigniew Jędrzejewski-Szmek751223f2017-11-24 12:19:40 +01002351 if (r < 0) {
2352 if (IN_SET(r, -EINVAL, -EBADSLT))
2353 *invalid_config = true;
Franck Bui4cef1922017-11-16 11:27:29 +01002354 return log_error_errno(r, "[%s:%u] Failed to substitute specifiers in argument: %m",
2355 fname, line);
Zbigniew Jędrzejewski-Szmek751223f2017-11-24 12:19:40 +01002356 }
Franck Bui4cef1922017-11-16 11:27:29 +01002357
Michael Marineaucf9a4ab2014-03-13 21:32:13 -07002358 if (arg_root) {
Lennart Poetteringcde684a2014-06-10 22:50:46 +02002359 char *p;
2360
Lennart Poettering1d13f642015-05-13 17:42:10 +02002361 p = prefix_root(arg_root, i.path);
Michael Marineaucf9a4ab2014-03-13 21:32:13 -07002362 if (!p)
2363 return log_oom();
2364
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002365 free(i.path);
2366 i.path = p;
Michael Marineaucf9a4ab2014-03-13 21:32:13 -07002367 }
2368
Lennart Poettering90937fe2015-04-10 16:04:16 +02002369 if (!isempty(user) && !streq(user, "-")) {
Lennart Poettering4b678342011-07-23 01:17:59 +02002370 const char *u = user;
Lennart Poettering5008d582010-09-28 02:34:02 +02002371
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002372 r = get_user_creds(&u, &i.uid, NULL, NULL, NULL);
Lennart Poettering4b678342011-07-23 01:17:59 +02002373 if (r < 0) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002374 *invalid_config = true;
2375 return log_error_errno(r, "[%s:%u] Unknown user '%s'.", fname, line, user);
Lennart Poettering5008d582010-09-28 02:34:02 +02002376 }
2377
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002378 i.uid_set = true;
Lennart Poettering5008d582010-09-28 02:34:02 +02002379 }
2380
Lennart Poettering90937fe2015-04-10 16:04:16 +02002381 if (!isempty(group) && !streq(group, "-")) {
Lennart Poettering4b678342011-07-23 01:17:59 +02002382 const char *g = group;
Lennart Poettering5008d582010-09-28 02:34:02 +02002383
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002384 r = get_group_creds(&g, &i.gid);
Lennart Poettering4b678342011-07-23 01:17:59 +02002385 if (r < 0) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002386 *invalid_config = true;
Lennart Poettering5008d582010-09-28 02:34:02 +02002387 log_error("[%s:%u] Unknown group '%s'.", fname, line, group);
Zbigniew Jędrzejewski-Szmek7f2c1f42013-03-31 16:29:46 -04002388 return r;
Lennart Poettering5008d582010-09-28 02:34:02 +02002389 }
2390
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002391 i.gid_set = true;
Lennart Poettering5008d582010-09-28 02:34:02 +02002392 }
2393
Lennart Poettering90937fe2015-04-10 16:04:16 +02002394 if (!isempty(mode) && !streq(mode, "-")) {
Lennart Poetteringabef3f92014-06-11 10:14:07 +02002395 const char *mm = mode;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002396 unsigned m;
Lennart Poettering5008d582010-09-28 02:34:02 +02002397
Lennart Poetteringabef3f92014-06-11 10:14:07 +02002398 if (*mm == '~') {
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002399 i.mask_perms = true;
Lennart Poetteringabef3f92014-06-11 10:14:07 +02002400 mm++;
2401 }
2402
Lennart Poettering2ff7b0a2015-04-10 14:43:06 +02002403 if (parse_mode(mm, &m) < 0) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002404 *invalid_config = true;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002405 log_error("[%s:%u] Invalid mode '%s'.", fname, line, mode);
Lennart Poettering2ff7b0a2015-04-10 14:43:06 +02002406 return -EBADMSG;
Lennart Poettering5008d582010-09-28 02:34:02 +02002407 }
2408
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002409 i.mode = m;
2410 i.mode_set = true;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002411 } else
Lennart Poettering5fb13eb2015-10-21 19:46:23 +02002412 i.mode = IN_SET(i.type, CREATE_DIRECTORY, TRUNCATE_DIRECTORY, CREATE_SUBVOLUME, CREATE_SUBVOLUME_INHERIT_QUOTA, CREATE_SUBVOLUME_NEW_QUOTA) ? 0755 : 0644;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002413
Lennart Poettering90937fe2015-04-10 16:04:16 +02002414 if (!isempty(age) && !streq(age, "-")) {
Lennart Poettering24f3a372012-06-20 09:05:50 +02002415 const char *a = age;
2416
2417 if (*a == '~') {
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002418 i.keep_first_level = true;
Lennart Poettering24f3a372012-06-20 09:05:50 +02002419 a++;
2420 }
2421
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002422 if (parse_sec(a, &i.age) < 0) {
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002423 *invalid_config = true;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002424 log_error("[%s:%u] Invalid age '%s'.", fname, line, age);
Zbigniew Jędrzejewski-Szmek7f2c1f42013-03-31 16:29:46 -04002425 return -EBADMSG;
Lennart Poettering5008d582010-09-28 02:34:02 +02002426 }
2427
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002428 i.age_set = true;
Lennart Poettering5008d582010-09-28 02:34:02 +02002429 }
2430
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002431 h = needs_glob(i.type) ? globs : items;
Lennart Poettering022707d2011-01-05 16:11:15 +01002432
Lennart Poetteringef43a392015-04-22 18:18:56 +02002433 existing = ordered_hashmap_get(h, i.path);
Lennart Poettering468d7262012-01-17 15:04:12 +01002434 if (existing) {
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002435 unsigned n;
2436
2437 for (n = 0; n < existing->count; n++) {
Martin Pitt6487ada2015-03-05 14:58:56 +01002438 if (!item_compatible(existing->items + n, &i)) {
Zbigniew Jędrzejewski-Szmeke286dba2017-11-22 14:19:13 +01002439 log_notice("[%s:%u] Duplicate line for path \"%s\", ignoring.",
2440 fname, line, i.path);
Martin Pitt6487ada2015-03-05 14:58:56 +01002441 return 0;
2442 }
Maciej Wereskiebf4e802014-12-04 10:32:10 +01002443 }
2444 } else {
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002445 existing = new0(ItemArray, 1);
Lennart Poettering07982ed2018-01-22 15:32:57 +01002446 if (!existing)
2447 return log_oom();
2448
Lennart Poetteringef43a392015-04-22 18:18:56 +02002449 r = ordered_hashmap_put(h, i.path, existing);
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002450 if (r < 0)
2451 return log_oom();
Lennart Poetteringbfe95f32011-04-08 04:49:43 +02002452 }
2453
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002454 if (!GREEDY_REALLOC(existing->items, existing->size, existing->count + 1))
2455 return log_oom();
Lennart Poettering5008d582010-09-28 02:34:02 +02002456
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002457 memcpy(existing->items + existing->count++, &i, sizeof(i));
Zbigniew Jędrzejewski-Szmekdd449ac2015-04-10 18:57:05 -04002458
2459 /* Sort item array, to enforce stable ordering of application */
2460 qsort_safe(existing->items, existing->count, sizeof(Item), item_compare);
Lennart Poettering17493fa2015-04-10 16:22:22 +02002461
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002462 zero(i);
Zbigniew Jędrzejewski-Szmek7f2c1f42013-03-31 16:29:46 -04002463 return 0;
Lennart Poettering5008d582010-09-28 02:34:02 +02002464}
2465
Zbigniew Jędrzejewski-Szmek601185b2014-08-02 11:12:21 -04002466static void help(void) {
Lennart Poettering522d4a42011-02-13 15:08:15 +01002467 printf("%s [OPTIONS...] [CONFIGURATION FILE...]\n\n"
2468 "Creates, deletes and cleans up volatile and temporary files and directories.\n\n"
Dave Reisner5c795112013-07-24 11:19:24 -04002469 " -h --help Show this help\n"
Zbigniew Jędrzejewski-Szmekf2b5ca02017-11-23 11:20:29 +01002470 " --user Execute user configuration\n"
Lennart Poetteringeb9da372013-11-06 18:28:39 +01002471 " --version Show package version\n"
Dave Reisner5c795112013-07-24 11:19:24 -04002472 " --create Create marked files/directories\n"
2473 " --clean Clean up marked directories\n"
2474 " --remove Remove marked files/directories\n"
Zbigniew Jędrzejewski-Szmek81815652013-12-30 13:00:38 -05002475 " --boot Execute actions only safe at boot\n"
Zbigniew Jędrzejewski-Szmek79ca8882015-01-27 21:22:08 -05002476 " --prefix=PATH Only apply rules with the specified prefix\n"
2477 " --exclude-prefix=PATH Ignore rules with the specified prefix\n"
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002478 " --root=PATH Operate on an alternate filesystem root\n"
Zbigniew Jędrzejewski-Szmeka6d84742018-02-05 14:53:11 +01002479 " --replace=PATH Treat arguments as replacement for PATH\n"
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002480 , program_invocation_short_name);
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002481}
2482
2483static int parse_argv(int argc, char *argv[]) {
2484
2485 enum {
Lennart Poetteringeb9da372013-11-06 18:28:39 +01002486 ARG_VERSION = 0x100,
Zbigniew Jędrzejewski-Szmekf2b5ca02017-11-23 11:20:29 +01002487 ARG_USER,
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002488 ARG_CREATE,
2489 ARG_CLEAN,
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002490 ARG_REMOVE,
Zbigniew Jędrzejewski-Szmek81815652013-12-30 13:00:38 -05002491 ARG_BOOT,
Dave Reisner5c795112013-07-24 11:19:24 -04002492 ARG_PREFIX,
2493 ARG_EXCLUDE_PREFIX,
Michael Marineaucf9a4ab2014-03-13 21:32:13 -07002494 ARG_ROOT,
Zbigniew Jędrzejewski-Szmeka6d84742018-02-05 14:53:11 +01002495 ARG_REPLACE,
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002496 };
2497
2498 static const struct option options[] = {
Dave Reisner5c795112013-07-24 11:19:24 -04002499 { "help", no_argument, NULL, 'h' },
Zbigniew Jędrzejewski-Szmekf2b5ca02017-11-23 11:20:29 +01002500 { "user", no_argument, NULL, ARG_USER },
Lennart Poetteringeb9da372013-11-06 18:28:39 +01002501 { "version", no_argument, NULL, ARG_VERSION },
Dave Reisner5c795112013-07-24 11:19:24 -04002502 { "create", no_argument, NULL, ARG_CREATE },
2503 { "clean", no_argument, NULL, ARG_CLEAN },
2504 { "remove", no_argument, NULL, ARG_REMOVE },
Zbigniew Jędrzejewski-Szmek81815652013-12-30 13:00:38 -05002505 { "boot", no_argument, NULL, ARG_BOOT },
Dave Reisner5c795112013-07-24 11:19:24 -04002506 { "prefix", required_argument, NULL, ARG_PREFIX },
2507 { "exclude-prefix", required_argument, NULL, ARG_EXCLUDE_PREFIX },
Michael Marineaucf9a4ab2014-03-13 21:32:13 -07002508 { "root", required_argument, NULL, ARG_ROOT },
Zbigniew Jędrzejewski-Szmeka6d84742018-02-05 14:53:11 +01002509 { "replace", required_argument, NULL, ARG_REPLACE },
Lennart Poetteringeb9da372013-11-06 18:28:39 +01002510 {}
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002511 };
2512
Lennart Poettering0f474362015-10-22 19:28:31 +02002513 int c, r;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002514
2515 assert(argc >= 0);
2516 assert(argv);
2517
Zbigniew Jędrzejewski-Szmek601185b2014-08-02 11:12:21 -04002518 while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002519
2520 switch (c) {
2521
2522 case 'h':
Zbigniew Jędrzejewski-Szmek601185b2014-08-02 11:12:21 -04002523 help();
2524 return 0;
Lennart Poetteringeb9da372013-11-06 18:28:39 +01002525
2526 case ARG_VERSION:
Lennart Poettering3f6fd1b2015-09-23 03:01:06 +02002527 return version();
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002528
Zbigniew Jędrzejewski-Szmekf2b5ca02017-11-23 11:20:29 +01002529 case ARG_USER:
2530 arg_user = true;
2531 break;
2532
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002533 case ARG_CREATE:
2534 arg_create = true;
2535 break;
2536
2537 case ARG_CLEAN:
2538 arg_clean = true;
2539 break;
2540
2541 case ARG_REMOVE:
2542 arg_remove = true;
2543 break;
2544
Zbigniew Jędrzejewski-Szmek81815652013-12-30 13:00:38 -05002545 case ARG_BOOT:
2546 arg_boot = true;
Zbigniew Jędrzejewski-Szmekc4708f12013-12-20 20:25:39 -05002547 break;
2548
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002549 case ARG_PREFIX:
Lennart Poettering7bc040f2014-06-11 01:26:28 +02002550 if (strv_push(&arg_include_prefixes, optarg) < 0)
Dave Reisnera2aced42013-07-24 11:10:05 -04002551 return log_oom();
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002552 break;
2553
Dave Reisner5c795112013-07-24 11:19:24 -04002554 case ARG_EXCLUDE_PREFIX:
Lennart Poettering7bc040f2014-06-11 01:26:28 +02002555 if (strv_push(&arg_exclude_prefixes, optarg) < 0)
Dave Reisner5c795112013-07-24 11:19:24 -04002556 return log_oom();
2557 break;
2558
Michael Marineaucf9a4ab2014-03-13 21:32:13 -07002559 case ARG_ROOT:
Lennart Poettering0f03c2a2015-10-22 19:54:29 +02002560 r = parse_path_argument_and_warn(optarg, true, &arg_root);
Lennart Poettering0f474362015-10-22 19:28:31 +02002561 if (r < 0)
Lennart Poettering0f03c2a2015-10-22 19:54:29 +02002562 return r;
Michael Marineaucf9a4ab2014-03-13 21:32:13 -07002563 break;
2564
Zbigniew Jędrzejewski-Szmeka6d84742018-02-05 14:53:11 +01002565 case ARG_REPLACE:
2566 if (!path_is_absolute(optarg) ||
2567 !endswith(optarg, ".conf")) {
2568 log_error("The argument to --replace= must an absolute path to a config file");
2569 return -EINVAL;
2570 }
2571
2572 arg_replace = optarg;
2573 break;
2574
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002575 case '?':
2576 return -EINVAL;
2577
2578 default:
Lennart Poetteringeb9da372013-11-06 18:28:39 +01002579 assert_not_reached("Unhandled option");
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002580 }
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002581
2582 if (!arg_clean && !arg_create && !arg_remove) {
Harald Hoyer35b8ca32011-02-21 15:32:17 +01002583 log_error("You need to specify at least one of --clean, --create or --remove.");
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002584 return -EINVAL;
2585 }
2586
Zbigniew Jędrzejewski-Szmeka6d84742018-02-05 14:53:11 +01002587 if (arg_replace && optind >= argc) {
2588 log_error("When --replace= is given, some configuration items must be specified");
2589 return -EINVAL;
2590 }
2591
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002592 return 1;
2593}
2594
Zbigniew Jędrzejewski-Szmeka6d84742018-02-05 14:53:11 +01002595static int read_config_file(char **config_dirs, const char *fn, bool ignore_enoent, bool *invalid_config) {
Zbigniew Jędrzejewski-Szmekf7ac1ed2016-04-19 22:34:04 -04002596 _cleanup_fclose_ FILE *_f = NULL;
2597 FILE *f;
Lennart Poettering1731e342013-09-17 11:02:02 -05002598 char line[LINE_MAX];
Michal Sekletar78a92a52013-01-18 16:13:08 +01002599 Iterator iterator;
Lennart Poettering1731e342013-09-17 11:02:02 -05002600 unsigned v = 0;
Michal Sekletar78a92a52013-01-18 16:13:08 +01002601 Item *i;
Lennart Poettering4e68ec12016-06-21 13:20:23 +02002602 int r = 0;
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002603
2604 assert(fn);
2605
Zbigniew Jędrzejewski-Szmekf7ac1ed2016-04-19 22:34:04 -04002606 if (streq(fn, "-")) {
Zbigniew Jędrzejewski-Szmeka6d84742018-02-05 14:53:11 +01002607 log_debug("Reading config from stdin…");
Zbigniew Jędrzejewski-Szmekf7ac1ed2016-04-19 22:34:04 -04002608 fn = "<stdin>";
2609 f = stdin;
2610 } else {
Zbigniew Jędrzejewski-Szmeka6d84742018-02-05 14:53:11 +01002611 r = search_and_fopen(fn, "re", arg_root, (const char**) config_dirs, &_f);
Zbigniew Jędrzejewski-Szmekf7ac1ed2016-04-19 22:34:04 -04002612 if (r < 0) {
2613 if (ignore_enoent && r == -ENOENT) {
2614 log_debug_errno(r, "Failed to open \"%s\", ignoring: %m", fn);
2615 return 0;
2616 }
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002617
Zbigniew Jędrzejewski-Szmekf7ac1ed2016-04-19 22:34:04 -04002618 return log_error_errno(r, "Failed to open '%s': %m", fn);
2619 }
Zbigniew Jędrzejewski-Szmeka6d84742018-02-05 14:53:11 +01002620 log_debug("Reading config file \"%s\"…", fn);
Zbigniew Jędrzejewski-Szmekf7ac1ed2016-04-19 22:34:04 -04002621 f = _f;
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002622 }
2623
Lennart Poettering1731e342013-09-17 11:02:02 -05002624 FOREACH_LINE(line, f, break) {
2625 char *l;
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002626 int k;
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002627 bool invalid_line = false;
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002628
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002629 v++;
2630
2631 l = strstrip(line);
Yu Watanabe4c701092017-10-04 23:01:32 +09002632 if (IN_SET(*l, 0, '#'))
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002633 continue;
2634
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002635 k = parse_line(fn, v, l, &invalid_line);
2636 if (k < 0) {
2637 if (invalid_line)
2638 /* Allow reporting with a special code if the caller requested this */
2639 *invalid_config = true;
2640 else if (r == 0)
2641 /* The first error becomes our return value */
2642 r = k;
2643 }
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002644 }
2645
Michal Sekletar78a92a52013-01-18 16:13:08 +01002646 /* we have to determine age parameter for each entry of type X */
Lennart Poetteringef43a392015-04-22 18:18:56 +02002647 ORDERED_HASHMAP_FOREACH(i, globs, iterator) {
Michal Sekletar78a92a52013-01-18 16:13:08 +01002648 Iterator iter;
2649 Item *j, *candidate_item = NULL;
2650
2651 if (i->type != IGNORE_DIRECTORY_PATH)
2652 continue;
2653
Lennart Poetteringef43a392015-04-22 18:18:56 +02002654 ORDERED_HASHMAP_FOREACH(j, items, iter) {
Lennart Poettering5fb13eb2015-10-21 19:46:23 +02002655 if (!IN_SET(j->type, CREATE_DIRECTORY, TRUNCATE_DIRECTORY, CREATE_SUBVOLUME, CREATE_SUBVOLUME_INHERIT_QUOTA, CREATE_SUBVOLUME_NEW_QUOTA))
Michal Sekletar78a92a52013-01-18 16:13:08 +01002656 continue;
2657
2658 if (path_equal(j->path, i->path)) {
2659 candidate_item = j;
2660 break;
2661 }
2662
2663 if ((!candidate_item && path_startswith(i->path, j->path)) ||
2664 (candidate_item && path_startswith(j->path, candidate_item->path) && (fnmatch(i->path, j->path, FNM_PATHNAME | FNM_PERIOD) == 0)))
2665 candidate_item = j;
2666 }
2667
Richard Weinberger9ed2a352014-09-09 11:09:37 +02002668 if (candidate_item && candidate_item->age_set) {
Michal Sekletar78a92a52013-01-18 16:13:08 +01002669 i->age = candidate_item->age;
2670 i->age_set = true;
2671 }
2672 }
2673
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002674 if (ferror(f)) {
Michal Schmidt56f64d92014-11-28 19:29:59 +01002675 log_error_errno(errno, "Failed to read from file %s: %m", fn);
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002676 if (r == 0)
2677 r = -EIO;
2678 }
2679
Lennart Poetteringfba6e682011-02-13 14:00:54 +01002680 return r;
2681}
2682
Zbigniew Jędrzejewski-Szmeka6d84742018-02-05 14:53:11 +01002683static int parse_arguments(char **config_dirs, char **args, bool *invalid_config) {
2684 char **arg;
2685 int r;
2686
2687 STRV_FOREACH(arg, args) {
2688 r = read_config_file(config_dirs, *arg, false, invalid_config);
2689 if (r < 0)
2690 return r;
2691 }
2692
2693 return 0;
2694}
2695
2696static int read_config_files(char **config_dirs, char **args, bool *invalid_config) {
2697 _cleanup_strv_free_ char **files = NULL;
2698 _cleanup_free_ char *p = NULL;
2699 char **f;
2700 int r;
2701
2702 r = conf_files_list_strv(&files, ".conf", arg_root, 0, (const char* const*) config_dirs);
2703 if (r < 0)
2704 return log_error_errno(r, "Failed to enumerate tmpfiles.d files: %m");
2705
2706 if (arg_replace) {
2707 r = conf_files_insert(&files, arg_root, config_dirs, arg_replace);
2708 if (r < 0)
2709 return log_error_errno(r, "Failed to extend tmpfiles.d file list: %m");
2710
2711 p = path_join(arg_root, arg_replace, NULL);
2712 if (!p)
2713 return log_oom();
2714 }
2715
2716 STRV_FOREACH(f, files)
2717 if (p && path_equal(*f, p)) {
2718 log_debug("Parsing arguments at position \"%s\"…", *f);
2719
2720 r = parse_arguments(config_dirs, args, invalid_config);
2721 if (r < 0)
2722 return r;
2723 } else
2724 /* Just warn, ignore result otherwise.
2725 * read_config_file() has some debug output, so no need to print anything. */
2726 (void) read_config_file(config_dirs, *f, true, invalid_config);
2727
2728 return 0;
2729}
2730
Lennart Poettering5008d582010-09-28 02:34:02 +02002731int main(int argc, char *argv[]) {
Lennart Poetteringfabe5c02013-02-11 23:48:36 +01002732 int r, k;
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002733 ItemArray *a;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002734 Iterator iterator;
Zbigniew Jędrzejewski-Szmekf2b5ca02017-11-23 11:20:29 +01002735 _cleanup_strv_free_ char **config_dirs = NULL;
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002736 bool invalid_config = false;
Lennart Poettering5008d582010-09-28 02:34:02 +02002737
Lennart Poetteringfdcad0c2012-01-11 22:07:35 +01002738 r = parse_argv(argc, argv);
2739 if (r <= 0)
Lennart Poettering753615e2014-06-12 23:07:17 +02002740 goto finish;
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002741
Lennart Poetteringeb0ca9e2011-02-12 09:31:38 +01002742 log_set_target(LOG_TARGET_AUTO);
Lennart Poettering5008d582010-09-28 02:34:02 +02002743 log_parse_environment();
2744 log_open();
2745
Lennart Poettering4c126262011-08-01 20:52:18 +02002746 umask(0022);
2747
Zbigniew Jędrzejewski-Szmekc3dacc82016-03-01 20:35:55 -05002748 mac_selinux_init();
Lennart Poettering5008d582010-09-28 02:34:02 +02002749
Lennart Poetteringef43a392015-04-22 18:18:56 +02002750 items = ordered_hashmap_new(&string_hash_ops);
2751 globs = ordered_hashmap_new(&string_hash_ops);
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +01002752
2753 if (!items || !globs) {
Lennart Poetteringfabe5c02013-02-11 23:48:36 +01002754 r = log_oom();
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002755 goto finish;
2756 }
2757
Lennart Poetteringfabe5c02013-02-11 23:48:36 +01002758 r = 0;
Lennart Poettering5008d582010-09-28 02:34:02 +02002759
Zbigniew Jędrzejewski-Szmekf2b5ca02017-11-23 11:20:29 +01002760 if (arg_user) {
2761 r = user_config_paths(&config_dirs);
2762 if (r < 0) {
2763 log_error_errno(r, "Failed to initialize configuration directory list: %m");
2764 goto finish;
2765 }
2766 } else {
2767 config_dirs = strv_split_nulstr(CONF_PATHS_NULSTR("tmpfiles.d"));
2768 if (!config_dirs) {
2769 r = log_oom();
2770 goto finish;
2771 }
2772 }
2773
Lennart Poettering79c91ce2018-01-22 15:33:13 +01002774 if (DEBUG_LOGGING) {
Zbigniew Jędrzejewski-Szmekf2b5ca02017-11-23 11:20:29 +01002775 _cleanup_free_ char *t = NULL;
2776
2777 t = strv_join(config_dirs, "\n\t");
2778 if (t)
2779 log_debug("Looking for configuration files in (higher priority first:\n\t%s", t);
2780 }
2781
Zbigniew Jędrzejewski-Szmeka6d84742018-02-05 14:53:11 +01002782 /* If command line arguments are specified along with --replace, read all
2783 * configuration files and insert the positional arguments at the specified
2784 * place. Otherwise, if command line arguments are specified, execute just
2785 * them, and finally, without --replace= or any positional arguments, just
2786 * read configuration and execute it.
2787 */
2788 if (arg_replace || optind >= argc)
2789 r = read_config_files(config_dirs, argv + optind, &invalid_config);
2790 else
2791 r = parse_arguments(config_dirs, argv + optind, &invalid_config);
2792 if (r < 0)
2793 goto finish;
Lennart Poettering5008d582010-09-28 02:34:02 +02002794
Lennart Poettering5008d582010-09-28 02:34:02 +02002795
Lennart Poettering5008d582010-09-28 02:34:02 +02002796
Lennart Poettering17493fa2015-04-10 16:22:22 +02002797 /* The non-globbing ones usually create things, hence we apply
2798 * them first */
Lennart Poetteringef43a392015-04-22 18:18:56 +02002799 ORDERED_HASHMAP_FOREACH(a, items, iterator) {
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002800 k = process_item_array(a);
Zbigniew Jędrzejewski-Szmek1db50422015-01-06 09:53:12 -05002801 if (k < 0 && r == 0)
2802 r = k;
2803 }
Lennart Poetteringb8bb3e82011-02-12 09:31:25 +01002804
Lennart Poettering17493fa2015-04-10 16:22:22 +02002805 /* The globbing ones usually alter things, hence we apply them
2806 * second. */
Lennart Poetteringef43a392015-04-22 18:18:56 +02002807 ORDERED_HASHMAP_FOREACH(a, globs, iterator) {
Zbigniew Jędrzejewski-Szmek3f93da92015-01-09 02:00:37 -05002808 k = process_item_array(a);
Zbigniew Jędrzejewski-Szmek1db50422015-01-06 09:53:12 -05002809 if (k < 0 && r == 0)
2810 r = k;
2811 }
Lennart Poettering3b63d2d2010-10-18 22:38:41 +02002812
Lennart Poettering5008d582010-09-28 02:34:02 +02002813finish:
Zbigniew Jędrzejewski-Szmek224b0e72017-11-28 12:35:49 +01002814 ordered_hashmap_free_with_destructor(items, item_array_free);
2815 ordered_hashmap_free_with_destructor(globs, item_array_free);
Lennart Poettering5008d582010-09-28 02:34:02 +02002816
Lennart Poettering7bc040f2014-06-11 01:26:28 +02002817 free(arg_include_prefixes);
2818 free(arg_exclude_prefixes);
Michael Marineaucf9a4ab2014-03-13 21:32:13 -07002819 free(arg_root);
Dave Reisnera2aced42013-07-24 11:10:05 -04002820
Lennart Poettering17b90522011-02-14 21:55:06 +01002821 set_free_free(unix_sockets);
2822
WaLyong Chocc56faf2014-10-23 17:23:46 +09002823 mac_selinux_finish();
Lennart Poettering29003cf2010-10-19 19:36:45 +02002824
Zbigniew Jędrzejewski-Szmekd9daae52017-11-22 14:13:32 +01002825 if (r < 0)
2826 return EXIT_FAILURE;
2827 else if (invalid_config)
2828 return EX_DATAERR;
2829 else
2830 return EXIT_SUCCESS;
Lennart Poettering5008d582010-09-28 02:34:02 +02002831}