#include <string.h>
#include <dirent.h>
#include <fcntl.h>
+#include <ctype.h>
#include <sys/stat.h>
#include "libudev.h"
struct udev_device *parent_device;
char *syspath;
const char *devpath;
- const char *sysname;
+ char *sysname;
+ const char *sysnum;
char *devnode;
char *subsystem;
- struct list_node devlink_list;
- struct list_node properties_list;
+ struct udev_list_node devlinks_list;
+ int devlinks_uptodate;
+ struct udev_list_node properties_list;
+ char *envp[128];
+ int envp_uptodate;
+ char *driver;
+ dev_t devnum;
char *action;
int event_timeout;
- char *driver;
char *devpath_old;
char *physdevpath;
int timeout;
- dev_t devnum;
unsigned long long int seqnum;
int num_fake_partitions;
int devlink_priority;
int ignore_remove;
- struct list_node attr_list;
+ struct udev_list_node attr_list;
int info_loaded;
};
-static size_t syspath_to_db_path(struct udev_device *udev_device, char *filename, size_t len)
+static size_t devpath_to_db_path(struct udev *udev, const char *devpath, char *filename, size_t len)
{
size_t start;
/* translate to location of db file */
- util_strlcpy(filename, udev_get_dev_path(udev_device->udev), len);
+ util_strlcpy(filename, udev_get_dev_path(udev), len);
start = util_strlcat(filename, "/.udev/db/", len);
- util_strlcat(filename, udev_device->devpath, len);
+ util_strlcat(filename, devpath, len);
return util_path_encode(&filename[start], len - start);
}
char line[UTIL_LINE_SIZE];
FILE *f;
- syspath_to_db_path(udev_device, filename, sizeof(filename));
+ devpath_to_db_path(udev_device->udev, udev_device->devpath, filename, sizeof(filename));
if (lstat(filename, &stats) != 0) {
info(udev_device->udev, "no db file to read %s: %m\n", filename);
}
if ((stats.st_mode & S_IFMT) == S_IFLNK) {
char target[UTIL_PATH_SIZE];
+ char devnode[UTIL_PATH_SIZE];
int target_len;
char *next;
next[0] = '\0';
next = &next[1];
}
- if (asprintf(&udev_device->devnode, "%s/%s", udev_get_dev_path(udev_device->udev), target) < 0)
- return -ENOMEM;
+ util_strlcpy(devnode, udev_get_dev_path(udev_device->udev), sizeof(devnode));
+ util_strlcat(devnode, "/", sizeof(devnode));
+ util_strlcat(devnode, target, sizeof(devnode));
+ udev_device_set_devnode(udev_device, devnode);
while (next != NULL) {
- char linkname[UTIL_PATH_SIZE];
+ char devlink[UTIL_PATH_SIZE];
const char *lnk;
lnk = next;
next[0] = '\0';
next = &next[1];
}
- util_strlcpy(linkname, udev_get_dev_path(udev_device->udev), sizeof(linkname));
- util_strlcat(linkname, "/", sizeof(linkname));
- util_strlcat(linkname, lnk, sizeof(linkname));
- device_add_devlink(udev_device, linkname);
+ util_strlcpy(devlink, udev_get_dev_path(udev_device->udev), sizeof(devlink));
+ util_strlcat(devlink, "/", sizeof(devlink));
+ util_strlcat(devlink, lnk, sizeof(devlink));
+ udev_device_add_devlink(udev_device, devlink);
}
info(udev_device->udev, "device %p filled with db symlink data '%s'\n", udev_device, udev_device->devnode);
return 0;
break;
line[len-1] = '\0';
val = &line[2];
-
switch(line[0]) {
case 'N':
- asprintf(&udev_device->devnode, "%s/%s", udev_get_dev_path(udev_device->udev), val);
+ util_strlcpy(filename, udev_get_dev_path(udev_device->udev), sizeof(filename));
+ util_strlcat(filename, "/", sizeof(filename));
+ util_strlcat(filename, val, sizeof(filename));
+ udev_device_set_devnode(udev_device, filename);
break;
case 'S':
util_strlcpy(filename, udev_get_dev_path(udev_device->udev), sizeof(filename));
util_strlcat(filename, "/", sizeof(filename));
util_strlcat(filename, val, sizeof(filename));
- device_add_devlink(udev_device, filename);
+ udev_device_add_devlink(udev_device, filename);
break;
case 'L':
- device_set_devlink_priority(udev_device, atoi(val));
+ udev_device_set_devlink_priority(udev_device, atoi(val));
break;
case 'T':
- device_set_event_timeout(udev_device, atoi(val));
+ udev_device_set_event_timeout(udev_device, atoi(val));
break;
case 'A':
- device_set_num_fake_partitions(udev_device, atoi(val));
+ udev_device_set_num_fake_partitions(udev_device, atoi(val));
break;
case 'R':
- device_set_ignore_remove(udev_device, atoi(val));
+ udev_device_set_ignore_remove(udev_device, atoi(val));
break;
case 'E':
- device_add_property_from_string(udev_device, val);
+ udev_device_add_property_from_string(udev_device, val);
break;
}
}
return 0;
}
-static int device_read_uevent_file(struct udev_device *udev_device)
+int udev_device_read_uevent_file(struct udev_device *udev_device)
{
char filename[UTIL_PATH_SIZE];
FILE *f;
else if (strncmp(line, "MINOR=", 6) == 0)
min = strtoull(&line[6], NULL, 10);
- device_add_property_from_string(udev_device, line);
+ udev_device_add_property_from_string(udev_device, line);
}
udev_device->devnum = makedev(maj, min);
static void device_load_info(struct udev_device *device)
{
- device_read_uevent_file(device);
- device_read_db(device);
device->info_loaded = 1;
+ udev_device_read_uevent_file(device);
+ device_read_db(device);
}
-void device_set_info_loaded(struct udev_device *device)
+void udev_device_set_info_loaded(struct udev_device *device)
{
device->info_loaded = 1;
}
memset(udev_device, 0x00, sizeof(struct udev_device));
udev_device->refcount = 1;
udev_device->udev = udev;
- list_init(&udev_device->devlink_list);
- list_init(&udev_device->properties_list);
- list_init(&udev_device->attr_list);
+ udev_list_init(&udev_device->devlinks_list);
+ udev_list_init(&udev_device->properties_list);
+ udev_list_init(&udev_device->attr_list);
+ udev_device->event_timeout = -1;
info(udev_device->udev, "udev_device: %p created\n", udev_device);
return udev_device;
}
if (udev_device == NULL)
return NULL;
- device_set_syspath(udev_device, path);
+ udev_device_set_syspath(udev_device, path);
info(udev, "device %p has devpath '%s'\n", udev_device, udev_device_get_devpath(udev_device));
return udev_device;
**/
void udev_device_unref(struct udev_device *udev_device)
{
+ unsigned int i;
+
if (udev_device == NULL)
return;
udev_device->refcount--;
if (udev_device->parent_device != NULL)
udev_device_unref(udev_device->parent_device);
free(udev_device->syspath);
+ free(udev_device->sysname);
free(udev_device->devnode);
free(udev_device->subsystem);
- list_cleanup(udev_device->udev, &udev_device->devlink_list);
- list_cleanup(udev_device->udev, &udev_device->properties_list);
+ udev_list_cleanup(udev_device->udev, &udev_device->devlinks_list);
+ udev_list_cleanup(udev_device->udev, &udev_device->properties_list);
free(udev_device->action);
free(udev_device->driver);
free(udev_device->devpath_old);
free(udev_device->physdevpath);
- list_cleanup(udev_device->udev, &udev_device->attr_list);
+ udev_list_cleanup(udev_device->udev, &udev_device->attr_list);
+ for (i = 0; i < ARRAY_SIZE(udev_device->envp) && udev_device->envp[i] != NULL; i++)
+ free(udev_device->envp[i]);
info(udev_device->udev, "udev_device: %p released\n", udev_device);
free(udev_device);
}
return udev_device->sysname;
}
+const char *udev_device_get_sysnum(struct udev_device *udev_device)
+{
+ if (udev_device == NULL)
+ return NULL;
+ return udev_device->sysnum;
+}
+
/**
* udev_device_get_devnode:
* @udev_device: udev device
return NULL;
if (!udev_device->info_loaded)
device_load_info(udev_device);
- return list_get_entry(&udev_device->devlink_list);
+ return udev_list_get_entry(&udev_device->devlinks_list);
+}
+
+void udev_device_cleanup_devlinks_list(struct udev_device *udev_device)
+{
+ udev_device->devlinks_uptodate = 0;
+ udev_list_cleanup(udev_device->udev, &udev_device->devlinks_list);
}
/**
return NULL;
if (!udev_device->info_loaded)
device_load_info(udev_device);
- return list_get_entry(&udev_device->properties_list);
+ if (!udev_device->devlinks_uptodate) {
+ char symlinks[UTIL_PATH_SIZE];
+ struct udev_list_entry *list_entry;
+
+ udev_device->devlinks_uptodate = 1;
+ list_entry = udev_device_get_devlinks_list_entry(udev_device);
+ if (list_entry != NULL) {
+ util_strlcpy(symlinks, udev_list_entry_get_name(list_entry), sizeof(symlinks));
+ udev_list_entry_foreach(list_entry, udev_list_entry_get_next(list_entry)) {
+ util_strlcat(symlinks, " ", sizeof(symlinks));
+ util_strlcat(symlinks, udev_list_entry_get_name(list_entry), sizeof(symlinks));
+ }
+ udev_device_add_property(udev_device, "DEVLINKS", symlinks);
+ }
+ }
+ return udev_list_get_entry(&udev_device->properties_list);
}
const char *udev_device_get_driver(struct udev_device *udev_device)
ssize_t size;
const char *val = NULL;
+ if (udev_device == NULL)
+ return NULL;
+ if (attr == NULL)
+ return NULL;
+
/* look for possibly already cached result */
- udev_list_entry_foreach(list_entry, list_get_entry(&udev_device->attr_list)) {
+ udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_device->attr_list)) {
if (strcmp(udev_list_entry_get_name(list_entry), attr) == 0) {
- info(udev_device->udev, "got '%s' (%s) from cache\n", attr, udev_list_entry_get_value(list_entry));
+ info(udev_device->udev, "got '%s' (%s) from cache\n",
+ attr, udev_list_entry_get_value(list_entry));
return udev_list_entry_get_value(list_entry);
}
}
if (pos != NULL) {
pos = &pos[1];
info(udev_device->udev, "cache '%s' with link value '%s'\n", attr, pos);
- list_entry = list_entry_add(udev_device->udev, &udev_device->attr_list, attr, pos, 0, 0);
+ list_entry = udev_list_entry_add(udev_device->udev, &udev_device->attr_list, attr, pos, 0, 0);
val = udev_list_entry_get_value(list_entry);
}
}
value[size] = '\0';
util_remove_trailing_chars(value, '\n');
info(udev_device->udev, "'%s' has attribute value '%s'\n", path, value);
- list_entry = list_entry_add(udev_device->udev, &udev_device->attr_list, attr, value, 0, 0);
+ list_entry = udev_list_entry_add(udev_device->udev, &udev_device->attr_list, attr, value, 0, 0);
val = udev_list_entry_get_value(list_entry);
out:
return val;
}
-int device_set_syspath(struct udev_device *udev_device, const char *syspath)
+
+int udev_device_set_syspath(struct udev_device *udev_device, const char *syspath)
{
const char *pos;
+ size_t len;
+ free(udev_device->syspath);
udev_device->syspath = strdup(syspath);
if (udev_device->syspath == NULL)
return -ENOMEM;
udev_device->devpath = &udev_device->syspath[strlen(udev_get_sys_path(udev_device->udev))];
+ udev_device_add_property(udev_device, "DEVPATH", udev_device->devpath);
+
pos = strrchr(udev_device->syspath, '/');
if (pos == NULL)
return -EINVAL;
- udev_device->sysname = &pos[1];
+ udev_device->sysname = strdup(&pos[1]);
+ if (udev_device->sysname == NULL)
+ return -ENOMEM;
+
+ /* some devices have '!' in their name, change that to '/' */
+ len = 0;
+ while (udev_device->sysname[len] != '\0') {
+ if (udev_device->sysname[len] == '!')
+ udev_device->sysname[len] = '/';
+ len++;
+ }
+
+ /* trailing number */
+ while (isdigit(udev_device->sysname[--len]))
+ udev_device->sysnum = &udev_device->sysname[len];
return 0;
}
-int 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);
if (udev_device->subsystem == NULL)
- return -1;
+ return -ENOMEM;
+ udev_device_add_property(udev_device, "SUBSYSTEM", udev_device->subsystem);
return 0;
}
-int device_set_devnode(struct udev_device *udev_device, const char *devnode)
+int udev_device_set_devnode(struct udev_device *udev_device, const char *devnode)
{
+ free(udev_device->devnode);
udev_device->devnode = strdup(devnode);
+ if (devnode == NULL)
+ return 0;
if (udev_device->devnode == NULL)
return -ENOMEM;
+ udev_device_add_property(udev_device, "DEVNAME", udev_device->devnode);
return 0;
}
-int device_add_devlink(struct udev_device *udev_device, const char *devlink)
+int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink)
{
- if (list_entry_add(udev_device->udev, &udev_device->devlink_list, devlink, NULL, 1, 0) == NULL)
+ udev_device->devlinks_uptodate = 0;
+ if (udev_list_entry_add(udev_device->udev, &udev_device->devlinks_list, devlink, NULL, 1, 0) == NULL)
return -ENOMEM;
return 0;
}
-int device_add_property(struct udev_device *udev_device, const char *key, const char *value)
+struct udev_list_entry *udev_device_add_property(struct udev_device *udev_device, const char *key, const char *value)
{
- if (list_entry_add(udev_device->udev, &udev_device->properties_list, key, value, 1, 0) == NULL)
- return -ENOMEM;
- return 0;
+ udev_device->envp_uptodate = 0;
+ return udev_list_entry_add(udev_device->udev, &udev_device->properties_list, key, value, 1, 0);
}
-int device_add_property_from_string(struct udev_device *udev_device, const char *property)
+struct udev_list_entry *udev_device_add_property_from_string(struct udev_device *udev_device, const char *property)
{
char name[UTIL_PATH_SIZE];
char *val;
strncpy(name, property, sizeof(name));
val = strchr(name, '=');
if (val == NULL)
- return -1;
+ return NULL;
val[0] = '\0';
val = &val[1];
if (val[0] == '\0')
val = NULL;
- device_add_property(udev_device, name, val);
- return 0;
+ return udev_device_add_property(udev_device, name, val);
}
-int device_set_action(struct udev_device *udev_device, const char *action)
+char **udev_device_get_properties_envp(struct udev_device *udev_device)
{
+ if (!udev_device->envp_uptodate) {
+ unsigned int i;
+ struct udev_list_entry *list_entry;
+
+ for (i = 0; i < ARRAY_SIZE(udev_device->envp) && udev_device->envp[i] != NULL; i++)
+ free(udev_device->envp[i]);
+ i = 0;
+ udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(udev_device)) {
+ asprintf(&udev_device->envp[i++], "%s=%s",
+ udev_list_entry_get_name(list_entry),
+ udev_list_entry_get_value(list_entry));
+ if (i+1 >= ARRAY_SIZE(udev_device->envp))
+ break;
+ }
+ udev_device->envp[i] = NULL;
+ info(udev_device->udev, "constructed envp from %u properties\n", i);
+ udev_device->envp_uptodate = 1;
+ }
+ return udev_device->envp;
+}
+
+int udev_device_set_action(struct udev_device *udev_device, const char *action)
+{
+ free(udev_device->action);
udev_device->action = strdup(action);
if (udev_device->action == NULL)
return -ENOMEM;
+ udev_device_add_property(udev_device, "ACTION", action);
return 0;
}
-int device_set_driver(struct udev_device *udev_device, const char *driver)
+int udev_device_set_driver(struct udev_device *udev_device, const char *driver)
{
+ free(udev_device->driver);
udev_device->driver = strdup(driver);
if (udev_device->driver == NULL)
return -ENOMEM;
return 0;
}
-const char *device_get_devpath_old(struct udev_device *udev_device)
+const char *udev_device_get_devpath_old(struct udev_device *udev_device)
{
return udev_device->devpath_old;
}
-int 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)
{
udev_device->devpath_old = strdup(devpath_old);
if (udev_device->devpath_old == NULL)
return 0;
}
-const char *device_get_physdevpath(struct udev_device *udev_device)
+const char *udev_device_get_physdevpath(struct udev_device *udev_device)
{
return udev_device->physdevpath;
}
-int device_set_physdevpath(struct udev_device *udev_device, const char *physdevpath)
+int udev_device_set_physdevpath(struct udev_device *udev_device, const char *physdevpath)
{
udev_device->physdevpath = strdup(physdevpath);
if (udev_device->physdevpath == NULL)
return 0;
}
-int device_get_timeout(struct udev_device *udev_device)
+int udev_device_get_timeout(struct udev_device *udev_device)
{
return udev_device->timeout;
}
-int device_set_timeout(struct udev_device *udev_device, int timeout)
+int udev_device_set_timeout(struct udev_device *udev_device, int timeout)
{
udev_device->timeout = timeout;
return 0;
}
-int device_get_event_timeout(struct udev_device *udev_device)
+int udev_device_get_event_timeout(struct udev_device *udev_device)
{
if (!udev_device->info_loaded)
device_load_info(udev_device);
return udev_device->event_timeout;
}
-int device_set_event_timeout(struct udev_device *udev_device, int event_timeout)
+int udev_device_set_event_timeout(struct udev_device *udev_device, int event_timeout)
{
udev_device->event_timeout = event_timeout;
return 0;
}
-int device_set_seqnum(struct udev_device *udev_device, unsigned long long int seqnum)
+int udev_device_set_seqnum(struct udev_device *udev_device, unsigned long long int seqnum)
{
udev_device->seqnum = seqnum;
return 0;
}
-int device_set_devnum(struct udev_device *udev_device, dev_t devnum)
+int udev_device_set_devnum(struct udev_device *udev_device, dev_t devnum)
{
udev_device->devnum = devnum;
return 0;
}
-int device_get_num_fake_partitions(struct udev_device *udev_device)
+int udev_device_get_num_fake_partitions(struct udev_device *udev_device)
{
if (!udev_device->info_loaded)
device_load_info(udev_device);
return udev_device->num_fake_partitions;
}
-int device_set_num_fake_partitions(struct udev_device *udev_device, int num)
+int udev_device_set_num_fake_partitions(struct udev_device *udev_device, int num)
{
udev_device->num_fake_partitions = num;
return 0;
}
-int device_get_devlink_priority(struct udev_device *udev_device)
+int udev_device_get_devlink_priority(struct udev_device *udev_device)
{
if (!udev_device->info_loaded)
device_load_info(udev_device);
return udev_device->devlink_priority;
}
-int device_set_devlink_priority(struct udev_device *udev_device, int prio)
+int udev_device_set_devlink_priority(struct udev_device *udev_device, int prio)
{
udev_device->devlink_priority = prio;
return 0;
}
-int device_get_ignore_remove(struct udev_device *udev_device)
+int udev_device_get_ignore_remove(struct udev_device *udev_device)
{
if (!udev_device->info_loaded)
device_load_info(udev_device);
return udev_device->ignore_remove;
}
-int device_set_ignore_remove(struct udev_device *udev_device, int ignore)
+int udev_device_set_ignore_remove(struct udev_device *udev_device, int ignore)
{
udev_device->ignore_remove = ignore;
return 0;
}
-
~ianmdlvl / elogind.git / blobdiff