src/basic/os-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include "alloc-util.h"
   4 #include "dirent-util.h"
   5 #include "env-file.h"
   6 #include "env-util.h"
   7 #include "fd-util.h"
   8 #include "fileio.h"
   9 #include "fs-util.h"
  10 #include "macro.h"
  11 #include "os-util.h"
  12 #include "parse-util.h"
  13 #include "path-util.h"
  14 #include "stat-util.h"
  15 #include "string-util.h"
  16 #include "strv.h"
  17 #include "utf8.h"
  18 #include "xattr-util.h"
  19
  20 bool image_name_is_valid(const char *s) {
  21         if (!filename_is_valid(s))
  22                 return false;
  23
  24         if (string_has_cc(s, NULL))
  25                 return false;
  26
  27         if (!utf8_is_valid(s))
  28                 return false;
  29
  30         /* Temporary files for atomically creating new files */
  31         if (startswith(s, ".#"))
  32                 return false;
  33
  34         return true;
  35 }
  36
  37 int path_is_extension_tree(const char *path, const char *extension) {
  38         int r;
  39
  40         assert(path);
  41
  42         /* Does the path exist at all? If not, generate an error immediately. This is useful so that a missing root dir
  43          * always results in -ENOENT, and we can properly distinguish the case where the whole root doesn't exist from
  44          * the case where just the os-release file is missing. */
  45         if (laccess(path, F_OK) < 0)
  46                 return -errno;
  47
  48         /* We use /usr/lib/extension-release.d/extension-release[.NAME] as flag for something being a system extension,
  49          * and {/etc|/usr/lib}/os-release as a flag for something being an OS (when not an extension). */
  50         r = open_extension_release(path, extension, NULL, NULL);
  51         if (r == -ENOENT) /* We got nothing */
  52                 return 0;
  53         if (r < 0)
  54                 return r;
  55
  56         return 1;
  57 }
  58
  59 int open_extension_release(const char *root, const char *extension, char **ret_path, int *ret_fd) {
  60         _cleanup_free_ char *q = NULL;
  61         int r, fd;
  62
  63         if (extension) {
  64                 const char *extension_full_path;
  65
  66                 if (!image_name_is_valid(extension))
  67                         return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
  68                                                "The extension name %s is invalid.", extension);
  69
  70                 extension_full_path = strjoina("/usr/lib/extension-release.d/extension-release.", extension);
  71                 r = chase_symlinks(extension_full_path, root, CHASE_PREFIX_ROOT,
  72                                    ret_path ? &q : NULL,
  73                                    ret_fd ? &fd : NULL);
  74                 /* Cannot find the expected extension-release file? The image filename might have been
  75                  * mangled on deployment, so fallback to checking for any file in the extension-release.d
  76                  * directory, and return the first one with a user.extension-release xattr instead.
  77                  * The user.extension-release.strict xattr is checked to ensure the author of the image
  78                  * considers it OK if names do not match. */
  79                 if (r == -ENOENT) {
  80                         _cleanup_free_ char *extension_release_dir_path = NULL;
  81                         _cleanup_closedir_ DIR *extension_release_dir = NULL;
  82
  83                         r = chase_symlinks_and_opendir("/usr/lib/extension-release.d/", root, CHASE_PREFIX_ROOT,
  84                                                        &extension_release_dir_path, &extension_release_dir);
  85                         if (r < 0)
  86                                 return r;
  87
  88                         r = -ENOENT;
  89                         struct dirent *de;
  90                         FOREACH_DIRENT(de, extension_release_dir, return -errno) {
  91                                 int k;
  92
  93                                 if (!IN_SET(de->d_type, DT_REG, DT_UNKNOWN))
  94                                         continue;
  95
  96                                 const char *image_name = startswith(de->d_name, "extension-release.");
  97                                 if (!image_name)
  98                                         continue;
  99
 100                                 if (!image_name_is_valid(image_name))
 101                                         continue;
 102
 103                                 /* We already chased the directory, and checked that
 104                                  * this is a real file, so we shouldn't fail to open it. */
 105                                 _cleanup_close_ int extension_release_fd = openat(dirfd(extension_release_dir),
 106                                                                                   de->d_name,
 107                                                                                   O_PATH|O_CLOEXEC|O_NOFOLLOW);
 108                                 if (extension_release_fd < 0)
 109                                         return log_debug_errno(errno,
 110                                                                "Failed to open extension-release file %s/%s: %m",
 111                                                                extension_release_dir_path,
 112                                                                de->d_name);
 113
 114                                 /* Really ensure it is a regular file after we open it. */
 115                                 if (fd_verify_regular(extension_release_fd) < 0)
 116                                         continue;
 117
 118                                 /* No xattr or cannot parse it? Then skip this. */
 119                                 _cleanup_free_ char *extension_release_xattr = NULL;
 120                                 k = fgetxattrat_fake_malloc(extension_release_fd, NULL, "user.extension-release.strict", AT_EMPTY_PATH, &extension_release_xattr);
 121                                 if (k < 0 && !ERRNO_IS_NOT_SUPPORTED(k) && k != -ENODATA)
 122                                         log_debug_errno(k,
 123                                                         "Failed to read 'user.extension-release.strict' extended attribute from extension-release file %s/%s: %m",
 124                                                         extension_release_dir_path,
 125                                                         de->d_name);
 126                                 if (k < 0)
 127                                         continue;
 128
 129                                 /* Explicitly set to request strict matching? Skip it. */
 130                                 k = parse_boolean(extension_release_xattr);
 131                                 if (k < 0)
 132                                         log_debug_errno(k,
 133                                                         "Failed to parse 'user.extension-release.strict' extended attribute value from extension-release file %s/%s: %m",
 134                                                         extension_release_dir_path,
 135                                                         de->d_name);
 136                                 if (k < 0 || k > 0)
 137                                         continue;
 138
 139                                 /* We already found what we were looking for, but there's another candidate?
 140                                  * We treat this as an error, as we want to enforce that there are no ambiguities
 141                                  * in case we are in the fallback path.*/
 142                                 if (r == 0) {
 143                                         r = -ENOTUNIQ;
 144                                         break;
 145                                 }
 146
 147                                 r = 0; /* Found it! */
 148
 149                                 if (ret_fd)
 150                                         fd = TAKE_FD(extension_release_fd);
 151
 152                                 if (ret_path) {
 153                                         q = path_join(extension_release_dir_path, de->d_name);
 154                                         if (!q)
 155                                                 return -ENOMEM;
 156                                 }
 157                         }
 158                 }
 159         } else {
 160                 const char *p;
 161
 162                 FOREACH_STRING(p, "/etc/os-release", "/usr/lib/os-release") {
 163                         r = chase_symlinks(p, root, CHASE_PREFIX_ROOT,
 164                                            ret_path ? &q : NULL,
 165                                            ret_fd ? &fd : NULL);
 166                         if (r != -ENOENT)
 167                                 break;
 168                 }
 169         }
 170         if (r < 0)
 171                 return r;
 172
 173         if (ret_fd) {
 174                 int real_fd;
 175
 176                 /* Convert the O_PATH fd into a proper, readable one */
 177                 real_fd = fd_reopen(fd, O_RDONLY|O_CLOEXEC|O_NOCTTY);
 178                 safe_close(fd);
 179                 if (real_fd < 0)
 180                         return real_fd;
 181
 182                 *ret_fd = real_fd;
 183         }
 184
 185         if (ret_path)
 186                 *ret_path = TAKE_PTR(q);
 187
 188         return 0;
 189 }
 190
 191 int fopen_extension_release(const char *root, const char *extension, char **ret_path, FILE **ret_file) {
 192         _cleanup_free_ char *p = NULL;
 193         _cleanup_close_ int fd = -1;
 194         FILE *f;
 195         int r;
 196
 197         if (!ret_file)
 198                 return open_extension_release(root, extension, ret_path, NULL);
 199
 200         r = open_extension_release(root, extension, ret_path ? &p : NULL, &fd);
 201         if (r < 0)
 202                 return r;
 203
 204         f = take_fdopen(&fd, "r");
 205         if (!f)
 206                 return -errno;
 207
 208         if (ret_path)
 209                 *ret_path = TAKE_PTR(p);
 210         *ret_file = f;
 211
 212         return 0;
 213 }
 214
 215 static int parse_release_internal(const char *root, const char *extension, va_list ap) {
 216         _cleanup_fclose_ FILE *f = NULL;
 217         _cleanup_free_ char *p = NULL;
 218         int r;
 219
 220         r = fopen_extension_release(root, extension, &p, &f);
 221         if (r < 0)
 222                 return r;
 223
 224         return parse_env_filev(f, p, ap);
 225 }
 226
 227 int _parse_extension_release(const char *root, const char *extension, ...) {
 228         va_list ap;
 229         int r;
 230
 231         va_start(ap, extension);
 232         r = parse_release_internal(root, extension, ap);
 233         va_end(ap);
 234
 235         return r;
 236 }
 237
 238 int _parse_os_release(const char *root, ...) {
 239         va_list ap;
 240         int r;
 241
 242         va_start(ap, root);
 243         r = parse_release_internal(root, NULL, ap);
 244         va_end(ap);
 245
 246         return r;
 247 }
 248
 249 int load_os_release_pairs(const char *root, char ***ret) {
 250         _cleanup_fclose_ FILE *f = NULL;
 251         _cleanup_free_ char *p = NULL;
 252         int r;
 253
 254         r = fopen_os_release(root, &p, &f);
 255         if (r < 0)
 256                 return r;
 257
 258         return load_env_file_pairs(f, p, ret);
 259 }
 260
 261 int load_os_release_pairs_with_prefix(const char *root, const char *prefix, char ***ret) {
 262         _cleanup_strv_free_ char **os_release_pairs = NULL, **os_release_pairs_prefixed = NULL;
 263         char **p, **q;
 264         int r;
 265
 266         r = load_os_release_pairs(root, &os_release_pairs);
 267         if (r < 0)
 268                 return r;
 269
 270         STRV_FOREACH_PAIR(p, q, os_release_pairs) {
 271                 char *line;
 272
 273                 /* We strictly return only the four main ID fields and ignore the rest */
 274                 if (!STR_IN_SET(*p, "ID", "VERSION_ID", "BUILD_ID", "VARIANT_ID"))
 275                         continue;
 276
 277                 ascii_strlower(*p);
 278                 line = strjoin(prefix, *p, "=", *q);
 279                 if (!line)
 280                         return -ENOMEM;
 281                 r = strv_consume(&os_release_pairs_prefixed, line);
 282                 if (r < 0)
 283                         return r;
 284         }
 285
 286         *ret = TAKE_PTR(os_release_pairs_prefixed);
 287
 288         return 0;
 289 }
 290
 291 int load_extension_release_pairs(const char *root, const char *extension, char ***ret) {
 292         _cleanup_fclose_ FILE *f = NULL;
 293         _cleanup_free_ char *p = NULL;
 294         int r;
 295
 296         r = fopen_extension_release(root, extension, &p, &f);
 297         if (r < 0)
 298                 return r;
 299
 300         return load_env_file_pairs(f, p, ret);
 301 }