Decrease buffer size when advancing past NUL byte

[elogind.git] / libudev / libudev-device.c

diff --git a/libudev/libudev-device.c b/libudev/libudev-device.c
index aef62567341136bdd5d92795a01cbfa2582c48d2..4f42aa2810795af231bc7e0ccf28b08ec5739e72 100644 (file)
--- a/libudev/libudev-device.c
+++ b/libudev/libudev-device.c
@@ -23,10 +23,20 @@
 #include "libudev.h"
 #include "libudev-private.h"
 
 #include "libudev.h"
 #include "libudev-private.h"
 

+/**
+ * SECTION:libudev-device
+ * @short_description: kernel sys devices
+ *
+ * Representation of kernel sys devices. Devices are uniquely identified
+ * by their syspath, every device has exactly one path in the kernel sys
+ * filesystem. Devices usually belong to a kernel subsystem, and and have
+ * a unique name inside that subsystem.
+ */
+

 /**
  * udev_device:
  *
 /**
  * udev_device:
  *

- * Representation of a kernel sys device.
+ * Opaque object representing one kernel sys device.

  */
 struct udev_device {
        struct udev *udev;
  */
 struct udev_device {
        struct udev *udev;


@@ -41,6 +51,7 @@ struct udev_device {
        char *driver;
        char *action;
        char *devpath_old;
        char *driver;
        char *action;
        char *devpath_old;

+       char *sysname_old;

        char *knodename;
        char **envp;
        char *monitor_buf;
        char *knodename;
        char **envp;
        char *monitor_buf;


@@ -66,16 +77,6 @@ struct udev_device {
        unsigned int ignore_remove:1;
 };
 
        unsigned int ignore_remove:1;
 };
 

-static size_t devpath_to_db_path(struct udev *udev, const char *devpath, char *filename, size_t len)
-{
-       char *s;
-       size_t l;
-
-       s = filename;
-       l = util_strpcpyl(&s, len, udev_get_dev_path(udev), "/.udev/db/", NULL);
-       return util_path_encode(devpath, s, l);
-}
-

 int udev_device_read_db(struct udev_device *udev_device)
 {
        struct stat stats;
 int udev_device_read_db(struct udev_device *udev_device)
 {
        struct stat stats;


@@ -83,7 +84,8 @@ int udev_device_read_db(struct udev_device *udev_device)
        char line[UTIL_LINE_SIZE];
        FILE *f;
 
        char line[UTIL_LINE_SIZE];
        FILE *f;
 

-       devpath_to_db_path(udev_device->udev, udev_device->devpath, filename, sizeof(filename));
+       util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev_device->udev), "/.udev/db/",
+                     udev_device_get_subsystem(udev_device), ":", udev_device_get_sysname(udev_device), NULL);

 
        if (lstat(filename, &stats) != 0) {
                dbg(udev_device->udev, "no db file to read %s: %m\n", filename);
 
        if (lstat(filename, &stats) != 0) {
                dbg(udev_device->udev, "no db file to read %s: %m\n", filename);


@@ -121,7 +123,7 @@ int udev_device_read_db(struct udev_device *udev_device)
                                next = &next[1];
                        }
                        util_strscpyl(devlink, sizeof(devlink), udev_get_dev_path(udev_device->udev), "/", lnk, NULL);
                                next = &next[1];
                        }
                        util_strscpyl(devlink, sizeof(devlink), udev_get_dev_path(udev_device->udev), "/", lnk, NULL);

-                       udev_device_add_devlink(udev_device, devlink);
+                       udev_device_add_devlink(udev_device, devlink, 0);

                }
                info(udev_device->udev, "device %p filled with db symlink data '%s'\n", udev_device, udev_device->devnode);
                return 0;
                }
                info(udev_device->udev, "device %p filled with db symlink data '%s'\n", udev_device, udev_device->devnode);
                return 0;


@@ -148,7 +150,7 @@ int udev_device_read_db(struct udev_device *udev_device)
                        break;
                case 'S':
                        util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev_device->udev), "/", val, NULL);
                        break;
                case 'S':
                        util_strscpyl(filename, sizeof(filename), udev_get_dev_path(udev_device->udev), "/", val, NULL);

-                       udev_device_add_devlink(udev_device, filename);
+                       udev_device_add_devlink(udev_device, filename, 0);

                        break;
                case 'L':
                        udev_device_set_devlink_priority(udev_device, atoi(val));
                        break;
                case 'L':
                        udev_device_set_devlink_priority(udev_device, atoi(val));


@@ -260,7 +262,7 @@ struct udev_device *udev_device_new(struct udev *udev)
  * @syspath: sys device path including sys directory
  *
  * Create new udev device, and fill in information from the sys
  * @syspath: sys device path including sys directory
  *
  * Create new udev device, and fill in information from the sys

- * device and the udev database entry. The sypath is the absolute
+ * device and the udev database entry. The syspath is the absolute

  * path to the device, including the sys mount point.
  *
  * The initial refcount is 1, and needs to be decremented to
  * path to the device, including the sys mount point.
  *
  * The initial refcount is 1, and needs to be decremented to


@@ -301,25 +303,7 @@ struct udev_device *udev_device_new_from_syspath(struct udev *udev, const char *
        util_strscpy(path, sizeof(path), syspath);
        util_resolve_sys_link(udev, path, sizeof(path));
 
        util_strscpy(path, sizeof(path), syspath);
        util_resolve_sys_link(udev, path, sizeof(path));
 

-       /* try to resolve the silly block layout if needed */
-       if (strncmp(&path[len], "/block/", 7) == 0) {
-               char block[UTIL_PATH_SIZE];
-               char part[UTIL_PATH_SIZE];
-
-               util_strscpy(block, sizeof(block), path);
-               pos = strrchr(block, '/');
-               if (pos == NULL)
-                       return NULL;
-               util_strscpy(part, sizeof(part), pos);
-               pos[0] = '\0';
-               if (util_resolve_sys_link(udev, block, sizeof(block)) == 0)
-                       util_strscpyl(path, sizeof(path), block, part, NULL);
-       }
-
-       /* path exists in sys */
-       if (strncmp(&syspath[len], "/devices/", 9) == 0 ||
-           strncmp(&syspath[len], "/class/", 7) == 0 ||
-           strncmp(&syspath[len], "/block/", 7) == 0) {
+       if (strncmp(&syspath[len], "/devices/", 9) == 0) {

                char file[UTIL_PATH_SIZE];
 
                /* all "devices" require a "uevent" file */
                char file[UTIL_PATH_SIZE];
 
                /* all "devices" require a "uevent" file */


@@ -367,9 +351,6 @@ struct udev_device *udev_device_new_from_devnum(struct udev *udev, char type, de
 {
        char path[UTIL_PATH_SIZE];
        const char *type_str;
 {
        char path[UTIL_PATH_SIZE];
        const char *type_str;

-       struct udev_enumerate *udev_enumerate;
-       struct udev_list_entry *list_entry;
-       struct udev_device *device = NULL;

 
        if (type == 'b')
                type_str = "block";
 
        if (type == 'b')
                type_str = "block";


@@ -378,51 +359,21 @@ struct udev_device *udev_device_new_from_devnum(struct udev *udev, char type, de
        else
                return NULL;
 
        else
                return NULL;
 

-       /* /sys/dev/{block,char}/<maj>:<min> link */
-       snprintf(path, sizeof(path), "%s/dev/%s/%u:%u", udev_get_sys_path(udev),
-                type_str, major(devnum), minor(devnum));
-       if (util_resolve_sys_link(udev, path, sizeof(path)) == 0)
-               return udev_device_new_from_syspath(udev, path);
-
-       udev_enumerate = udev_enumerate_new(udev);
-       if (udev_enumerate == NULL)
-               return NULL;
-
-       /* fallback to search sys devices for the major/minor */
-       if (type == 'b')
-               udev_enumerate_add_match_subsystem(udev_enumerate, "block");
-       else if (type == 'c')
-               udev_enumerate_add_nomatch_subsystem(udev_enumerate, "block");
-       udev_enumerate_scan_devices(udev_enumerate);
-       udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(udev_enumerate)) {
-               struct udev_device *device_loop;
-
-               device_loop = udev_device_new_from_syspath(udev, udev_list_entry_get_name(list_entry));
-               if (device_loop != NULL) {
-                       if (udev_device_get_devnum(device_loop) == devnum) {
-                               if (type == 'b' && strcmp(udev_device_get_subsystem(device_loop), "block") != 0)
-                                       continue;
-                               if (type == 'c' && strcmp(udev_device_get_subsystem(device_loop), "block") == 0)
-                                       continue;
-                               device = device_loop;
-                               break;
-                       }
-                       udev_device_unref(device_loop);
-               }
-       }
-       udev_enumerate_unref(udev_enumerate);
-       return device;
+       /* use /sys/dev/{block,char}/<maj>:<min> link */
+       snprintf(path, sizeof(path), "%s/dev/%s/%u:%u",
+                udev_get_sys_path(udev), type_str, major(devnum), minor(devnum));
+       return udev_device_new_from_syspath(udev, path);

 }
 
 /**
  * udev_device_new_from_subsystem_sysname:
  * @udev: udev library context
 }
 
 /**
  * udev_device_new_from_subsystem_sysname:
  * @udev: udev library context

- * @subsystem: the subsytem of the device
+ * @subsystem: the subsystem of the device

  * @sysname: the name of the device
  *
  * Create new udev device, and fill in information from the sys
  * device and the udev database entry. The device is looked up
  * @sysname: the name of the device
  *
  * Create new udev device, and fill in information from the sys
  * device and the udev database entry. The device is looked up

- * by the subsytem and name string of the device, like "mem",
+ * by the subsystem and name string of the device, like "mem",

  * "zero", or "block", "sda".
  *
  * The initial refcount is 1, and needs to be decremented to
  * "zero", or "block", "sda".
  *
  * The initial refcount is 1, and needs to be decremented to


@@ -506,20 +457,9 @@ static struct udev_device *device_new_from_parent(struct udev_device *udev_devic
        char path[UTIL_PATH_SIZE];
        const char *subdir;
 
        char path[UTIL_PATH_SIZE];
        const char *subdir;
 

-       /* follow "device" link in deprecated sys layout */
-       if (strncmp(udev_device->devpath, "/class/", 7) == 0 ||
-           strncmp(udev_device->devpath, "/block/", 7) == 0) {
-               util_strscpyl(path, sizeof(path), udev_device->syspath, "/device", NULL);
-               if (util_resolve_sys_link(udev_device->udev, path, sizeof(path)) == 0) {
-                       udev_device_parent = udev_device_new_from_syspath(udev_device->udev, path);
-                       if (udev_device_parent != NULL)
-                               return udev_device_parent;
-               }
-       }
-

        util_strscpy(path, sizeof(path), udev_device->syspath);
        subdir = &path[strlen(udev_get_sys_path(udev_device->udev))+1];
        util_strscpy(path, sizeof(path), udev_device->syspath);
        subdir = &path[strlen(udev_get_sys_path(udev_device->udev))+1];

-       while (1) {
+       for (;;) {

                char *pos;
 
                pos = strrchr(subdir, '/');
                char *pos;
 
                pos = strrchr(subdir, '/');


@@ -544,7 +484,7 @@ static struct udev_device *device_new_from_parent(struct udev_device *udev_devic
  * child device, and will be cleaned up when the child device
  * is cleaned up.
  *
  * child device, and will be cleaned up when the child device
  * is cleaned up.
  *

- * It is not neccessarily just the upper level directory, empty or not
+ * It is not necessarily just the upper level directory, empty or not

  * recognized sys directories are ignored.
  *
  * It can be called as many times as needed, without caring about
  * recognized sys directories are ignored.
  *
  * It can be called as many times as needed, without caring about


@@ -568,13 +508,16 @@ struct udev_device *udev_device_get_parent(struct udev_device *udev_device)
 /**
  * udev_device_get_parent_with_subsystem_devtype:
  * @udev_device: udev device to start searching from
 /**
  * udev_device_get_parent_with_subsystem_devtype:
  * @udev_device: udev device to start searching from

- * @subsystem: the subsytem of the device
+ * @subsystem: the subsystem of the device

  * @devtype: the type (DEVTYPE) of the device
  *
  * Find the next parent device, with a matching subsystem and devtype
  * value, and fill in information from the sys device and the udev
  * database entry.
  *
  * @devtype: the type (DEVTYPE) of the device
  *
  * Find the next parent device, with a matching subsystem and devtype
  * value, and fill in information from the sys device and the udev
  * database entry.
  *

+ * If devtype is #NULL, only subsystem is checked, and any devtype will
+ * match.
+ *

  * The returned the device is not referenced. It is attached to the
  * child device, and will be cleaned up when the child device
  * is cleaned up.
  * The returned the device is not referenced. It is attached to the
  * child device, and will be cleaned up when the child device
  * is cleaned up.


@@ -582,7 +525,7 @@ struct udev_device *udev_device_get_parent(struct udev_device *udev_device)
  * It can be called as many times as needed, without caring about
  * references.
  *
  * It can be called as many times as needed, without caring about
  * references.
  *

- * Returns: a new udev device, or #NULL, if no matching parent exists.
+ * Returns: a new udev device, or #NULL if no matching parent exists.

  **/
 struct udev_device *udev_device_get_parent_with_subsystem_devtype(struct udev_device *udev_device, const char *subsystem, const char *devtype)
 {
  **/
 struct udev_device *udev_device_get_parent_with_subsystem_devtype(struct udev_device *udev_device, const char *subsystem, const char *devtype)
 {


@@ -667,6 +610,7 @@ void udev_device_unref(struct udev_device *udev_device)
        free(udev_device->action);
        free(udev_device->driver);
        free(udev_device->devpath_old);
        free(udev_device->action);
        free(udev_device->driver);
        free(udev_device->devpath_old);

+       free(udev_device->sysname_old);

        free(udev_device->knodename);
        udev_list_cleanup_entries(udev_device->udev, &udev_device->sysattr_list);
        free(udev_device->envp);
        free(udev_device->knodename);
        udev_list_cleanup_entries(udev_device->udev, &udev_device->sysattr_list);
        free(udev_device->envp);


@@ -768,7 +712,7 @@ const char *udev_device_get_subsystem(struct udev_device *udev_device)
                return NULL;
        if (!udev_device->subsystem_set) {
                udev_device->subsystem_set = 1;
                return NULL;
        if (!udev_device->subsystem_set) {
                udev_device->subsystem_set = 1;

-               /* read "subsytem" link */
+               /* read "subsystem" link */

                if (util_get_sys_subsystem(udev_device->udev, udev_device->syspath, subsystem, sizeof(subsystem)) > 0) {
                        udev_device_set_subsystem(udev_device, subsystem);
                        return udev_device->subsystem;
                if (util_get_sys_subsystem(udev_device->udev, udev_device->syspath, subsystem, sizeof(subsystem)) > 0) {
                        udev_device_set_subsystem(udev_device, subsystem);
                        return udev_device->subsystem;


@@ -882,7 +826,7 @@ struct udev_list_entry *udev_device_get_properties_list_entry(struct udev_device
  * udev_device_get_driver:
  * @udev_device: udev device
  *
  * udev_device_get_driver:
  * @udev_device: udev device
  *

- * Returns: the driver string or #NULL, if ther is no driver attached.
+ * Returns: the driver string, or #NULL if there is no driver attached.

  **/
 const char *udev_device_get_driver(struct udev_device *udev_device)
 {
  **/
 const char *udev_device_get_driver(struct udev_device *udev_device)
 {


@@ -951,7 +895,7 @@ unsigned long long int udev_device_get_seqnum(struct udev_device *udev_device)
  * @udev_device: udev device
  * @sysattr: attribute name
  *
  * @udev_device: udev device
  * @sysattr: attribute name
  *

- * The retrieved value is cached in the device. Repeated reads will return the same
+ * The retrieved value is cached in the device. Repeated calls will return the same

  * value and not open the attribute again.
  *
  * Returns: the content of a sys attribute file, or #NULL if there is no sys attribute value.
  * value and not open the attribute again.
  *
  * Returns: the content of a sys attribute file, or #NULL if there is no sys attribute value.


@@ -1115,11 +1059,16 @@ int udev_device_set_devnode(struct udev_device *udev_device, const char *devnode
        return 0;
 }
 
        return 0;
 }
 

-int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink)
+int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink, int unique)

 {
 {

+       struct udev_list_entry *list_entry;
+

        udev_device->devlinks_uptodate = 0;
        udev_device->devlinks_uptodate = 0;

-       if (udev_list_entry_add(udev_device->udev, &udev_device->devlinks_list, devlink, NULL, 1, 0) == NULL)
+       list_entry = udev_list_entry_add(udev_device->udev, &udev_device->devlinks_list, devlink, NULL, 1, 0);
+       if (list_entry == NULL)

                return -ENOMEM;
                return -ENOMEM;

+       if (unique)
+               udev_list_entry_set_flag(list_entry, 1);

        return 0;
 }
 
        return 0;
 }
 


@@ -1201,17 +1150,25 @@ static int update_envp_monitor_buf(struct udev_device *udev_device)
        s = udev_device->monitor_buf;
        l = MONITOR_BUF_SIZE;
        udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(udev_device)) {
        s = udev_device->monitor_buf;
        l = MONITOR_BUF_SIZE;
        udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(udev_device)) {

+               const char *key;
+
+               key = udev_list_entry_get_name(list_entry);
+               /* skip private variables */
+               if (key[0] == '.')
+                       continue;
+

                /* add string to envp array */
                udev_device->envp[i++] = s;
                if (i+1 >= ENVP_SIZE)
                        return -EINVAL;
 
                /* add property string to monitor buffer */
                /* add string to envp array */
                udev_device->envp[i++] = s;
                if (i+1 >= ENVP_SIZE)
                        return -EINVAL;
 
                /* add property string to monitor buffer */

-               l = util_strpcpyl(&s, l, udev_list_entry_get_name(list_entry), "=",
-                                 udev_list_entry_get_value(list_entry), NULL);
+               l = util_strpcpyl(&s, l, key, "=", udev_list_entry_get_value(list_entry), NULL);

                if (l == 0)
                        return -EINVAL;
                if (l == 0)
                        return -EINVAL;

+               /* advance past the trailing '\0' that util_strpcpyl() guarantees */

                s++;
                s++;

+               l--;

        }
        udev_device->envp[i] = NULL;
        udev_device->monitor_buf_len = s - udev_device->monitor_buf;
        }
        udev_device->envp[i] = NULL;
        udev_device->monitor_buf_len = s - udev_device->monitor_buf;


@@ -1266,13 +1223,39 @@ const char *udev_device_get_devpath_old(struct udev_device *udev_device)
 
 int udev_device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old)
 {
 
 int udev_device_set_devpath_old(struct udev_device *udev_device, const char *devpath_old)
 {

+       const char *pos;
+       size_t len;
+
+       free(udev_device->devpath_old);

        udev_device->devpath_old = strdup(devpath_old);
        if (udev_device->devpath_old == NULL)
                return -ENOMEM;
        udev_device_add_property(udev_device, "DEVPATH_OLD", udev_device->devpath_old);
        udev_device->devpath_old = strdup(devpath_old);
        if (udev_device->devpath_old == NULL)
                return -ENOMEM;
        udev_device_add_property(udev_device, "DEVPATH_OLD", udev_device->devpath_old);

+
+       pos = strrchr(udev_device->devpath_old, '/');
+       if (pos == NULL)
+               return -EINVAL;
+       udev_device->sysname_old = strdup(&pos[1]);
+       if (udev_device->sysname_old == NULL)
+               return -ENOMEM;
+
+       /* some devices have '!' in their name, change that to '/' */
+       len = 0;
+       while (udev_device->sysname_old[len] != '\0') {
+               if (udev_device->sysname_old[len] == '!')
+                       udev_device->sysname_old[len] = '/';
+               len++;
+       }

        return 0;
 }
 
        return 0;
 }
 

+const char *udev_device_get_sysname_old(struct udev_device *udev_device)
+{
+       if (udev_device == NULL)
+               return NULL;
+       return udev_device->sysname_old;
+}
+

 const char *udev_device_get_knodename(struct udev_device *udev_device)
 {
        return udev_device->knodename;
 const char *udev_device_get_knodename(struct udev_device *udev_device)
 {
        return udev_device->knodename;


@@ -1280,9 +1263,11 @@ const char *udev_device_get_knodename(struct udev_device *udev_device)
 
 int udev_device_set_knodename(struct udev_device *udev_device, const char *knodename)
 {
 
 int udev_device_set_knodename(struct udev_device *udev_device, const char *knodename)
 {

+       free(udev_device->knodename);

        udev_device->knodename = strdup(knodename);
        if (udev_device->knodename == NULL)
                return -ENOMEM;
        udev_device->knodename = strdup(knodename);
        if (udev_device->knodename == NULL)
                return -ENOMEM;

+       udev_device_add_property(udev_device, "DEVNAME", udev_device->knodename);

        return 0;
 }
 
        return 0;
 }