src/basic/os-util.c

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