/* 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; }
static int name_index_get_devices(struct udev *udev, const char *name, struct udev_list_node *dev_list) { char dirname[PATH_MAX]; size_t devlen = strlen(udev_get_dev_path(udev))+1; size_t start; DIR *dir; int count = 0; util_strlcpy(dirname, udev_get_dev_path(udev), sizeof(dirname)); start = util_strlcat(dirname, "/.udev/names/", sizeof(dirname)); util_strlcat(dirname, &name[devlen], sizeof(dirname)); util_path_encode(&dirname[start], sizeof(dirname) - start); dir = opendir(dirname); if (dir == NULL) { dbg(udev, "no index directory '%s': %m\n", dirname); count = -1; goto out; } dbg(udev, "found index directory '%s'\n", dirname); while (1) { struct dirent *ent; char device[UTIL_PATH_SIZE]; ent = readdir(dir); if (ent == NULL || ent->d_name[0] == '\0') break; if (ent->d_name[0] == '.') continue; util_strlcpy(device, udev_get_sys_path(udev), sizeof(device)); util_strlcat(device, ent->d_name, sizeof(device)); util_path_decode(device); udev_list_entry_add(udev, dev_list, device, NULL, 1, 0); count++; } closedir(dir); out: return count; }
/** * Return the local APPDATA directory for APme. * * Create the folder if it does not exist. * * @param[out] path Path to the APPDATA directory * @param[in] pathsz Maximum number of characters that @p path can hold * * @retval true On success * @Retval false On error */ bool sys_appdata_path(char *path, size_t pathsz) { char appdata_path[MAX_PATH]; char *pstr; HRESULT hres; /* Retrieve the APP data path */ hres = SHGetFolderPath(NULL, CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE, NULL, 0, appdata_path); if (!SUCCEEDED(hres)) { con_printf("Error retrieving the LOCAL APPDATA path\n"); return false; } /* Replace '\' with '/' */ pstr = appdata_path; while (*pstr != '\0') { if (*pstr == '\\') *pstr = '/'; pstr++; } util_strlcat(appdata_path, "/APme", sizeof(appdata_path)); con_printf("APPDATA directory: %s\n", appdata_path); /* Check if the directory exists, otherwise create it */ if (!CreateDirectory(appdata_path, NULL)) { if (GetLastError() != ERROR_ALREADY_EXISTS) { con_printf("Create directory on '%s' failed\n", appdata_path); return false; } } util_strlcpy(path, appdata_path, pathsz); return true; }
static void exec_list(struct udev_enumerate *udev_enumerate, const char *action) { struct udev *udev = udev_enumerate_get_udev(udev_enumerate); struct udev_list_entry *entry; udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(udev_enumerate)) { char filename[UTIL_PATH_SIZE]; int fd; if (verbose) printf("%s\n", udev_list_entry_get_name(entry)); if (dry_run) continue; util_strlcpy(filename, udev_list_entry_get_name(entry), sizeof(filename)); util_strlcat(filename, "/uevent", sizeof(filename)); fd = open(filename, O_WRONLY); if (fd < 0) { dbg(udev, "error on opening %s: %m\n", filename); continue; } if (write(fd, action, strlen(action)) < 0) info(udev, "error writing '%s' to '%s': %m\n", action, filename); close(fd); }
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); char file_tmp[UTIL_PATH_SIZE + sizeof(TMP_FILE_EXT)]; 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); } else { info(udev, "atomically replace existing file '%s'\n", file); util_strlcpy(file_tmp, file, sizeof(file_tmp)); util_strlcat(file_tmp, TMP_FILE_EXT, sizeof(file_tmp)); 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)); udev_selinux_setfscreatecon(udev, file, mode); err = mknod(file, mode, devnum); udev_selinux_resetfscreatecon(udev); 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; }
static int node_symlink(struct udev *udev, const char *node, const char *slink) { struct stat stats; char target[UTIL_PATH_SIZE]; char slink_tmp[UTIL_PATH_SIZE + sizeof(TMP_FILE_EXT)]; int i = 0; int tail = 0; int len; int err = 0; /* use relative link */ target[0] = '\0'; while (node[i] && (node[i] == slink[i])) { if (node[i] == '/') tail = i+1; i++; } while (slink[i] != '\0') { if (slink[i] == '/') util_strlcat(target, "../", sizeof(target)); i++; } util_strlcat(target, &node[tail], sizeof(target)); /* 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) { 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]; dbg(udev, "found existing symlink '%s'\n", slink); len = readlink(slink, buf, sizeof(buf)); if (len > 0) { 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); goto exit; } } } } else { info(udev, "creating symlink '%s' to '%s'\n", slink, target); udev_selinux_setfscreatecon(udev, slink, S_IFLNK); err = symlink(target, slink); udev_selinux_resetfscreatecon(udev); if (err == 0) goto exit; } info(udev, "atomically replace '%s'\n", slink); util_strlcpy(slink_tmp, slink, sizeof(slink_tmp)); util_strlcat(slink_tmp, TMP_FILE_EXT, sizeof(slink_tmp)); unlink(slink_tmp); udev_selinux_setfscreatecon(udev, slink, S_IFLNK); err = symlink(target, slink_tmp); udev_selinux_resetfscreatecon(udev); 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); goto exit; } exit: return err; }
/* move any old watches directory out of the way, and then restore * the watches */ void udev_watch_restore(struct udev *udev) { char filename[UTIL_PATH_SIZE], oldname[UTIL_PATH_SIZE]; if (inotify_fd < 0) return; util_strlcpy(oldname, udev_get_dev_path(udev), sizeof(oldname)); util_strlcat(oldname, "/.udev/watch.old", sizeof(oldname)); util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename)); util_strlcat(filename, "/.udev/watch", sizeof(filename)); if (rename(filename, oldname) == 0) { DIR *dir; struct dirent *ent; dir = opendir(oldname); if (dir == NULL) { err(udev, "unable to open old watches dir '%s', old watches will not be restored: %m", oldname); return; } while ((ent = readdir(dir)) != NULL) { char path[UTIL_PATH_SIZE]; char buf[UTIL_PATH_SIZE]; ssize_t syslen; ssize_t len; struct udev_device *dev; if (ent->d_name[0] < '0' || ent->d_name[0] > '9') continue; util_strlcpy(path, oldname, sizeof(path)); util_strlcat(path, "/", sizeof(path)); util_strlcat(path, ent->d_name, sizeof(path)); syslen = util_strlcpy(buf, udev_get_sys_path(udev), sizeof(buf)); len = readlink(path, &buf[syslen], sizeof(buf)-syslen); if (len <= 0 || len >= (ssize_t)(sizeof(buf)-syslen)) { unlink(path); continue; } buf[syslen + len] = '\0'; dbg(udev, "old watch to '%s' found\n", buf); dev = udev_device_new_from_syspath(udev, buf); if (dev == NULL) { unlink(path); continue; } info(udev, "restoring old watch on '%s'\n", udev_device_get_devnode(dev)); udev_watch_begin(udev, dev); udev_device_unref(dev); unlink(path); } closedir(dir); rmdir(oldname); } else if (errno != ENOENT) { err(udev, "unable to move watches dir '%s', old watches will not be restored: %m", filename); } }
int main(int argc, char *argv[]) { struct udev *udev; struct udev_event *event; struct udev_device *dev; struct udev_rules *rules; char syspath[UTIL_PATH_SIZE]; const char *devpath; const char *action; const char *subsystem; struct sigaction act; int err = -EINVAL; udev = udev_new(); if (udev == NULL) exit(1); info(udev, "version %s\n", VERSION); udev_selinux_init(udev); /* set signal handlers */ memset(&act, 0x00, sizeof(act)); act.sa_handler = (void (*)(int)) sig_handler; sigemptyset (&act.sa_mask); act.sa_flags = 0; sigaction(SIGALRM, &act, NULL); sigaction(SIGINT, &act, NULL); sigaction(SIGTERM, &act, NULL); /* trigger timeout to prevent hanging processes */ alarm(UDEV_EVENT_TIMEOUT); action = getenv("ACTION"); devpath = getenv("DEVPATH"); subsystem = getenv("SUBSYSTEM"); if (action == NULL || subsystem == NULL || devpath == NULL) { err(udev, "action, subsystem or devpath missing\n"); goto exit; } rules = udev_rules_new(udev, 1); util_strlcpy(syspath, udev_get_sys_path(udev), sizeof(syspath)); util_strlcat(syspath, devpath, sizeof(syspath)); dev = udev_device_new_from_syspath(udev, syspath); if (dev == NULL) { info(udev, "unknown device '%s'\n", devpath); goto fail; } /* skip reading of db, but read kernel parameters */ udev_device_set_info_loaded(dev); udev_device_read_uevent_file(dev); udev_device_set_action(dev, action); event = udev_event_new(dev); err = udev_event_execute_rules(event, rules); /* rules may change/disable the timeout */ if (udev_device_get_event_timeout(dev) >= 0) alarm(udev_device_get_event_timeout(dev)); if (err == 0 && !event->ignore_device && udev_get_run(udev)) udev_event_execute_run(event); udev_event_unref(event); udev_device_unref(dev); fail: udev_rules_unref(rules); exit: udev_selinux_exit(udev); udev_unref(udev); if (err != 0) return 1; return 0; }