src/udev/udev-node.c

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2
   3 #include <errno.h>
   4 #include <fcntl.h>
   5 #include <stdbool.h>
   6 #include <stddef.h>
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <sys/stat.h>
  10 #include <unistd.h>
  11
  12 #include "device-nodes.h"
  13 #include "dirent-util.h"
  14 #include "format-util.h"
  15 #include "fs-util.h"
  16 #include "selinux-util.h"
  17 #include "smack-util.h"
  18 #include "stdio-util.h"
  19 #include "string-util.h"
  20 #include "udev.h"
  21
  22 static int node_symlink(struct udev_device *dev, const char *node, const char *slink) {
  23         _cleanup_free_ char *slink_dirname = NULL, *target = NULL;
  24         char slink_tmp[UTIL_PATH_SIZE + 32];
  25         struct stat stats;
  26         int r, err = 0;
  27
  28         slink_dirname = dirname_malloc(slink);
  29         if (!slink_dirname)
  30                 return log_oom();
  31
  32         /* use relative link */
  33         r = path_make_relative(slink_dirname, node, &target);
  34         if (r < 0)
  35                 return log_error_errno(r, "Failed to get relative path from '%s' to '%s': %m", slink, node);
  36
  37         /* preserve link with correct target, do not replace node of other device */
  38         if (lstat(slink, &stats) == 0) {
  39                 if (S_ISBLK(stats.st_mode) || S_ISCHR(stats.st_mode)) {
  40                         log_error("conflicting device node '%s' found, link to '%s' will not be created", slink, node);
  41                         goto exit;
  42                 } else if (S_ISLNK(stats.st_mode)) {
  43                         char buf[UTIL_PATH_SIZE];
  44                         int len;
  45
  46                         len = readlink(slink, buf, sizeof(buf));
  47                         if (len > 0 && len < (int)sizeof(buf)) {
  48                                 buf[len] = '\0';
  49                                 if (streq(target, buf)) {
  50                                         log_debug("preserve already existing symlink '%s' to '%s'", slink, target);
  51                                         (void) label_fix(slink, LABEL_IGNORE_ENOENT);
  52                                         utimensat(AT_FDCWD, slink, NULL, AT_SYMLINK_NOFOLLOW);
  53                                         goto exit;
  54                                 }
  55                         }
  56                 }
  57         } else {
  58                 log_debug("creating symlink '%s' to '%s'", slink, target);
  59                 do {
  60                         err = mkdir_parents_label(slink, 0755);
  61                         if (!IN_SET(err, 0, -ENOENT))
  62                                 break;
  63                         mac_selinux_create_file_prepare(slink, S_IFLNK);
  64                         err = symlink(target, slink);
  65                         if (err != 0)
  66                                 err = -errno;
  67                         mac_selinux_create_file_clear();
  68                 } while (err == -ENOENT);
  69                 if (err == 0)
  70                         goto exit;
  71         }
  72
  73         log_debug("atomically replace '%s'", slink);
  74         strscpyl(slink_tmp, sizeof(slink_tmp), slink, ".tmp-", udev_device_get_id_filename(dev), NULL);
  75         unlink(slink_tmp);
  76         do {
  77                 err = mkdir_parents_label(slink_tmp, 0755);
  78                 if (!IN_SET(err, 0, -ENOENT))
  79                         break;
  80                 mac_selinux_create_file_prepare(slink_tmp, S_IFLNK);
  81                 err = symlink(target, slink_tmp);
  82                 if (err != 0)
  83                         err = -errno;
  84                 mac_selinux_create_file_clear();
  85         } while (err == -ENOENT);
  86         if (err != 0) {
  87                 log_error_errno(errno, "symlink '%s' '%s' failed: %m", target, slink_tmp);
  88                 goto exit;
  89         }
  90         err = rename(slink_tmp, slink);
  91         if (err != 0) {
  92                 log_error_errno(errno, "rename '%s' '%s' failed: %m", slink_tmp, slink);
  93                 unlink(slink_tmp);
  94         }
  95 exit:
  96         return err;
  97 }
  98
  99 /* find device node of device with highest priority */
 100 static const char *link_find_prioritized(struct udev_device *dev, bool add, const char *stackdir, char *buf, size_t bufsize) {
 101         DIR *dir;
 102         struct dirent *dent;
 103         int priority = 0;
 104         const char *target = NULL;
 105
 106         if (add) {
 107                 priority = udev_device_get_devlink_priority(dev);
 108                 strscpy(buf, bufsize, udev_device_get_devnode(dev));
 109                 target = buf;
 110         }
 111
 112         dir = opendir(stackdir);
 113         if (dir == NULL)
 114                 return target;
 115         FOREACH_DIRENT_ALL(dent, dir, break) {
 116                 struct udev_device *dev_db;
 117
 118                 if (dent->d_name[0] == '\0')
 119                         break;
 120                 if (dent->d_name[0] == '.')
 121                         continue;
 122
 123                 log_debug("found '%s' claiming '%s'", dent->d_name, stackdir);
 124
 125                 /* did we find ourself? */
 126                 if (streq(dent->d_name, udev_device_get_id_filename(dev)))
 127                         continue;
 128
 129                 dev_db = udev_device_new_from_device_id(NULL, dent->d_name);
 130                 if (dev_db != NULL) {
 131                         const char *devnode;
 132
 133                         devnode = udev_device_get_devnode(dev_db);
 134                         if (devnode != NULL) {
 135                                 if (target == NULL || udev_device_get_devlink_priority(dev_db) > priority) {
 136                                         log_debug("'%s' claims priority %i for '%s'",
 137                                                   udev_device_get_syspath(dev_db), udev_device_get_devlink_priority(dev_db), stackdir);
 138                                         priority = udev_device_get_devlink_priority(dev_db);
 139                                         strscpy(buf, bufsize, devnode);
 140                                         target = buf;
 141                                 }
 142                         }
 143                         udev_device_unref(dev_db);
 144                 }
 145         }
 146         closedir(dir);
 147         return target;
 148 }
 149
 150 /* manage "stack of names" with possibly specified device priorities */
 151 static void link_update(struct udev_device *dev, const char *slink, bool add) {
 152         char name_enc[UTIL_PATH_SIZE];
 153         char filename[UTIL_PATH_SIZE * 2];
 154         char dirname[UTIL_PATH_SIZE];
 155         const char *target;
 156         char buf[UTIL_PATH_SIZE];
 157
 158         util_path_encode(slink + STRLEN("/dev"), name_enc, sizeof(name_enc));
 159         strscpyl(dirname, sizeof(dirname), "/run/udev/links/", name_enc, NULL);
 160         strscpyl(filename, sizeof(filename), dirname, "/", udev_device_get_id_filename(dev), NULL);
 161
 162         if (!add && unlink(filename) == 0)
 163                 rmdir(dirname);
 164
 165         target = link_find_prioritized(dev, add, dirname, buf, sizeof(buf));
 166         if (target == NULL) {
 167                 log_debug("no reference left, remove '%s'", slink);
 168                 if (unlink(slink) == 0)
 169                         rmdir_parents(slink, "/");
 170         } else {
 171                 log_debug("creating link '%s' to '%s'", slink, target);
 172                 node_symlink(dev, target, slink);
 173         }
 174
 175         if (add) {
 176                 int err;
 177
 178                 do {
 179                         int fd;
 180
 181                         err = mkdir_parents(filename, 0755);
 182                         if (!IN_SET(err, 0, -ENOENT))
 183                                 break;
 184                         fd = open(filename, O_WRONLY|O_CREAT|O_CLOEXEC|O_TRUNC|O_NOFOLLOW, 0444);
 185                         if (fd >= 0)
 186                                 close(fd);
 187                         else
 188                                 err = -errno;
 189                 } while (err == -ENOENT);
 190         }
 191 }
 192
 193 void udev_node_update_old_links(struct udev_device *dev, struct udev_device *dev_old) {
 194         struct udev_list_entry *list_entry;
 195
 196         /* update possible left-over symlinks */
 197         udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev_old)) {
 198                 const char *name = udev_list_entry_get_name(list_entry);
 199                 struct udev_list_entry *list_entry_current;
 200                 int found;
 201
 202                 /* check if old link name still belongs to this device */
 203                 found = 0;
 204                 udev_list_entry_foreach(list_entry_current, udev_device_get_devlinks_list_entry(dev)) {
 205                         const char *name_current = udev_list_entry_get_name(list_entry_current);
 206
 207                         if (streq(name, name_current)) {
 208                                 found = 1;
 209                                 break;
 210                         }
 211                 }
 212                 if (found)
 213                         continue;
 214
 215                 log_debug("update old name, '%s' no longer belonging to '%s'",
 216                      name, udev_device_get_devpath(dev));
 217                 link_update(dev, name, false);
 218         }
 219 }
 220
 221 static int node_permissions_apply(struct udev_device *dev, bool apply,
 222                                   mode_t mode, uid_t uid, gid_t gid,
 223                                   struct udev_list *seclabel_list) {
 224         const char *devnode = udev_device_get_devnode(dev);
 225         dev_t devnum = udev_device_get_devnum(dev);
 226         struct stat stats;
 227         struct udev_list_entry *entry;
 228         int err = 0;
 229
 230         if (streq(udev_device_get_subsystem(dev), "block"))
 231                 mode |= S_IFBLK;
 232         else
 233                 mode |= S_IFCHR;
 234
 235         if (lstat(devnode, &stats) != 0) {
 236                 err = log_debug_errno(errno, "cannot stat() node '%s' (%m)", devnode);
 237                 goto out;
 238         }
 239
 240         if (((stats.st_mode & S_IFMT) != (mode & S_IFMT)) || (stats.st_rdev != devnum)) {
 241                 err = -EEXIST;
 242                 log_debug("found node '%s' with non-matching devnum %s, skip handling",
 243                           udev_device_get_devnode(dev), udev_device_get_id_filename(dev));
 244                 goto out;
 245         }
 246
 247         if (apply) {
 248                 bool selinux = false;
 249                 bool smack = false;
 250
 251                 if ((stats.st_mode & 0777) != (mode & 0777) || stats.st_uid != uid || stats.st_gid != gid) {
 252                         log_debug("set permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);
 253                         err = chmod(devnode, mode);
 254                         if (err < 0)
 255                                 log_warning_errno(errno, "setting mode of %s to %#o failed: %m", devnode, mode);
 256                         err = chown(devnode, uid, gid);
 257                         if (err < 0)
 258                                 log_warning_errno(errno, "setting owner of %s to uid=%u, gid=%u failed: %m", devnode, uid, gid);
 259                 } else {
 260                         log_debug("preserve permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);
 261                 }
 262
 263                 /* apply SECLABEL{$module}=$label */
 264                 udev_list_entry_foreach(entry, udev_list_get_entry(seclabel_list)) {
 265                         const char *name, *label;
 266                         int r;
 267
 268                         name = udev_list_entry_get_name(entry);
 269                         label = udev_list_entry_get_value(entry);
 270
 271                         if (streq(name, "selinux")) {
 272                                 selinux = true;
 273
 274                                 r = mac_selinux_apply(devnode, label);
 275                                 if (r < 0)
 276                                         log_error_errno(r, "SECLABEL: failed to set SELinux label '%s': %m", label);
 277                                 else
 278                                         log_debug("SECLABEL: set SELinux label '%s'", label);
 279
 280                         } else if (streq(name, "smack")) {
 281                                 smack = true;
 282
 283                                 r = mac_smack_apply(devnode, SMACK_ATTR_ACCESS, label);
 284                                 if (r < 0)
 285                                         log_error_errno(r, "SECLABEL: failed to set SMACK label '%s': %m", label);
 286                                 else
 287                                         log_debug("SECLABEL: set SMACK label '%s'", label);
 288
 289                         } else
 290                                 log_error("SECLABEL: unknown subsystem, ignoring '%s'='%s'", name, label);
 291                 }
 292
 293                 /* set the defaults */
 294                 if (!selinux)
 295                         (void) mac_selinux_fix(devnode, LABEL_IGNORE_ENOENT);
 296                 if (!smack)
 297                         mac_smack_apply(devnode, SMACK_ATTR_ACCESS, NULL);
 298         }
 299
 300         /* always update timestamp when we re-use the node, like on media change events */
 301         utimensat(AT_FDCWD, devnode, NULL, 0);
 302 out:
 303         return err;
 304 }
 305
 306 void udev_node_add(struct udev_device *dev, bool apply,
 307                    mode_t mode, uid_t uid, gid_t gid,
 308                    struct udev_list *seclabel_list) {
 309         char filename[DEV_NUM_PATH_MAX];
 310         struct udev_list_entry *list_entry;
 311
 312         log_debug("handling device node '%s', devnum=%s, mode=%#o, uid="UID_FMT", gid="GID_FMT,
 313                   udev_device_get_devnode(dev), udev_device_get_id_filename(dev), mode, uid, gid);
 314
 315         if (node_permissions_apply(dev, apply, mode, uid, gid, seclabel_list) < 0)
 316                 return;
 317
 318         /* always add /dev/{block,char}/$major:$minor */
 319         xsprintf_dev_num_path(filename,
 320                               streq(udev_device_get_subsystem(dev), "block") ? "block" : "char",
 321                               udev_device_get_devnum(dev));
 322         node_symlink(dev, udev_device_get_devnode(dev), filename);
 323
 324         /* create/update symlinks, add symlinks to name index */
 325         udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev))
 326                         link_update(dev, udev_list_entry_get_name(list_entry), true);
 327 }
 328
 329 void udev_node_remove(struct udev_device *dev) {
 330         struct udev_list_entry *list_entry;
 331         char filename[DEV_NUM_PATH_MAX];
 332
 333         /* remove/update symlinks, remove symlinks from name index */
 334         udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev))
 335                 link_update(dev, udev_list_entry_get_name(list_entry), false);
 336
 337         /* remove /dev/{block,char}/$major:$minor */
 338         xsprintf_dev_num_path(filename,
 339                               streq(udev_device_get_subsystem(dev), "block") ? "block" : "char",
 340                               udev_device_get_devnum(dev));
 341         unlink(filename);
 342 }