void udev_watch_begin(struct udev *udev, struct udev_device *dev) { char filename[UTIL_PATH_SIZE]; char majmin[UTIL_PATH_SIZE]; int wd; if (inotify_fd < 0) return; info(udev, "adding watch on '%s'\n", udev_device_get_devnode(dev)); wd = inotify_add_watch(inotify_fd, udev_device_get_devnode(dev), IN_CLOSE_WRITE); if (wd < 0) { err(udev, "inotify_add_watch(%d, %s, %o) failed: %m\n", inotify_fd, udev_device_get_devnode(dev), IN_CLOSE_WRITE); return; } snprintf(majmin, sizeof(majmin), "%c%i:%i", strcmp(udev_device_get_subsystem(dev), "block") == 0 ? 'b' : 'c', major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev))); snprintf(filename, sizeof(filename), "%s/.udev/watch/%d", udev_get_dev_path(udev), wd); util_create_path(udev, filename); unlink(filename); symlink(majmin, filename); udev_device_set_watch_handle(dev, wd); }
/* reverse mapping from the device file name to the devpath */ static int name_index(struct udev *udev, const char *devpath, const char *name, int add, int test) { char device[UTIL_PATH_SIZE]; char filename[UTIL_PATH_SIZE * 2]; size_t devlen = strlen(udev_get_dev_path(udev))+1; size_t start; int fd; /* directory with device name */ util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename)); start = util_strlcat(filename, "/.udev/names/", sizeof(filename)); util_strlcat(filename, &name[devlen], sizeof(filename)); util_path_encode(&filename[start], sizeof(filename) - start); /* entry with the devpath */ util_strlcpy(device, devpath, sizeof(device)); util_path_encode(device, sizeof(device)); util_strlcat(filename, "/", sizeof(filename)); util_strlcat(filename, device, sizeof(filename)); if (add) { dbg(udev, "creating index: '%s'\n", filename); util_create_path(udev, filename); fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0644); if (fd > 0) close(fd); } else { dbg(udev, "removing index: '%s'\n", filename); unlink(filename); util_delete_path(udev, filename); } return 0; }
/* manage "stack of names" with possibly specified device priorities */ static void link_update(struct udev_device *dev, const char *slink, bool add) { struct udev *udev = udev_device_get_udev(dev); char name_enc[UTIL_PATH_SIZE]; char filename[UTIL_PATH_SIZE * 2]; char dirname[UTIL_PATH_SIZE]; const char *target; char buf[UTIL_PATH_SIZE]; dbg(udev, "update symlink '%s' of '%s'\n", slink, udev_device_get_syspath(dev)); util_path_encode(&slink[strlen(udev_get_dev_path(udev))+1], name_enc, sizeof(name_enc)); util_strscpyl(dirname, sizeof(dirname), udev_get_run_path(udev), "/links/", name_enc, NULL); util_strscpyl(filename, sizeof(filename), dirname, "/", udev_device_get_id_filename(dev), NULL); if (!add) { dbg(udev, "removing index: '%s'\n", filename); if (unlink(filename) == 0) rmdir(dirname); } target = link_find_prioritized(dev, add, dirname, buf, sizeof(buf)); if (target == NULL) { info(udev, "no reference left, remove '%s'\n", slink); if (unlink(slink) == 0) util_delete_path(udev, slink); } else { info(udev, "creating link '%s' to '%s'\n", slink, target); node_symlink(udev, target, slink); } if (add) { int err; dbg(udev, "creating index: '%s'\n", filename); do { int fd; err = util_create_path(udev, filename); if (err != 0 && err != -ENOENT) break; fd = open(filename, O_WRONLY|O_CREAT|O_CLOEXEC|O_TRUNC|O_NOFOLLOW, 0444); if (fd >= 0) close(fd); else err = -errno; } while (err == -ENOENT); } }
int udev_node_add(struct udev_device *dev, mode_t mode, uid_t uid, gid_t gid, int test) { struct udev *udev = udev_device_get_udev(dev); int i; int num; struct udev_list_entry *list_entry; int err = 0; info(udev, "creating device node '%s', devnum=%d:%d, mode=%#o, uid=%d, gid=%d\n", udev_device_get_devnode(dev), major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev)), mode, uid, gid); util_create_path(udev, udev_device_get_devnode(dev)); if (!test) if (udev_node_mknod(dev, NULL, makedev(0,0), mode, uid, gid) != 0) { err = -1; goto exit; } /* create all_partitions if requested */ num = udev_device_get_num_fake_partitions(dev); if (num > 0) { info(udev, "creating device partition nodes '%s[1-%i]'\n", udev_device_get_devnode(dev), num); if (!test) { for (i = 1; i <= num; i++) { char partitionname[UTIL_PATH_SIZE]; dev_t part_devnum; snprintf(partitionname, sizeof(partitionname), "%s%d", udev_device_get_devnode(dev), i); partitionname[sizeof(partitionname)-1] = '\0'; part_devnum = makedev(major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev)) + i); udev_node_mknod(dev, partitionname, part_devnum, mode, uid, gid); } } } /* add node to name index */ name_index(udev, udev_device_get_devpath(dev), udev_device_get_devnode(dev), 1, test); /* create/update symlinks, add symlinks to name index */ udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev)) { name_index(udev, udev_device_get_devpath(dev), udev_list_entry_get_name(list_entry), 1, test); update_link(dev, udev_list_entry_get_name(list_entry), test); }
/* manage "stack of names" with possibly specified device priorities */ static void link_update(struct udev_device *dev, const char *slink, bool add) { struct udev *udev = udev_device_get_udev(dev); char name_enc[UTIL_PATH_SIZE]; char filename[UTIL_PATH_SIZE * 2]; char dirname[UTIL_PATH_SIZE]; const char *target; char buf[UTIL_PATH_SIZE]; dbg(udev, "update symlink '%s' of '%s'\n", slink, udev_device_get_syspath(dev)); util_path_encode(&slink[strlen(udev_get_dev_path(udev))+1], name_enc, sizeof(name_enc)); snprintf(dirname, sizeof(dirname), "%s/.udev/links/%s", udev_get_dev_path(udev), name_enc); snprintf(filename, sizeof(filename), "%s/%c%u:%u", dirname, strcmp(udev_device_get_subsystem(dev), "block") == 0 ? 'b' : 'c', major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev))); if (!add) { dbg(udev, "removing index: '%s'\n", filename); unlink(filename); util_delete_path(udev, filename); } target = link_find_prioritized(dev, add, dirname, buf, sizeof(buf)); if (target == NULL) { info(udev, "no reference left, remove '%s'\n", slink); unlink(slink); util_delete_path(udev, slink); } else { info(udev, "creating link '%s' to '%s'\n", slink, target); node_symlink(udev, target, slink); } if (add) { int err; dbg(udev, "creating index: '%s'\n", filename); do { err = util_create_path(udev, filename); if (err != 0 && err != -ENOENT) break; err = symlink(udev_device_get_devpath(dev), filename); if (err != 0) err = -errno; } while (err == -ENOENT); } }
static int create_path(struct udev *udev, const char *path, bool selinux) { char p[UTIL_PATH_SIZE]; char *pos; struct stat stats; int err; util_strscpy(p, sizeof(p), path); pos = strrchr(p, '/'); if (pos == NULL) return 0; while (pos != p && pos[-1] == '/') pos--; if (pos == p) return 0; pos[0] = '\0'; dbg(udev, "stat '%s'\n", p); if (stat(p, &stats) == 0) { if ((stats.st_mode & S_IFMT) == S_IFDIR) return 0; else return -ENOTDIR; } err = util_create_path(udev, p); if (err != 0) return err; dbg(udev, "mkdir '%s'\n", p); if (selinux) udev_selinux_setfscreatecon(udev, p, S_IFDIR|0755); err = mkdir(p, 0755); if (err != 0) { err = -errno; if (err == -EEXIST && stat(p, &stats) == 0) { if ((stats.st_mode & S_IFMT) == S_IFDIR) err = 0; else err = -ENOTDIR; } } if (selinux) udev_selinux_resetfscreatecon(udev); return err; }
void udev_watch_begin(struct udev *udev, struct udev_device *dev) { char filename[UTIL_PATH_SIZE]; int wd; if (inotify_fd < 0) return; info(udev, "adding watch on '%s'\n", udev_device_get_devnode(dev)); wd = inotify_add_watch(inotify_fd, udev_device_get_devnode(dev), IN_CLOSE_WRITE); if (wd < 0) { err(udev, "inotify_add_watch(%d, %s, %o) failed: %m\n", inotify_fd, udev_device_get_devnode(dev), IN_CLOSE_WRITE); } snprintf(filename, sizeof(filename), "%s/.udev/watch/%d", udev_get_dev_path(udev), wd); util_create_path(udev, filename); unlink(filename); symlink(udev_device_get_devpath(dev), filename); udev_device_set_watch_handle(dev, wd); }
int main(int argc, char *argv[]) { struct udev *udev; struct udev_event *event = NULL; struct udev_device *dev = NULL; struct udev_rules *rules = NULL; char syspath[UTIL_PATH_SIZE]; const char *devpath; const char *action; sigset_t mask, sigmask_orig; int err = -EINVAL; udev = udev_new(); if (udev == NULL) exit(1); info(udev, "version %s\n", VERSION); udev_selinux_init(udev); sigprocmask(SIG_SETMASK, NULL, &sigmask_orig); action = argv[1]; if (action == NULL) { err(udev, "action missing\n"); goto out; } devpath = argv[2]; if (devpath == NULL) { err(udev, "devpath missing\n"); goto out; } rules = udev_rules_new(udev, 1); util_strscpyl(syspath, sizeof(syspath), udev_get_sys_path(udev), devpath, NULL); dev = udev_device_new_from_syspath(udev, syspath); if (dev == NULL) { info(udev, "unknown device '%s'\n", devpath); goto out; } udev_device_set_action(dev, action); event = udev_event_new(dev); sigfillset(&mask); sigprocmask(SIG_SETMASK, &mask, &sigmask_orig); event->fd_signal = signalfd(-1, &mask, SFD_NONBLOCK|SFD_CLOEXEC); if (event->fd_signal < 0) { fprintf(stderr, "error creating signalfd\n"); goto out; } /* do what devtmpfs usually provides us */ if (udev_device_get_devnode(dev) != NULL) { mode_t mode; if (strcmp(udev_device_get_subsystem(dev), "block") == 0) mode |= S_IFBLK; else mode |= S_IFCHR; if (strcmp(action, "remove") != 0) { util_create_path(udev, udev_device_get_devnode(dev)); mknod(udev_device_get_devnode(dev), mode, udev_device_get_devnum(dev)); } else { unlink(udev_device_get_devnode(dev)); util_delete_path(udev, udev_device_get_devnode(dev)); } } err = udev_event_execute_rules(event, rules, &sigmask_orig); if (err == 0) udev_event_execute_run(event, NULL); out: if (event != NULL && event->fd_signal >= 0) close(event->fd_signal); udev_event_unref(event); udev_device_unref(dev); udev_rules_unref(rules); udev_selinux_exit(udev); udev_unref(udev); if (err != 0) return 1; return 0; }
static int update_link(struct udev_device *dev, const char *slink, int test) { struct udev *udev = udev_device_get_udev(dev); struct udev_list_node dev_list; struct udev_list_entry *dev_entry; char target[UTIL_PATH_SIZE]; int count; int priority = 0; int rc = 0; dbg(udev, "update symlink '%s' of '%s'\n", slink, udev_device_get_syspath(dev)); udev_list_init(&dev_list); count = name_index_get_devices(udev, slink, &dev_list); if (count > 1) info(udev, "found %i devices with name '%s'\n", count, slink); /* if we don't have a reference, delete it */ if (count <= 0) { info(udev, "no reference left, remove '%s'\n", slink); if (!test) { unlink(slink); util_delete_path(udev, slink); } goto out; } /* find the device with the highest priority */ target[0] = '\0'; udev_list_entry_foreach(dev_entry, udev_list_get_entry(&dev_list)) { const char *syspath; struct udev_device *dev_db; const char *devnode; syspath = udev_list_entry_get_name(dev_entry); dbg(udev, "found '%s' for '%s'\n", syspath, slink); /* did we find ourself? we win, if we have the same priority */ if (strcmp(udev_device_get_syspath(dev), syspath) == 0) { dbg(udev, "compare (our own) priority of '%s' %i >= %i\n", udev_device_get_devpath(dev), udev_device_get_devlink_priority(dev), priority); if (strcmp(udev_device_get_devnode(dev), slink) == 0) { info(udev, "'%s' is our device node, database inconsistent, skip link update\n", udev_device_get_devnode(dev)); } else if (target[0] == '\0' || udev_device_get_devlink_priority(dev) >= priority) { priority = udev_device_get_devlink_priority(dev); util_strlcpy(target, udev_device_get_devnode(dev), sizeof(target)); } continue; } /* another device, read priority from database */ dev_db = udev_device_new_from_syspath(udev, syspath); if (dev_db == NULL) continue; devnode = udev_device_get_devnode(dev_db); if (devnode != NULL) { if (strcmp(devnode, slink) == 0) { info(udev, "'%s' is a device node of '%s', skip link update\n", devnode, syspath); } else { dbg(udev, "compare priority of '%s' %i > %i\n", udev_device_get_devpath(dev_db), udev_device_get_devlink_priority(dev_db), priority); if (target[0] == '\0' || udev_device_get_devlink_priority(dev_db) > priority) { priority = udev_device_get_devlink_priority(dev_db); util_strlcpy(target, devnode, sizeof(target)); } } } udev_device_unref(dev_db); } udev_list_cleanup_entries(udev, &dev_list); if (target[0] == '\0') { info(udev, "no current target for '%s' found\n", slink); rc = 1; goto out; } /* create symlink to the target with the highest priority */ info(udev, "'%s' with target '%s' has the highest priority %i, create it\n", slink, target, priority); if (!test) { util_create_path(udev, slink); node_symlink(udev, target, slink); } out: return rc; }
int udev_node_mknod(struct udev_device *dev, const char *file, mode_t mode, uid_t uid, gid_t gid) { struct udev *udev = udev_device_get_udev(dev); dev_t devnum = udev_device_get_devnum(dev); struct stat stats; int err = 0; if (strcmp(udev_device_get_subsystem(dev), "block") == 0) mode |= S_IFBLK; else mode |= S_IFCHR; if (file == NULL) file = udev_device_get_devnode(dev); if (lstat(file, &stats) == 0) { if (((stats.st_mode & S_IFMT) == (mode & S_IFMT)) && (stats.st_rdev == devnum)) { info(udev, "preserve file '%s', because it has correct dev_t\n", file); if (stats.st_mode != mode || stats.st_uid != uid || stats.st_gid != gid) { info(udev, "set permissions %s, %#o, uid=%u, gid=%u\n", file, mode, uid, gid); chmod(file, mode); chown(file, uid, gid); } else { info(udev, "preserve permissions %s, %#o, uid=%u, gid=%u\n", file, mode, uid, gid); } /* * Set initial selinux file context only on add events. * We set the proper context on bootup (triger) or for newly * added devices, but we don't change it later, in case * something else has set a custom context in the meantime. */ if (strcmp(udev_device_get_action(dev), "add") == 0) udev_selinux_lsetfilecon(udev, file, mode); /* always update timestamp when we re-use the node, like on media change events */ utimensat(AT_FDCWD, file, NULL, 0); } else { char file_tmp[UTIL_PATH_SIZE + sizeof(TMP_FILE_EXT)]; info(udev, "atomically replace existing file '%s'\n", file); util_strscpyl(file_tmp, sizeof(file_tmp), file, TMP_FILE_EXT, NULL); unlink(file_tmp); udev_selinux_setfscreatecon(udev, file_tmp, mode); err = mknod(file_tmp, mode, devnum); udev_selinux_resetfscreatecon(udev); if (err != 0) { err(udev, "mknod '%s' %u:%u %#o failed: %m\n", file_tmp, major(devnum), minor(devnum), mode); goto exit; } err = rename(file_tmp, file); if (err != 0) { err(udev, "rename '%s' '%s' failed: %m\n", file_tmp, file); unlink(file_tmp); goto exit; } info(udev, "set permissions '%s' %#o uid=%u gid=%u\n", file, mode, uid, gid); chmod(file, mode); chown(file, uid, gid); } } else { info(udev, "mknod '%s' %u:%u %#o\n", file, major(devnum), minor(devnum), mode); do { err = util_create_path(udev, file); if (err != 0 && err != -ENOENT) break; udev_selinux_setfscreatecon(udev, file, mode); err = mknod(file, mode, devnum); if (err != 0) err = -errno; udev_selinux_resetfscreatecon(udev); } while (err == -ENOENT); if (err != 0) err(udev, "mknod '%s' %u:%u %#o' failed: %m\n", file, major(devnum), minor(devnum), mode); info(udev, "set permissions '%s' %#o uid=%u gid=%u\n", file, mode, uid, gid); chmod(file, mode); chown(file, uid, gid); } exit: return err; }
static int node_symlink(struct udev *udev, const char *node, const char *slink) { struct stat stats; char target[UTIL_PATH_SIZE]; char *s; size_t l; char slink_tmp[UTIL_PATH_SIZE + sizeof(TMP_FILE_EXT)]; int i = 0; int tail = 0; int err = 0; /* use relative link */ target[0] = '\0'; while (node[i] && (node[i] == slink[i])) { if (node[i] == '/') tail = i+1; i++; } s = target; l = sizeof(target); while (slink[i] != '\0') { if (slink[i] == '/') l = util_strpcpy(&s, l, "../"); i++; } l = util_strscpy(s, l, &node[tail]); if (l == 0) { err = -EINVAL; goto exit; } /* preserve link with correct target, do not replace node of other device */ if (lstat(slink, &stats) == 0) { if (S_ISBLK(stats.st_mode) || S_ISCHR(stats.st_mode)) { struct stat stats2; info(udev, "found existing node instead of symlink '%s'\n", slink); if (lstat(node, &stats2) == 0) { if ((stats.st_mode & S_IFMT) == (stats2.st_mode & S_IFMT) && stats.st_rdev == stats2.st_rdev && stats.st_ino != stats2.st_ino) { info(udev, "replace device node '%s' with symlink to our node '%s'\n", slink, node); } else { err(udev, "device node '%s' already exists, " "link to '%s' will not overwrite it\n", slink, node); goto exit; } } } else if (S_ISLNK(stats.st_mode)) { char buf[UTIL_PATH_SIZE]; int len; dbg(udev, "found existing symlink '%s'\n", slink); len = readlink(slink, buf, sizeof(buf)); if (len > 0 && len < (int)sizeof(buf)) { buf[len] = '\0'; if (strcmp(target, buf) == 0) { info(udev, "preserve already existing symlink '%s' to '%s'\n", slink, target); udev_selinux_lsetfilecon(udev, slink, S_IFLNK); utimensat(AT_FDCWD, slink, NULL, AT_SYMLINK_NOFOLLOW); goto exit; } } } } else { info(udev, "creating symlink '%s' to '%s'\n", slink, target); do { err = util_create_path(udev, slink); if (err != 0 && err != -ENOENT) break; udev_selinux_setfscreatecon(udev, slink, S_IFLNK); err = symlink(target, slink); if (err != 0) err = -errno; udev_selinux_resetfscreatecon(udev); } while (err == -ENOENT); if (err == 0) goto exit; } info(udev, "atomically replace '%s'\n", slink); util_strscpyl(slink_tmp, sizeof(slink_tmp), slink, TMP_FILE_EXT, NULL); unlink(slink_tmp); do { err = util_create_path(udev, slink_tmp); if (err != 0 && err != -ENOENT) break; udev_selinux_setfscreatecon(udev, slink_tmp, S_IFLNK); err = symlink(target, slink_tmp); if (err != 0) err = -errno; udev_selinux_resetfscreatecon(udev); } while (err == -ENOENT); if (err != 0) { err(udev, "symlink '%s' '%s' failed: %m\n", target, slink_tmp); goto exit; } err = rename(slink_tmp, slink); if (err != 0) { err(udev, "rename '%s' '%s' failed: %m\n", slink_tmp, slink); unlink(slink_tmp); } exit: return err; }
int udev_node_mknod(struct udev_device *dev, const char *file, dev_t devnum, mode_t mode, uid_t uid, gid_t gid) { struct udev *udev = udev_device_get_udev(dev); struct stat stats; int preserve = 0; int err = 0; if (major(devnum) == 0) devnum = udev_device_get_devnum(dev); if (strcmp(udev_device_get_subsystem(dev), "block") == 0) mode |= S_IFBLK; else mode |= S_IFCHR; if (file == NULL) file = udev_device_get_devnode(dev); if (lstat(file, &stats) == 0) { if (((stats.st_mode & S_IFMT) == (mode & S_IFMT)) && (stats.st_rdev == devnum)) { info(udev, "preserve file '%s', because it has correct dev_t\n", file); preserve = 1; udev_selinux_lsetfilecon(udev, file, mode); /* update time stamp when we re-use the node, like on media change events */ utimes(file, NULL); } else { char file_tmp[UTIL_PATH_SIZE + sizeof(TMP_FILE_EXT)]; info(udev, "atomically replace existing file '%s'\n", file); util_strscpyl(file_tmp, sizeof(file_tmp), file, TMP_FILE_EXT, NULL); unlink(file_tmp); udev_selinux_setfscreatecon(udev, file_tmp, mode); err = mknod(file_tmp, mode, devnum); udev_selinux_resetfscreatecon(udev); if (err != 0) { err(udev, "mknod(%s, %#o, %u, %u) failed: %m\n", file_tmp, mode, major(devnum), minor(devnum)); goto exit; } err = rename(file_tmp, file); if (err != 0) { err(udev, "rename(%s, %s) failed: %m\n", file_tmp, file); unlink(file_tmp); } } } else { info(udev, "mknod(%s, %#o, (%u,%u))\n", file, mode, major(devnum), minor(devnum)); do { err = util_create_path(udev, file); if (err != 0 && err != -ENOENT) break; udev_selinux_setfscreatecon(udev, file, mode); err = mknod(file, mode, devnum); if (err != 0) err = -errno; udev_selinux_resetfscreatecon(udev); } while (err == -ENOENT); if (err != 0) { err(udev, "mknod(%s, %#o, (%u,%u) failed: %m\n", file, mode, major(devnum), minor(devnum)); goto exit; } } if (!preserve || stats.st_mode != mode) { info(udev, "chmod(%s, %#o)\n", file, mode); err = chmod(file, mode); if (err != 0) { err(udev, "chmod(%s, %#o) failed: %m\n", file, mode); goto exit; } } if (!preserve || stats.st_uid != uid || stats.st_gid != gid) { info(udev, "chown(%s, %u, %u)\n", file, uid, gid); err = chown(file, uid, gid); if (err != 0) { err(udev, "chown(%s, %u, %u) failed: %m\n", file, uid, gid); goto exit; } } exit: return err; }