chiark / gitweb /
use CLOEXEC flags instead of fcntl()
[elogind.git] / udev / udev-watch.c
index 33b493d..d67083b 100644 (file)
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#ifdef HAVE_INOTIFY
 #include <sys/inotify.h>
 #include <sys/inotify.h>
-#endif
 
 #include "udev.h"
 
 
 #include "udev.h"
 
-int inotify_fd = -1;
+static int inotify_fd = -1;
 
 /* inotify descriptor, will be shared with rules directory;
  * set to cloexec since we need our children to be able to add
  * watches for us
  */
 
 /* inotify descriptor, will be shared with rules directory;
  * set to cloexec since we need our children to be able to add
  * watches for us
  */
-void udev_watch_init(struct udev *udev)
+int udev_watch_init(struct udev *udev)
 {
 {
-       inotify_fd = inotify_init();
-       if (inotify_fd >= 0) {
-               int flags;
-
-               flags = fcntl(inotify_fd, F_GETFD);
-               if (flags < 0)
-                       flags = FD_CLOEXEC;
-               else
-                       flags |= FD_CLOEXEC;
-               fcntl(inotify_fd, F_SETFD, flags);
-       } else if (errno == ENOSYS)
-               info(udev, "unable to use inotify, udevd will not monitor rule files changes\n");
-       else
+       inotify_fd = inotify_init1(IN_CLOEXEC);
+       if (inotify_fd < 0)
                err(udev, "inotify_init failed: %m\n");
                err(udev, "inotify_init failed: %m\n");
+       return inotify_fd;
 }
 
 /* move any old watches directory out of the way, and then restore
 }
 
 /* move any old watches directory out of the way, and then restore
@@ -66,12 +54,8 @@ void udev_watch_restore(struct udev *udev)
        if (inotify_fd < 0)
                return;
 
        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));
-
+       util_strscpyl(oldname, sizeof(oldname), udev_get_dev_path(udev), "/.udev/watch.old", NULL);
+       util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev), "/.udev/watch", NULL);
        if (rename(filename, oldname) == 0) {
                DIR *dir;
                struct dirent *ent;
        if (rename(filename, oldname) == 0) {
                DIR *dir;
                struct dirent *ent;
@@ -82,30 +66,28 @@ void udev_watch_restore(struct udev *udev)
                        return;
                }
 
                        return;
                }
 
-               while ((ent = readdir(dir)) != NULL) {
-                       char path[UTIL_PATH_SIZE];
-                       char buf[UTIL_PATH_SIZE];
+               for (ent = readdir(dir); ent != NULL; ent = readdir(dir)) {
+                       char device[UTIL_PATH_SIZE];
+                       char *s;
+                       size_t l;
                        ssize_t len;
                        struct udev_device *dev;
 
                        if (ent->d_name[0] < '0' || ent->d_name[0] > '9')
                                continue;
 
                        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));
-
-                       len = readlink(path, buf, sizeof(buf));
-                       if (len <= 0) {
-                               unlink(path);
+                       s = device;
+                       l = util_strpcpy(&s, sizeof(device), udev_get_sys_path(udev));
+                       len = readlinkat(dirfd(dir), ent->d_name, s, l);
+                       if (len <= 0 || len >= (ssize_t)l) {
+                               unlinkat(dirfd(dir), ent->d_name, 0);
                                continue;
                        }
                                continue;
                        }
-
-                       buf[len] = '\0';
-                       dbg(udev, "old watch to '%s' found\n", buf);
-                       dev = udev_device_new_from_syspath(udev, buf);
+                       s[len] = '\0';
+                       dbg(udev, "old watch to '%s' found\n", device);
+                       dev = udev_device_new_from_syspath(udev, device);
                        if (dev == NULL) {
                        if (dev == NULL) {
-                               unlink(path);
+                               unlinkat(dirfd(dir), ent->d_name, 0);
                                continue;
                        }
 
                                continue;
                        }
 
@@ -113,7 +95,7 @@ void udev_watch_restore(struct udev *udev)
                        udev_watch_begin(udev, dev);
 
                        udev_device_unref(dev);
                        udev_watch_begin(udev, dev);
 
                        udev_device_unref(dev);
-                       unlink(path);
+                       unlinkat(dirfd(dir), ent->d_name, 0);
                }
 
                closedir(dir);
                }
 
                closedir(dir);
@@ -124,112 +106,68 @@ void udev_watch_restore(struct udev *udev)
        }
 }
 
        }
 }
 
-static const char *udev_watch_filename(struct udev *udev, int wd)
-{
-       static char filename[UTIL_PATH_SIZE];
-       char str[32];
-
-       sprintf(str, "%d", wd);
-       util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
-       util_strlcat(filename, "/.udev/watch/", sizeof(filename));
-       util_strlcat(filename, str, sizeof(filename));
-
-       return filename;
-}
-
 void udev_watch_begin(struct udev *udev, struct udev_device *dev)
 {
 void udev_watch_begin(struct udev *udev, struct udev_device *dev)
 {
-       const char *filename;
+       char filename[UTIL_PATH_SIZE];
        int wd;
 
        int wd;
 
-       if (inotify_fd < 0 || major(udev_device_get_devnum(dev)) == 0)
+       if (inotify_fd < 0)
                return;
 
                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);
        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;
        }
 
        }
 
-       filename = udev_watch_filename(udev, wd);
+       snprintf(filename, sizeof(filename), "%s/.udev/watch/%d", udev_get_dev_path(udev), wd);
        util_create_path(udev, filename);
        unlink(filename);
        util_create_path(udev, filename);
        unlink(filename);
-       symlink(udev_device_get_syspath(dev), filename);
+       symlink(udev_device_get_devpath(dev), filename);
+
+       udev_device_set_watch_handle(dev, wd);
 }
 
 }
 
-void udev_watch_clear(struct udev *udev, struct udev_device *dev)
+void udev_watch_end(struct udev *udev, struct udev_device *dev)
 {
 {
-       static char filename[UTIL_PATH_SIZE];
-       DIR *dir;
-       struct dirent *ent;
+       int wd;
+       char filename[UTIL_PATH_SIZE];
 
 
-       if (inotify_fd < 0 || major(udev_device_get_devnum(dev)) == 0)
+       if (inotify_fd < 0)
                return;
 
                return;
 
-       util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
-       util_strlcat(filename, "/.udev/watch", sizeof(filename));
-
-       dir = opendir(filename);
-       if (dir == NULL)
-               return;
-
-       while ((ent = readdir(dir)) != NULL) {
-               char path[UTIL_PATH_SIZE];
-               char buf[UTIL_PATH_SIZE];
-               ssize_t len;
-
-               if (ent->d_name[0] < '0' || ent->d_name[0] > '9')
-                       continue;
-
-               util_strlcpy(path, filename, sizeof(path));
-               util_strlcat(path, "/", sizeof(path));
-               util_strlcat(path, ent->d_name, sizeof(path));
-
-               len = readlink(path, buf, sizeof(buf));
-               if (len <= 0)
-                       continue;
-
-               buf[len] = '\0';
-               if (strcmp(buf, udev_device_get_syspath(dev)))
-                       continue;
-
-               /* this is the watch we're looking for */
-               info(udev, "clearing existing watch on '%s'\n", udev_device_get_devnode(dev));
-               udev_watch_end(udev, atoi(ent->d_name));
-       }
-
-       closedir(dir);
-}
-
-void udev_watch_end(struct udev *udev, int wd)
-{
-       const char *filename;
-
-       if (inotify_fd < 0 || wd < 0)
+       wd = udev_device_get_watch_handle(dev);
+       if (wd < 0)
                return;
 
                return;
 
+       info(udev, "removing watch on '%s'\n", udev_device_get_devnode(dev));
        inotify_rm_watch(inotify_fd, wd);
 
        inotify_rm_watch(inotify_fd, wd);
 
-       filename = udev_watch_filename(udev, wd);
+       snprintf(filename, sizeof(filename), "%s/.udev/watch/%d", udev_get_dev_path(udev), wd);
        unlink(filename);
        unlink(filename);
+
+       udev_device_set_watch_handle(dev, -1);
 }
 
 }
 
-const char *udev_watch_lookup(struct udev *udev, int wd)
+struct udev_device *udev_watch_lookup(struct udev *udev, int wd)
 {
 {
-       const char *filename;
-       static char buf[UTIL_PATH_SIZE];
+       char filename[UTIL_PATH_SIZE];
+       char syspath[UTIL_PATH_SIZE];
+       char *s;
+       size_t l;
        ssize_t len;
 
        if (inotify_fd < 0 || wd < 0)
                return NULL;
 
        ssize_t len;
 
        if (inotify_fd < 0 || wd < 0)
                return NULL;
 
-       filename = udev_watch_filename(udev, wd);
-       len = readlink(filename, buf, sizeof(buf));
-       if (len > 0) {
-               buf[len] = '\0';
-
-               return buf;
-       }
-
-       return NULL;
+       snprintf(filename, sizeof(filename), "%s/.udev/watch/%d", udev_get_dev_path(udev), wd);
+       s = syspath;
+       l = util_strpcpy(&s, sizeof(syspath), udev_get_sys_path(udev));
+       len = readlink(filename, s, l);
+       if (len < 0 || (size_t)len >= l)
+               return NULL;
+       s[len] = '\0';
+       return udev_device_new_from_syspath(udev, syspath);
 }
 }