-/*
- * libudev - interface to udev device information
- *
- * Copyright (C) 2008-2010 Kay Sievers <kay.sievers@vrfy.org>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- */
+/***
+ This file is part of systemd.
+
+ Copyright 2008-2012 Kay Sievers <kay@vrfy.org>
+
+ systemd is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ systemd is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
#include <stdio.h>
#include <stdlib.h>
#include "libudev.h"
#include "libudev-private.h"
+static int udev_device_set_devnode(struct udev_device *udev_device, const char *devnode);
+
/**
* 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
+ * filesystem. Devices usually belong to a kernel subsystem, and have
* a unique name inside that subsystem.
*/
const char *sysnum;
char *devnode;
mode_t devnode_mode;
+ uid_t devnode_uid;
+ gid_t devnode_gid;
char *subsystem;
char *devtype;
char *driver;
struct udev_list sysattr_list;
struct udev_list tags_list;
unsigned long long int seqnum;
- unsigned long long int usec_initialized;
+ usec_t usec_initialized;
int devlink_priority;
int refcount;
dev_t devnum;
* udev_device_get_devnum:
* @udev_device: udev device
*
- * Returns: the device major/minor number.
+ * Get the device major/minor number.
+ *
+ * Returns: the dev_t number.
**/
_public_ dev_t udev_device_get_devnum(struct udev_device *udev_device)
{
* udev_device_get_driver:
* @udev_device: udev device
*
- * Returns: the driver string, or #NULL if there is no driver attached.
+ * Get the kernel driver name.
+ *
+ * Returns: the driver name string, or #NULL if there is no driver attached.
**/
_public_ const char *udev_device_get_driver(struct udev_device *udev_device)
{
return 0;
}
-static int udev_device_set_subsystem(struct udev_device *udev_device, const char *subsystem)
+int udev_device_set_subsystem(struct udev_device *udev_device, const char *subsystem)
{
free(udev_device->subsystem);
udev_device->subsystem = strdup(subsystem);
return udev_device->subsystem;
}
/* implicit names */
- if (strncmp(udev_device->devpath, "/module/", 8) == 0) {
+ if (startswith(udev_device->devpath, "/module/")) {
udev_device_set_subsystem(udev_device, "module");
return udev_device->subsystem;
}
udev_device_set_subsystem(udev_device, "drivers");
return udev_device->subsystem;
}
- if (strncmp(udev_device->devpath, "/subsystem/", 11) == 0 ||
- strncmp(udev_device->devpath, "/class/", 7) == 0 ||
- strncmp(udev_device->devpath, "/bus/", 5) == 0) {
+ if (startswith(udev_device->devpath, "/subsystem/") ||
+ startswith(udev_device->devpath, "/class/") ||
+ startswith(udev_device->devpath, "/bus/")) {
udev_device_set_subsystem(udev_device, "subsystem");
return udev_device->subsystem;
}
return 0;
}
+uid_t udev_device_get_devnode_uid(struct udev_device *udev_device)
+{
+ if (!udev_device->info_loaded)
+ udev_device_read_uevent_file(udev_device);
+ return udev_device->devnode_uid;
+}
+
+static int udev_device_set_devnode_uid(struct udev_device *udev_device, uid_t uid)
+{
+ char num[32];
+
+ udev_device->devnode_uid = uid;
+ snprintf(num, sizeof(num), "%u", uid);
+ udev_device_add_property(udev_device, "DEVUID", num);
+ return 0;
+}
+
+gid_t udev_device_get_devnode_gid(struct udev_device *udev_device)
+{
+ if (!udev_device->info_loaded)
+ udev_device_read_uevent_file(udev_device);
+ return udev_device->devnode_gid;
+}
+
+static int udev_device_set_devnode_gid(struct udev_device *udev_device, gid_t gid)
+{
+ char num[32];
+
+ udev_device->devnode_gid = gid;
+ snprintf(num, sizeof(num), "%u", gid);
+ udev_device_add_property(udev_device, "DEVGID", num);
+ return 0;
+}
+
struct udev_list_entry *udev_device_add_property(struct udev_device *udev_device, const char *key, const char *value)
{
udev_device->envp_uptodate = false;
char name[UTIL_LINE_SIZE];
char *val;
- util_strscpy(name, sizeof(name), property);
+ strscpy(name, sizeof(name), property);
val = strchr(name, '=');
if (val == NULL)
return NULL;
*/
void udev_device_add_property_from_string_parse(struct udev_device *udev_device, const char *property)
{
- if (strncmp(property, "DEVPATH=", 8) == 0) {
+ if (startswith(property, "DEVPATH=")) {
char path[UTIL_PATH_SIZE];
- util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys", &property[8], NULL);
+ strscpyl(path, sizeof(path), "/sys", &property[8], NULL);
udev_device_set_syspath(udev_device, path);
- } else if (strncmp(property, "SUBSYSTEM=", 10) == 0) {
+ } else if (startswith(property, "SUBSYSTEM=")) {
udev_device_set_subsystem(udev_device, &property[10]);
- } else if (strncmp(property, "DEVTYPE=", 8) == 0) {
+ } else if (startswith(property, "DEVTYPE=")) {
udev_device_set_devtype(udev_device, &property[8]);
- } else if (strncmp(property, "DEVNAME=", 8) == 0) {
+ } else if (startswith(property, "DEVNAME=")) {
udev_device_set_devnode(udev_device, &property[8]);
- } else if (strncmp(property, "DEVLINKS=", 9) == 0) {
+ } else if (startswith(property, "DEVLINKS=")) {
char devlinks[UTIL_PATH_SIZE];
char *slink;
char *next;
- util_strscpy(devlinks, sizeof(devlinks), &property[9]);
+ strscpy(devlinks, sizeof(devlinks), &property[9]);
slink = devlinks;
next = strchr(slink, ' ');
while (next != NULL) {
next[0] = '\0';
- udev_device_add_devlink(udev_device, slink, 0);
+ udev_device_add_devlink(udev_device, slink);
slink = &next[1];
next = strchr(slink, ' ');
}
if (slink[0] != '\0')
- udev_device_add_devlink(udev_device, slink, 0);
- } else if (strncmp(property, "TAGS=", 5) == 0) {
+ udev_device_add_devlink(udev_device, slink);
+ } else if (startswith(property, "TAGS=")) {
char tags[UTIL_PATH_SIZE];
char *next;
- util_strscpy(tags, sizeof(tags), &property[5]);
+ strscpy(tags, sizeof(tags), &property[5]);
next = strchr(tags, ':');
if (next != NULL) {
next++;
udev_device_add_tag(udev_device, tag);
}
}
- } else if (strncmp(property, "USEC_INITIALIZED=", 19) == 0) {
+ } else if (startswith(property, "USEC_INITIALIZED=")) {
udev_device_set_usec_initialized(udev_device, strtoull(&property[19], NULL, 10));
- } else if (strncmp(property, "DRIVER=", 7) == 0) {
+ } else if (startswith(property, "DRIVER=")) {
udev_device_set_driver(udev_device, &property[7]);
- } else if (strncmp(property, "ACTION=", 7) == 0) {
+ } else if (startswith(property, "ACTION=")) {
udev_device_set_action(udev_device, &property[7]);
- } else if (strncmp(property, "MAJOR=", 6) == 0) {
+ } else if (startswith(property, "MAJOR=")) {
udev_device->maj = strtoull(&property[6], NULL, 10);
- } else if (strncmp(property, "MINOR=", 6) == 0) {
+ } else if (startswith(property, "MINOR=")) {
udev_device->min = strtoull(&property[6], NULL, 10);
- } else if (strncmp(property, "DEVPATH_OLD=", 12) == 0) {
+ } else if (startswith(property, "DEVPATH_OLD=")) {
udev_device_set_devpath_old(udev_device, &property[12]);
- } else if (strncmp(property, "SEQNUM=", 7) == 0) {
+ } else if (startswith(property, "SEQNUM=")) {
udev_device_set_seqnum(udev_device, strtoull(&property[7], NULL, 10));
- } else if (strncmp(property, "IFINDEX=", 8) == 0) {
+ } else if (startswith(property, "IFINDEX=")) {
udev_device_set_ifindex(udev_device, strtoull(&property[8], NULL, 10));
- } else if (strncmp(property, "DEVMODE=", 8) == 0) {
+ } else if (startswith(property, "DEVMODE=")) {
udev_device_set_devnode_mode(udev_device, strtoul(&property[8], NULL, 8));
+ } else if (startswith(property, "DEVUID=")) {
+ udev_device_set_devnode_uid(udev_device, strtoul(&property[7], NULL, 10));
+ } else if (startswith(property, "DEVGID=")) {
+ udev_device_set_devnode_gid(udev_device, strtoul(&property[7], NULL, 10));
} else {
udev_device_add_property_from_string(udev_device, property);
}
* @udev_device: udev device
* @key: property name
*
- * Returns: the value of a device property, or #NULL if there is no such property.
+ * Get the value of a given property.
+ *
+ * Returns: the property string, or #NULL if there is no such property.
**/
_public_ const char *udev_device_get_property_value(struct udev_device *udev_device, const char *key)
{
id = udev_device_get_id_filename(udev_device);
if (id == NULL)
return -1;
- util_strscpyl(filename, sizeof(filename), TEST_PREFIX "/run/udev/data/", id, NULL);
+ strscpyl(filename, sizeof(filename), "/run/udev/data/", id, NULL);
dbfile = filename;
}
f = fopen(dbfile, "re");
if (f == NULL) {
- dbg(udev_device->udev, "no db file to read %s: %m\n", dbfile);
- return -1;
+ udev_dbg(udev_device->udev, "no db file to read %s: %m\n", dbfile);
+ return -errno;
}
+
+ /* devices with a database entry are initialized */
udev_device->is_initialized = true;
while (fgets(line, sizeof(line), f)) {
val = &line[2];
switch(line[0]) {
case 'S':
- util_strscpyl(filename, sizeof(filename), TEST_PREFIX "/dev/", val, NULL);
- udev_device_add_devlink(udev_device, filename, 0);
+ strscpyl(filename, sizeof(filename), "/dev/", val, NULL);
+ udev_device_add_devlink(udev_device, filename);
break;
case 'L':
udev_device_set_devlink_priority(udev_device, atoi(val));
}
fclose(f);
- dbg(udev_device->udev, "device %p filled with db file data\n", udev_device);
+ udev_dbg(udev_device->udev, "device %p filled with db file data\n", udev_device);
return 0;
}
if (udev_device->uevent_loaded)
return 0;
- util_strscpyl(filename, sizeof(filename), udev_device->syspath, "/uevent", NULL);
+ strscpyl(filename, sizeof(filename), udev_device->syspath, "/uevent", NULL);
f = fopen(filename, "re");
if (f == NULL)
- return -1;
+ return -errno;
udev_device->uevent_loaded = true;
while (fgets(line, sizeof(line), f)) {
continue;
pos[0] = '\0';
- if (strncmp(line, "DEVTYPE=", 8) == 0) {
+ if (startswith(line, "DEVTYPE=")) {
udev_device_set_devtype(udev_device, &line[8]);
continue;
}
- if (strncmp(line, "IFINDEX=", 8) == 0) {
+ if (startswith(line, "IFINDEX=")) {
udev_device_set_ifindex(udev_device, strtoull(&line[8], NULL, 10));
continue;
}
- if (strncmp(line, "DEVNAME=", 8) == 0) {
+ if (startswith(line, "DEVNAME=")) {
udev_device_set_devnode(udev_device, &line[8]);
continue;
}
- if (strncmp(line, "MAJOR=", 6) == 0)
+ if (startswith(line, "MAJOR="))
maj = strtoull(&line[6], NULL, 10);
- else if (strncmp(line, "MINOR=", 6) == 0)
+ else if (startswith(line, "MINOR="))
min = strtoull(&line[6], NULL, 10);
- else if (strncmp(line, "DEVMODE=", 8) == 0)
+ else if (startswith(line, "DEVMODE="))
udev_device->devnode_mode = strtoul(&line[8], NULL, 8);
udev_device_add_property_from_string(udev_device, line);
struct udev_device *udev_device;
struct udev_list_entry *list_entry;
- if (udev == NULL)
+ if (udev == NULL) {
+ errno = EINVAL;
return NULL;
+ }
- udev_device = calloc(1, sizeof(struct udev_device));
- if (udev_device == NULL)
+ udev_device = new0(struct udev_device, 1);
+ if (udev_device == NULL) {
+ errno = ENOMEM;
return NULL;
+ }
udev_device->refcount = 1;
udev_device->udev = udev;
udev_list_init(udev, &udev_device->devlinks_list, true);
struct stat statbuf;
struct udev_device *udev_device;
- if (udev == NULL)
+ if (udev == NULL) {
+ errno = EINVAL;
return NULL;
- if (syspath == NULL)
+ }
+
+ if (syspath == NULL) {
+ errno = EINVAL;
return NULL;
+ }
/* path starts in sys */
- if (strncmp(syspath, TEST_PREFIX "/sys", strlen(TEST_PREFIX "/sys")) != 0) {
- dbg(udev, "not in sys :%s\n", syspath);
+ if (!startswith(syspath, "/sys")) {
+ udev_dbg(udev, "not in sys :%s\n", syspath);
+ errno = EINVAL;
return NULL;
}
/* path is not a root directory */
- subdir = syspath + strlen(TEST_PREFIX "/sys");
+ subdir = syspath + strlen("/sys");
pos = strrchr(subdir, '/');
- if (pos == NULL || pos[1] == '\0' || pos < &subdir[2])
+ if (pos == NULL || pos[1] == '\0' || pos < &subdir[2]) {
+ errno = EINVAL;
return NULL;
+ }
/* resolve possible symlink to real path */
- util_strscpy(path, sizeof(path), syspath);
+ strscpy(path, sizeof(path), syspath);
util_resolve_sys_link(udev, path, sizeof(path));
- if (strncmp(path + strlen(TEST_PREFIX "/sys"), "/devices/", 9) == 0) {
+ if (startswith(path + strlen("/sys"), "/devices/")) {
char file[UTIL_PATH_SIZE];
/* all "devices" require a "uevent" file */
- util_strscpyl(file, sizeof(file), path, "/uevent", NULL);
+ strscpyl(file, sizeof(file), path, "/uevent", NULL);
if (stat(file, &statbuf) != 0)
return NULL;
} else {
return NULL;
udev_device_set_syspath(udev_device, path);
- dbg(udev, "device %p has devpath '%s'\n", udev_device, udev_device_get_devpath(udev_device));
+ udev_dbg(udev, "device %p has devpath '%s'\n", udev_device, udev_device_get_devpath(udev_device));
return udev_device;
}
type_str = "block";
else if (type == 'c')
type_str = "char";
- else
+ else {
+ errno = EINVAL;
return NULL;
+ }
/* use /sys/dev/{block,char}/<maj>:<min> link */
- snprintf(path, sizeof(path), TEST_PREFIX "/sys/dev/%s/%u:%u",
+ snprintf(path, sizeof(path), "/sys/dev/%s/%u:%u",
type_str, major(devnum), minor(devnum));
return udev_device_new_from_syspath(udev, path);
}
-struct udev_device *udev_device_new_from_id_filename(struct udev *udev, char *id)
+/**
+ * udev_device_new_from_device_id:
+ * @udev: udev library context
+ * @id: text string identifying a kernel device
+ *
+ * Create new udev device, and fill in information from the sys
+ * device and the udev database entry. The device is looked-up
+ * by a special string:
+ * b8:2 - block device major:minor
+ * c128:1 - char device major:minor
+ * n3 - network device ifindex
+ * +sound:card29 - kernel driver core subsystem:device name
+ *
+ * The initial refcount is 1, and needs to be decremented to
+ * release the resources of the udev device.
+ *
+ * Returns: a new udev device, or #NULL, if it does not exist
+ **/
+_public_ struct udev_device *udev_device_new_from_device_id(struct udev *udev, const char *id)
{
char type;
int maj, min;
int ifindex;
ifindex = strtoul(&id[1], NULL, 10);
- if (ifindex <= 0)
+ if (ifindex <= 0) {
+ errno = EINVAL;
return NULL;
+ }
sk = socket(PF_INET, SOCK_DGRAM, 0);
if (sk < 0)
return NULL;
- memset(&ifr, 0x00, sizeof(struct ifreq));
+ memzero(&ifr, sizeof(struct ifreq));
ifr.ifr_ifindex = ifindex;
if (ioctl(sk, SIOCGIFNAME, &ifr) != 0) {
close(sk);
return NULL;
if (udev_device_get_ifindex(dev) == ifindex)
return dev;
+
+ /* this is racy, so we may end up with the wrong device */
udev_device_unref(dev);
+ errno = ENODEV;
return NULL;
}
case '+':
- util_strscpy(subsys, sizeof(subsys), &id[1]);
+ strscpy(subsys, sizeof(subsys), &id[1]);
sysname = strchr(subsys, ':');
- if (sysname == NULL)
+ if (sysname == NULL) {
+ errno = EINVAL;
return NULL;
+ }
sysname[0] = '\0';
sysname = &sysname[1];
return udev_device_new_from_subsystem_sysname(udev, subsys, sysname);
default:
+ errno = EINVAL;
return NULL;
}
}
char path[UTIL_PATH_SIZE];
struct stat statbuf;
- if (strcmp(subsystem, "subsystem") == 0) {
- util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/subsystem/", sysname, NULL);
+ if (streq(subsystem, "subsystem")) {
+ strscpyl(path, sizeof(path), "/sys/subsystem/", sysname, NULL);
if (stat(path, &statbuf) == 0)
goto found;
- util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/bus/", sysname, NULL);
+ strscpyl(path, sizeof(path), "/sys/bus/", sysname, NULL);
if (stat(path, &statbuf) == 0)
goto found;
- util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/class/", sysname, NULL);
+ strscpyl(path, sizeof(path), "/sys/class/", sysname, NULL);
if (stat(path, &statbuf) == 0)
goto found;
goto out;
}
- if (strcmp(subsystem, "module") == 0) {
- util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/module/", sysname, NULL);
+ if (streq(subsystem, "module")) {
+ strscpyl(path, sizeof(path), "/sys/module/", sysname, NULL);
if (stat(path, &statbuf) == 0)
goto found;
goto out;
}
- if (strcmp(subsystem, "drivers") == 0) {
+ if (streq(subsystem, "drivers")) {
char subsys[UTIL_NAME_SIZE];
char *driver;
- util_strscpy(subsys, sizeof(subsys), sysname);
+ strscpy(subsys, sizeof(subsys), sysname);
driver = strchr(subsys, ':');
if (driver != NULL) {
driver[0] = '\0';
driver = &driver[1];
- util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/subsystem/", subsys, "/drivers/", driver, NULL);
+ strscpyl(path, sizeof(path), "/sys/subsystem/", subsys, "/drivers/", driver, NULL);
if (stat(path, &statbuf) == 0)
goto found;
- util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/bus/", subsys, "/drivers/", driver, NULL);
+ strscpyl(path, sizeof(path), "/sys/bus/", subsys, "/drivers/", driver, NULL);
if (stat(path, &statbuf) == 0)
goto found;
- }
+ } else
+ errno = EINVAL;
+
goto out;
}
- util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/subsystem/", subsystem, "/devices/", sysname, NULL);
+ strscpyl(path, sizeof(path), "/sys/subsystem/", subsystem, "/devices/", sysname, NULL);
if (stat(path, &statbuf) == 0)
goto found;
- util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/bus/", subsystem, "/devices/", sysname, NULL);
+ strscpyl(path, sizeof(path), "/sys/bus/", subsystem, "/devices/", sysname, NULL);
if (stat(path, &statbuf) == 0)
goto found;
- util_strscpyl(path, sizeof(path), TEST_PREFIX "/sys/class/", subsystem, "/", sysname, NULL);
+ strscpyl(path, sizeof(path), "/sys/class/", subsystem, "/", sysname, NULL);
if (stat(path, &statbuf) == 0)
goto found;
out:
udev_device_add_property_from_string_parse(udev_device, environ[i]);
if (udev_device_add_property_from_string_parse_finish(udev_device) < 0) {
- dbg(udev, "missing values, invalid device\n");
+ udev_dbg(udev, "missing values, invalid device\n");
udev_device_unref(udev_device);
udev_device = NULL;
}
char path[UTIL_PATH_SIZE];
const char *subdir;
- util_strscpy(path, sizeof(path), udev_device->syspath);
- subdir = path + strlen(TEST_PREFIX "/sys/");
+ strscpy(path, sizeof(path), udev_device->syspath);
+ subdir = path + strlen("/sys/");
for (;;) {
char *pos;
if (udev_device_parent != NULL)
return udev_device_parent;
}
+
+ errno = ENOENT;
return NULL;
}
* Find the next parent device, and fill in information from the sys
* device and the udev database entry.
*
- * 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.
+ * Returned device is not referenced. It is attached to the child
+ * device, and will be cleaned up when the child device is cleaned up.
*
* It is not necessarily just the upper level directory, empty or not
* recognized sys directories are ignored.
**/
_public_ struct udev_device *udev_device_get_parent(struct udev_device *udev_device)
{
- if (udev_device == NULL)
+ if (udev_device == NULL) {
+ errno = EINVAL;
return NULL;
+ }
if (!udev_device->parent_set) {
udev_device->parent_set = true;
udev_device->parent_device = device_new_from_parent(udev_device);
* 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.
+ * Returned device is not referenced. It is attached to the child
+ * device, and will be cleaned up when the child device is cleaned up.
*
* It can be called as many times as needed, without caring about
* references.
{
struct udev_device *parent;
- if (subsystem == NULL)
+ if (subsystem == NULL) {
+ errno = EINVAL;
return NULL;
+ }
parent = udev_device_get_parent(udev_device);
while (parent != NULL) {
const char *parent_devtype;
parent_subsystem = udev_device_get_subsystem(parent);
- if (parent_subsystem != NULL && strcmp(parent_subsystem, subsystem) == 0) {
+ if (parent_subsystem != NULL && streq(parent_subsystem, subsystem)) {
if (devtype == NULL)
break;
parent_devtype = udev_device_get_devtype(parent);
- if (parent_devtype != NULL && strcmp(parent_devtype, devtype) == 0)
+ if (parent_devtype != NULL && streq(parent_devtype, devtype))
break;
}
parent = udev_device_get_parent(parent);
}
+
+ if (!parent)
+ errno = ENOENT;
+
return parent;
}
* Drop a reference of a udev device. If the refcount reaches zero,
* the resources of the device will be released.
*
+ * Returns: #NULL
**/
-_public_ void udev_device_unref(struct udev_device *udev_device)
+_public_ struct udev_device *udev_device_unref(struct udev_device *udev_device)
{
if (udev_device == NULL)
- return;
+ return NULL;
udev_device->refcount--;
if (udev_device->refcount > 0)
- return;
+ return NULL;
if (udev_device->parent_device != NULL)
udev_device_unref(udev_device->parent_device);
free(udev_device->syspath);
free(udev_device->envp);
free(udev_device->monitor_buf);
free(udev_device);
+ return NULL;
}
/**
* udev_device_get_sysname:
* @udev_device: udev device
*
- * Returns: the sys name of the device device
+ * Get the kernel device name in /sys.
+ *
+ * Returns: the name string of the device device
**/
_public_ const char *udev_device_get_sysname(struct udev_device *udev_device)
{
* udev_device_get_sysnum:
* @udev_device: udev device
*
- * Returns: the trailing number of of the device name
+ * Get the instance number of the device.
+ *
+ * Returns: the trailing number string of the device name
**/
_public_ const char *udev_device_get_sysnum(struct udev_device *udev_device)
{
size_t l;
s = symlinks;
- l = util_strpcpyl(&s, sizeof(symlinks), udev_list_entry_get_name(list_entry), NULL);
+ l = strpcpyl(&s, sizeof(symlinks), udev_list_entry_get_name(list_entry), NULL);
udev_list_entry_foreach(list_entry, udev_list_entry_get_next(list_entry))
- l = util_strpcpyl(&s, l, " ", udev_list_entry_get_name(list_entry), NULL);
+ l = strpcpyl(&s, l, " ", udev_list_entry_get_name(list_entry), NULL);
udev_device_add_property(udev_device, "DEVLINKS", symlinks);
}
}
size_t l;
s = tags;
- l = util_strpcpyl(&s, sizeof(tags), ":", NULL);
+ l = strpcpyl(&s, sizeof(tags), ":", NULL);
udev_list_entry_foreach(list_entry, udev_device_get_tags_list_entry(udev_device))
- l = util_strpcpyl(&s, l, udev_list_entry_get_name(list_entry), ":", NULL);
+ l = strpcpyl(&s, l, udev_list_entry_get_name(list_entry), ":", NULL);
udev_device_add_property(udev_device, "TAGS", tags);
}
}
**/
_public_ unsigned long long int udev_device_get_usec_since_initialized(struct udev_device *udev_device)
{
- unsigned long long now;
+ usec_t now_ts;
if (udev_device == NULL)
return 0;
udev_device_read_db(udev_device, NULL);
if (udev_device->usec_initialized == 0)
return 0;
- now = now_usec();
- if (now == 0)
+ now_ts = now(CLOCK_MONOTONIC);
+ if (now_ts == 0)
return 0;
- return now - udev_device->usec_initialized;
+ return now_ts - udev_device->usec_initialized;
}
-unsigned long long udev_device_get_usec_initialized(struct udev_device *udev_device)
+usec_t udev_device_get_usec_initialized(struct udev_device *udev_device)
{
return udev_device->usec_initialized;
}
-void udev_device_set_usec_initialized(struct udev_device *udev_device, unsigned long long usec_initialized)
+void udev_device_set_usec_initialized(struct udev_device *udev_device, usec_t usec_initialized)
{
char num[32];
udev_device->usec_initialized = usec_initialized;
- snprintf(num, sizeof(num), "%llu", usec_initialized);
+ snprintf(num, sizeof(num), USEC_FMT, usec_initialized);
udev_device_add_property(udev_device, "USEC_INITIALIZED", num);
}
if (list_entry != NULL)
return udev_list_entry_get_value(list_entry);
- util_strscpyl(path, sizeof(path), udev_device_get_syspath(udev_device), "/", sysattr, NULL);
+ strscpyl(path, sizeof(path), udev_device_get_syspath(udev_device), "/", sysattr, NULL);
if (lstat(path, &statbuf) != 0) {
udev_list_entry_add(&udev_device->sysattr_value_list, sysattr, NULL);
goto out;
}
if (S_ISLNK(statbuf.st_mode)) {
- struct udev_device *dev;
-
/*
* Some core links return only the last element of the target path,
* these are just values, the paths should not be exposed.
*/
- if (strcmp(sysattr, "driver") == 0 ||
- strcmp(sysattr, "subsystem") == 0 ||
- strcmp(sysattr, "module") == 0) {
+ if (streq(sysattr, "driver") ||
+ streq(sysattr, "subsystem") ||
+ streq(sysattr, "module")) {
if (util_get_sys_core_link_value(udev_device->udev, sysattr,
udev_device->syspath, value, sizeof(value)) < 0)
return NULL;
goto out;
}
- /* resolve link to a device and return its syspath */
- util_strscpyl(path, sizeof(path), udev_device->syspath, "/", sysattr, NULL);
- dev = udev_device_new_from_syspath(udev_device->udev, path);
- if (dev != NULL) {
- list_entry = udev_list_entry_add(&udev_device->sysattr_value_list, sysattr,
- udev_device_get_syspath(dev));
- val = udev_list_entry_get_value(list_entry);
- udev_device_unref(dev);
- }
-
goto out;
}
return val;
}
+/**
+ * udev_device_set_sysattr_value:
+ * @udev_device: udev device
+ * @sysattr: attribute name
+ * @value: new value to be set
+ *
+ * Update the contents of the sys attribute and the cached value of the device.
+ *
+ * Returns: Negative error code on failure or 0 on success.
+ **/
+_public_ int udev_device_set_sysattr_value(struct udev_device *udev_device, const char *sysattr, char *value)
+{
+ struct udev_device *dev;
+ char path[UTIL_PATH_SIZE];
+ struct stat statbuf;
+ int fd;
+ ssize_t size, value_len;
+ int ret = 0;
+
+ if (udev_device == NULL)
+ return -EINVAL;
+ dev = udev_device;
+ if (sysattr == NULL)
+ return -EINVAL;
+ if (value == NULL)
+ value_len = 0;
+ else
+ value_len = strlen(value);
+
+ strscpyl(path, sizeof(path), udev_device_get_syspath(dev), "/", sysattr, NULL);
+ if (lstat(path, &statbuf) != 0) {
+ udev_list_entry_add(&dev->sysattr_value_list, sysattr, NULL);
+ ret = -ENXIO;
+ goto out;
+ }
+
+ if (S_ISLNK(statbuf.st_mode)) {
+ ret = -EINVAL;
+ goto out;
+ }
+
+ /* skip directories */
+ if (S_ISDIR(statbuf.st_mode)) {
+ ret = -EISDIR;
+ goto out;
+ }
+
+ /* skip non-readable files */
+ if ((statbuf.st_mode & S_IRUSR) == 0) {
+ ret = -EACCES;
+ goto out;
+ }
+
+ /* Value is limited to 4k */
+ if (value_len > 4096) {
+ ret = -EINVAL;
+ goto out;
+ }
+ util_remove_trailing_chars(value, '\n');
+
+ /* write attribute value */
+ fd = open(path, O_WRONLY|O_CLOEXEC);
+ if (fd < 0) {
+ ret = -errno;
+ goto out;
+ }
+ size = write(fd, value, value_len);
+ close(fd);
+ if (size < 0) {
+ ret = -errno;
+ goto out;
+ }
+ if (size < value_len) {
+ ret = -EIO;
+ goto out;
+ }
+
+ /* wrote a valid value, store it in cache and return it */
+ udev_list_entry_add(&dev->sysattr_value_list, sysattr, value);
+out:
+ if (dev != udev_device)
+ udev_device_unref(dev);
+ return ret;
+}
+
static int udev_device_sysattr_list_read(struct udev_device *udev_device)
{
struct dirent *dent;
int num = 0;
if (udev_device == NULL)
- return -1;
+ return -EINVAL;
if (udev_device->sysattr_list_read)
return 0;
dir = opendir(udev_device_get_syspath(udev_device));
if (!dir)
- return -1;
+ return -errno;
for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
char path[UTIL_PATH_SIZE];
if (dent->d_type != DT_LNK && dent->d_type != DT_REG)
continue;
- util_strscpyl(path, sizeof(path), udev_device_get_syspath(udev_device), "/", dent->d_name, NULL);
+ strscpyl(path, sizeof(path), udev_device_get_syspath(udev_device), "/", dent->d_name, NULL);
if (lstat(path, &statbuf) != 0)
continue;
if ((statbuf.st_mode & S_IRUSR) == 0)
udev_device->syspath = strdup(syspath);
if (udev_device->syspath == NULL)
return -ENOMEM;
- udev_device->devpath = udev_device->syspath + strlen(TEST_PREFIX "/sys");
+ udev_device->devpath = udev_device->syspath + strlen("/sys");
udev_device_add_property(udev_device, "DEVPATH", udev_device->devpath);
pos = strrchr(udev_device->syspath, '/');
return 0;
}
-int udev_device_set_devnode(struct udev_device *udev_device, const char *devnode)
+static int udev_device_set_devnode(struct udev_device *udev_device, const char *devnode)
{
free(udev_device->devnode);
if (devnode[0] != '/') {
- if (asprintf(&udev_device->devnode, TEST_PREFIX "/dev/%s", devnode) < 0)
+ if (asprintf(&udev_device->devnode, "/dev/%s", devnode) < 0)
udev_device->devnode = NULL;
} else {
udev_device->devnode = strdup(devnode);
return 0;
}
-int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink, int unique)
+int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink)
{
struct udev_list_entry *list_entry;
list_entry = udev_list_entry_add(&udev_device->devlinks_list, devlink, NULL);
if (list_entry == NULL)
return -ENOMEM;
- if (unique)
- udev_list_entry_set_num(list_entry, true);
return 0;
}
if (major(udev_device_get_devnum(udev_device)) > 0) {
/* use dev_t -- b259:131072, c254:0 */
if (asprintf(&udev_device->id_filename, "%c%u:%u",
- strcmp(udev_device_get_subsystem(udev_device), "block") == 0 ? 'b' : 'c',
+ streq(udev_device_get_subsystem(udev_device), "block") ? 'b' : 'c',
major(udev_device_get_devnum(udev_device)),
minor(udev_device_get_devnum(udev_device))) < 0)
udev_device->id_filename = NULL;
udev_device->is_initialized = true;
}
+static bool is_valid_tag(const char *tag)
+{
+ return !strchr(tag, ':') && !strchr(tag, ' ');
+}
+
int udev_device_add_tag(struct udev_device *udev_device, const char *tag)
{
- if (strchr(tag, ':') != NULL || strchr(tag, ' ') != NULL)
+ if (!is_valid_tag(tag))
return -EINVAL;
udev_device->tags_uptodate = false;
if (udev_list_entry_add(&udev_device->tags_list, tag, NULL) != NULL)
return -ENOMEM;
}
+void udev_device_remove_tag(struct udev_device *udev_device, const char *tag)
+{
+ struct udev_list_entry *e;
+
+ if (!is_valid_tag(tag))
+ return;
+ e = udev_list_get_entry(&udev_device->tags_list);
+ e = udev_list_entry_get_by_name(e, tag);
+ if (e) {
+ udev_device->tags_uptodate = false;
+ udev_list_entry_delete(e);
+ }
+}
+
void udev_device_cleanup_tags_list(struct udev_device *udev_device)
{
udev_device->tags_uptodate = false;
return udev_list_get_entry(&udev_device->tags_list);
}
+/**
+ * udev_device_has_tag:
+ * @udev_device: udev device
+ * @tag: tag name
+ *
+ * Check if a given device has a certain tag associated.
+ *
+ * Returns: 1 if the tag is found. 0 otherwise.
+ **/
_public_ int udev_device_has_tag(struct udev_device *udev_device, const char *tag)
{
struct udev_list_entry *list_entry;
return -EINVAL;
/* add property string to monitor buffer */
- l = util_strpcpyl(&s, l, key, "=", udev_list_entry_get_value(list_entry), NULL);
+ l = strpcpyl(&s, l, key, "=", udev_list_entry_get_value(list_entry), NULL);
if (l == 0)
return -EINVAL;
- /* advance past the trailing '\0' that util_strpcpyl() guarantees */
+ /* advance past the trailing '\0' that strpcpyl() guarantees */
s++;
l--;
}
~ianmdlvl / elogind.git / blobdiff