../../udev/lib/libudev.h \
../../udev/lib/libudev.c \
../../udev/lib/libudev-util.c \
- ../../udev/udev_sysdeps.c \
../../udev/udev_utils.c
if USE_SELINUX
../../udev/lib/libudev.h \
../../udev/lib/libudev.c \
../../udev/lib/libudev-util.c \
- ../../udev/udev_sysdeps.c \
../../udev/udev_sysfs.c \
../../udev/udev_utils.c
break;
}
}
- strlcpy(to, type, len);
+ util_strlcpy(to, type, len);
return type_num;
}
break;
}
}
- strlcpy(to, type, len);
+ util_strlcpy(to, type, len);
}
/*
env = getenv("DEVPATH");
if (env != NULL)
- strlcpy(devpath, env, sizeof(devpath));
+ util_strlcpy(devpath, env, sizeof(devpath));
else {
if (argv[optind] == NULL) {
fprintf(stderr, "No device specified\n");
retval = 1;
goto exit;
}
- strlcpy(devpath, argv[optind], sizeof(devpath));
+ util_strlcpy(devpath, argv[optind], sizeof(devpath));
}
retval = usb_id(udev, devpath);
if (retval == 0) {
char serial[256];
- strlcpy(serial, vendor_str, sizeof(serial));
- strlcat(serial, "_", sizeof(serial));
- strlcat(serial, model_str, sizeof(serial));
+ util_strlcpy(serial, vendor_str, sizeof(serial));
+ util_strlcat(serial, "_", sizeof(serial));
+ util_strlcat(serial, model_str, sizeof(serial));
if (serial_str[0] != '\0') {
- strlcat(serial, "_", sizeof(serial));
- strlcat(serial, serial_str, sizeof(serial));
+ util_strlcat(serial, "_", sizeof(serial));
+ util_strlcat(serial, serial_str, sizeof(serial));
}
if (instance_str[0] != '\0') {
- strlcat(serial, "-", sizeof(serial));
- strlcat(serial, instance_str, sizeof(serial));
+ util_strlcat(serial, "-", sizeof(serial));
+ util_strlcat(serial, instance_str, sizeof(serial));
}
if (export) {
udev_node.c \
udev_rules.c \
udev_rules_parse.c \
- udev_sysdeps.c \
udev_sysfs.c \
udev_utils.c \
udev_utils_file.c \
--- /dev/null
+/*
+ * Based on list.h in the Linux kernel source tree.
+ */
+
+#ifndef _LIST_H
+#define _LIST_H
+
+/**
+ * container_of - cast a member of a structure out to the containing structure
+ *
+ * @ptr: the pointer to the member.
+ * @type: the type of the container struct this is embedded in.
+ * @member: the name of the member within the struct.
+ *
+ */
+#define container_of(ptr, type, member) ({ \
+ const typeof( ((type *)0)->member ) *__mptr = (ptr); \
+ (type *)( (char *)__mptr - offsetof(type,member) );})
+
+/*
+ * These are non-NULL pointers that will result in page faults
+ * under normal circumstances, used to verify that nobody uses
+ * non-initialized list entries.
+ */
+#define LIST_POISON1 ((void *) 0x00100100)
+#define LIST_POISON2 ((void *) 0x00200200)
+
+/*
+ * Simple doubly linked list implementation.
+ *
+ * Some of the internal functions ("__xxx") are useful when
+ * manipulating whole lists rather than single entries, as
+ * sometimes we already know the next/prev entries and we can
+ * generate better code by using them directly rather than
+ * using the generic single-entry routines.
+ */
+
+struct list_head {
+ struct list_head *next, *prev;
+};
+
+#define LIST_HEAD_INIT(name) { &(name), &(name) }
+
+#define LIST_HEAD(name) \
+ struct list_head name = LIST_HEAD_INIT(name)
+
+#define INIT_LIST_HEAD(ptr) do { \
+ (ptr)->next = (ptr); (ptr)->prev = (ptr); \
+} while (0)
+
+/*
+ * Insert a new entry between two known consecutive entries.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_add(struct list_head *new,
+ struct list_head *prev,
+ struct list_head *next)
+{
+ next->prev = new;
+ new->next = next;
+ new->prev = prev;
+ prev->next = new;
+}
+
+/**
+ * list_add - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it after
+ *
+ * Insert a new entry after the specified head.
+ * This is good for implementing stacks.
+ */
+static inline void list_add(struct list_head *new, struct list_head *head)
+{
+ __list_add(new, head, head->next);
+}
+
+/**
+ * list_add_tail - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it before
+ *
+ * Insert a new entry before the specified head.
+ * This is useful for implementing queues.
+ */
+static inline void list_add_tail(struct list_head *new, struct list_head *head)
+{
+ __list_add(new, head->prev, head);
+}
+
+/*
+ * Delete a list entry by making the prev/next entries
+ * point to each other.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_del(struct list_head * prev, struct list_head * next)
+{
+ next->prev = prev;
+ prev->next = next;
+}
+
+/**
+ * list_del - deletes entry from list.
+ * @entry: the element to delete from the list.
+ * Note: list_empty on entry does not return true after this, the entry is
+ * in an undefined state.
+ */
+static inline void list_del(struct list_head *entry)
+{
+ __list_del(entry->prev, entry->next);
+ entry->next = LIST_POISON1;
+ entry->prev = LIST_POISON2;
+}
+
+/**
+ * list_del_init - deletes entry from list and reinitialize it.
+ * @entry: the element to delete from the list.
+ */
+static inline void list_del_init(struct list_head *entry)
+{
+ __list_del(entry->prev, entry->next);
+ INIT_LIST_HEAD(entry);
+}
+
+/**
+ * list_move - delete from one list and add as another's head
+ * @list: the entry to move
+ * @head: the head that will precede our entry
+ */
+static inline void list_move(struct list_head *list, struct list_head *head)
+{
+ __list_del(list->prev, list->next);
+ list_add(list, head);
+}
+
+/**
+ * list_move_tail - delete from one list and add as another's tail
+ * @list: the entry to move
+ * @head: the head that will follow our entry
+ */
+static inline void list_move_tail(struct list_head *list,
+ struct list_head *head)
+{
+ __list_del(list->prev, list->next);
+ list_add_tail(list, head);
+}
+
+/**
+ * list_empty - tests whether a list is empty
+ * @head: the list to test.
+ */
+static inline int list_empty(struct list_head *head)
+{
+ return head->next == head;
+}
+
+static inline void __list_splice(struct list_head *list,
+ struct list_head *head)
+{
+ struct list_head *first = list->next;
+ struct list_head *last = list->prev;
+ struct list_head *at = head->next;
+
+ first->prev = head;
+ head->next = first;
+
+ last->next = at;
+ at->prev = last;
+}
+
+/**
+ * list_splice - join two lists
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ */
+static inline void list_splice(struct list_head *list, struct list_head *head)
+{
+ if (!list_empty(list))
+ __list_splice(list, head);
+}
+
+/**
+ * list_splice_init - join two lists and reinitialise the emptied list.
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ *
+ * The list at @list is reinitialised
+ */
+static inline void list_splice_init(struct list_head *list,
+ struct list_head *head)
+{
+ if (!list_empty(list)) {
+ __list_splice(list, head);
+ INIT_LIST_HEAD(list);
+ }
+}
+
+/**
+ * list_entry - get the struct for this entry
+ * @ptr: the &struct list_head pointer.
+ * @type: the type of the struct this is embedded in.
+ * @member: the name of the list_struct within the struct.
+ */
+#define list_entry(ptr, type, member) \
+ container_of(ptr, type, member)
+
+/**
+ * list_for_each - iterate over a list
+ * @pos: the &struct list_head to use as a loop counter.
+ * @head: the head for your list.
+ */
+#define list_for_each(pos, head) \
+ for (pos = (head)->next; pos != (head); \
+ pos = pos->next)
+
+/**
+ * __list_for_each - iterate over a list
+ * @pos: the &struct list_head to use as a loop counter.
+ * @head: the head for your list.
+ *
+ * This variant differs from list_for_each() in that it's the
+ * simplest possible list iteration code.
+ * Use this for code that knows the list to be very short (empty
+ * or 1 entry) most of the time.
+ */
+#define __list_for_each(pos, head) \
+ for (pos = (head)->next; pos != (head); pos = pos->next)
+
+/**
+ * list_for_each_prev - iterate over a list backwards
+ * @pos: the &struct list_head to use as a loop counter.
+ * @head: the head for your list.
+ */
+#define list_for_each_prev(pos, head) \
+ for (pos = (head)->prev; pos != (head); pos = pos->prev)
+
+/**
+ * list_for_each_safe - iterate over a list safe against removal of list entry
+ * @pos: the &struct list_head to use as a loop counter.
+ * @n: another &struct list_head to use as temporary storage
+ * @head: the head for your list.
+ */
+#define list_for_each_safe(pos, n, head) \
+ for (pos = (head)->next, n = pos->next; pos != (head); \
+ pos = n, n = pos->next)
+
+/**
+ * list_for_each_entry - iterate over list of given type
+ * @pos: the type * to use as a loop counter.
+ * @head: the head for your list.
+ * @member: the name of the list_struct within the struct.
+ */
+#define list_for_each_entry(pos, head, member) \
+ for (pos = list_entry((head)->next, typeof(*pos), member); \
+ &pos->member != (head); \
+ pos = list_entry(pos->member.next, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_reverse - iterate backwards over list of given type.
+ * @pos: the type * to use as a loop counter.
+ * @head: the head for your list.
+ * @member: the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_reverse(pos, head, member) \
+ for (pos = list_entry((head)->prev, typeof(*pos), member); \
+ &pos->member != (head); \
+ pos = list_entry(pos->member.prev, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * @pos: the type * to use as a loop counter.
+ * @n: another type * to use as temporary storage
+ * @head: the head for your list.
+ * @member: the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_safe(pos, n, head, member) \
+ for (pos = list_entry((head)->next, typeof(*pos), member), \
+ n = list_entry(pos->member.next, typeof(*pos), member); \
+ &pos->member != (head); \
+ pos = n, n = list_entry(n->member.next, typeof(*n), member))
+
+#endif /* _LIST_H */
/* override built-in sysfs device */
udevice->dev = dev;
- strlcpy(udevice->action, action, sizeof(udevice->action));
+ util_strlcpy(udevice->action, action, sizeof(udevice->action));
/* get dev_t from environment, which is needed for "remove" to work, "add" works also from sysfs */
maj = getenv("MAJOR");
size_t start;
/* translate to location of db file */
- strlcpy(filename, udev_get_dev_path(udev), len);
- start = strlcat(filename, "/.udev/db/", len);
- strlcat(filename, devpath, len);
+ util_strlcpy(filename, udev_get_dev_path(udev), len);
+ start = util_strlcat(filename, "/.udev/db/", len);
+ util_strlcat(filename, devpath, len);
return util_path_encode(&filename[start], len - start);
}
int fd;
/* directory with device name */
- strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
- start = strlcat(filename, "/.udev/names/", sizeof(filename));
- strlcat(filename, name, sizeof(filename));
+ util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
+ start = util_strlcat(filename, "/.udev/names/", sizeof(filename));
+ util_strlcat(filename, name, sizeof(filename));
util_path_encode(&filename[start], sizeof(filename) - start);
/* entry with the devpath */
- strlcpy(device, devpath, sizeof(device));
+ util_strlcpy(device, devpath, sizeof(device));
util_path_encode(device, sizeof(device));
- strlcat(filename, "/", sizeof(filename));
- strlcat(filename, device, sizeof(filename));
+ util_strlcat(filename, "/", sizeof(filename));
+ util_strlcat(filename, device, sizeof(filename));
if (add) {
info(udev, "creating index: '%s'\n", filename);
DIR *dir;
int rc = 0;
- strlcpy(dirname, udev_get_dev_path(udev), sizeof(dirname));
- start = strlcat(dirname, "/.udev/names/", sizeof(dirname));
- strlcat(dirname, name, sizeof(dirname));
+ util_strlcpy(dirname, udev_get_dev_path(udev), sizeof(dirname));
+ start = util_strlcat(dirname, "/.udev/names/", sizeof(dirname));
+ util_strlcat(dirname, name, sizeof(dirname));
util_path_encode(&dirname[start], sizeof(dirname) - start);
dir = opendir(dirname);
if (ent->d_name[0] == '.')
continue;
- strlcpy(device, ent->d_name, sizeof(device));
+ util_strlcpy(device, ent->d_name, sizeof(device));
util_path_decode(device);
name_list_add(udev, name_list, device, 0);
rc++;
return -1;
}
dbg(udevice->udev, "db link points to '%s'\n", target);
- strlcpy(udevice->name, target, sizeof(udevice->name));
+ util_strlcpy(udevice->name, target, sizeof(udevice->name));
return 0;
}
switch(bufline[0]) {
case 'N':
- strlcpy(udevice->name, line, sizeof(udevice->name));
+ util_strlcpy(udevice->name, line, sizeof(udevice->name));
break;
case 'M':
sscanf(line, "%u:%u", &maj, &min);
char dbpath[PATH_MAX];
DIR *dir;
- strlcpy(dbpath, udev_get_dev_path(udev), sizeof(dbpath));
- strlcat(dbpath, "/.udev/db", sizeof(dbpath));
+ util_strlcpy(dbpath, udev_get_dev_path(udev), sizeof(dbpath));
+ util_strlcat(dbpath, "/.udev/db", sizeof(dbpath));
dir = opendir(dbpath);
if (dir == NULL) {
info(udev, "no udev_db available '%s': %s\n", dbpath, strerror(errno));
if (ent->d_name[0] == '.')
continue;
- strlcpy(device, ent->d_name, sizeof(device));
+ util_strlcpy(device, ent->d_name, sizeof(device));
util_path_decode(device);
name_list_add(udev, name_list, device, 1);
dbg(udev, "added '%s'\n", device);
#include "udev.h"
#include "udev_rules.h"
-
static void kernel_log(struct ifreq ifr)
{
int klog;
}
memset(&ifr, 0x00, sizeof(struct ifreq));
- strlcpy(ifr.ifr_name, udevice->dev->kernel, IFNAMSIZ);
- strlcpy(ifr.ifr_newname, udevice->name, IFNAMSIZ);
+ util_strlcpy(ifr.ifr_name, udevice->dev->kernel, IFNAMSIZ);
+ util_strlcpy(ifr.ifr_newname, udevice->name, IFNAMSIZ);
retval = ioctl(sk, SIOCSIFNAME, &ifr);
if (retval == 0)
kernel_log(ifr);
/* see if the destination interface name already exists */
if (errno != EEXIST) {
- err(udevice->udev, "error changing netif name %s to %s: %s\n", ifr.ifr_name, ifr.ifr_newname, strerror(errno));
+ err(udevice->udev, "error changing netif name %s to %s: %s\n",
+ ifr.ifr_name, ifr.ifr_newname, strerror(errno));
goto exit;
}
/* free our own name, another process may wait for us */
- strlcpy(ifr.ifr_newname, udevice->dev->kernel, IFNAMSIZ);
- strlcat(ifr.ifr_newname, "_rename", IFNAMSIZ);
+ util_strlcpy(ifr.ifr_newname, udevice->dev->kernel, IFNAMSIZ);
+ util_strlcat(ifr.ifr_newname, "_rename", IFNAMSIZ);
retval = ioctl(sk, SIOCSIFNAME, &ifr);
if (retval != 0) {
- err(udevice->udev, "error changing netif name %s to %s: %s\n", ifr.ifr_name, ifr.ifr_newname, strerror(errno));
+ err(udevice->udev, "error changing netif name %s to %s: %s\n",
+ ifr.ifr_name, ifr.ifr_newname, strerror(errno));
goto exit;
}
/* wait 30 seconds for our target to become available */
- strlcpy(ifr.ifr_name, ifr.ifr_newname, IFNAMSIZ);
- strlcpy(ifr.ifr_newname, udevice->name, IFNAMSIZ);
+ util_strlcpy(ifr.ifr_name, ifr.ifr_newname, IFNAMSIZ);
+ util_strlcpy(ifr.ifr_newname, udevice->name, IFNAMSIZ);
loop = 30 * 20;
while (loop--) {
retval = ioctl(sk, SIOCSIFNAME, &ifr);
ifr.ifr_name, ifr.ifr_newname, strerror(errno));
break;
}
- dbg(udevice->udev, "wait for netif '%s' to become free, loop=%i\n", udevice->name, (30 * 20) - loop);
+ dbg(udevice->udev, "wait for netif '%s' to become free, loop=%i\n",
+ udevice->name, (30 * 20) - loop);
usleep(1000 * 1000 / 20);
}
}
setenv("INTERFACE_OLD", udevice->dev->kernel, 1);
/* now change the devpath, because the kernel device name has changed */
- strlcpy(devpath, udevice->dev->devpath, sizeof(devpath));
+ util_strlcpy(devpath, udevice->dev->devpath, sizeof(devpath));
pos = strrchr(devpath, '/');
if (pos != NULL) {
pos[1] = '\0';
- strlcat(devpath, udevice->name, sizeof(devpath));
+ util_strlcat(devpath, udevice->name, sizeof(devpath));
sysfs_device_set_values(udevice->udev, udevice->dev, devpath, NULL, NULL);
setenv("DEVPATH", udevice->dev->devpath, 1);
setenv("INTERFACE", udevice->name, 1);
} else {
dbg(udevice->udev, "'%s' not found in database, using kernel name '%s'\n",
udevice->dev->devpath, udevice->dev->kernel);
- strlcpy(udevice->name, udevice->dev->kernel, sizeof(udevice->name));
+ util_strlcpy(udevice->name, udevice->dev->kernel, sizeof(udevice->name));
}
udev_rules_get_run(rules, udevice);
udev_selinux_lsetfilecon(udevice->udev, file, mode);
} else {
info(udevice->udev, "atomically replace existing file '%s'\n", file);
- strlcpy(file_tmp, file, sizeof(file_tmp));
- strlcat(file_tmp, TMP_FILE_EXT, sizeof(file_tmp));
+ util_strlcpy(file_tmp, file, sizeof(file_tmp));
+ util_strlcat(file_tmp, TMP_FILE_EXT, sizeof(file_tmp));
unlink(file_tmp);
udev_selinux_setfscreatecon(udevice->udev, file_tmp, mode);
err = mknod(file_tmp, mode, devt);
}
while (slink[i] != '\0') {
if (slink[i] == '/')
- strlcat(target, "../", sizeof(target));
+ util_strlcat(target, "../", sizeof(target));
i++;
}
- strlcat(target, &node[tail], sizeof(target));
+ util_strlcat(target, &node[tail], sizeof(target));
/* preserve link with correct target, do not replace node of other device */
if (lstat(slink, &stats) == 0) {
}
info(udevice->udev, "atomically replace '%s'\n", slink);
- strlcpy(slink_tmp, slink, sizeof(slink_tmp));
- strlcat(slink_tmp, TMP_FILE_EXT, sizeof(slink_tmp));
+ util_strlcpy(slink_tmp, slink, sizeof(slink_tmp));
+ util_strlcat(slink_tmp, TMP_FILE_EXT, sizeof(slink_tmp));
unlink(slink_tmp);
udev_selinux_setfscreatecon(udevice->udev, slink, S_IFLNK);
retval = symlink(target, slink_tmp);
int priority = 0;
int rc = 0;
- strlcpy(slink, udev_get_dev_path(udevice->udev), sizeof(slink));
- strlcat(slink, "/", sizeof(slink));
- strlcat(slink, name, sizeof(slink));
+ util_strlcpy(slink, udev_get_dev_path(udevice->udev), sizeof(slink));
+ util_strlcat(slink, "/", sizeof(slink));
+ util_strlcat(slink, name, sizeof(slink));
count = udev_db_get_devices_by_name(udevice->udev, name, &name_list);
info(udevice->udev, "found %i devices with name '%s'\n", count, name);
info(udevice->udev, "'%s' is our device node, database inconsistent, skip link update\n", udevice->name);
} else if (target[0] == '\0' || udevice->link_priority >= priority) {
priority = udevice->link_priority;
- strlcpy(target, udevice->name, sizeof(target));
+ util_strlcpy(target, udevice->name, sizeof(target));
}
continue;
}
udevice_db->dev->devpath, udevice_db->link_priority, priority);
if (target[0] == '\0' || udevice_db->link_priority > priority) {
priority = udevice_db->link_priority;
- strlcpy(target, udevice_db->name, sizeof(target));
+ util_strlcpy(target, udevice_db->name, sizeof(target));
}
}
}
}
/* create symlink to the target with the highest priority */
- strlcpy(node, udev_get_dev_path(udevice->udev), sizeof(node));
- strlcat(node, "/", sizeof(node));
- strlcat(node, target, sizeof(node));
+ util_strlcpy(node, udev_get_dev_path(udevice->udev), sizeof(node));
+ util_strlcat(node, "/", sizeof(node));
+ util_strlcat(node, target, sizeof(node));
info(udevice->udev, "'%s' with target '%s' has the highest priority %i, create it\n", name, target, priority);
if (!udevice->test_run) {
create_path(udevice->udev, slink);
list_for_each_entry(name_loop, &udevice->symlink_list, node) {
info(udevice->udev, "update symlink '%s' of '%s'\n", name_loop->name, udevice->dev->devpath);
update_link(udevice, name_loop->name);
- strlcat(symlinks, udev_get_dev_path(udevice->udev), sizeof(symlinks));
- strlcat(symlinks, "/", sizeof(symlinks));
- strlcat(symlinks, name_loop->name, sizeof(symlinks));
- strlcat(symlinks, " ", sizeof(symlinks));
+ util_strlcat(symlinks, udev_get_dev_path(udevice->udev), sizeof(symlinks));
+ util_strlcat(symlinks, "/", sizeof(symlinks));
+ util_strlcat(symlinks, name_loop->name, sizeof(symlinks));
+ util_strlcat(symlinks, " ", sizeof(symlinks));
}
/* export symlinks to environment */
int i;
int retval = 0;
- strlcpy(filename, udev_get_dev_path(udevice->udev), sizeof(filename));
- strlcat(filename, "/", sizeof(filename));
- strlcat(filename, udevice->name, sizeof(filename));
+ util_strlcpy(filename, udev_get_dev_path(udevice->udev), sizeof(filename));
+ util_strlcat(filename, "/", sizeof(filename));
+ util_strlcat(filename, udevice->name, sizeof(filename));
create_path(udevice->udev, filename);
if (strcmp(udevice->owner, "root") == 0)
int retval = 0;
int num;
- strlcpy(filename, udev_get_dev_path(udevice->udev), sizeof(filename));
- strlcat(filename, "/", sizeof(filename));
- strlcat(filename, udevice->name, sizeof(filename));
+ util_strlcpy(filename, udev_get_dev_path(udevice->udev), sizeof(filename));
+ util_strlcat(filename, "/", sizeof(filename));
+ util_strlcat(filename, udevice->name, sizeof(filename));
if (stat(filename, &stats) != 0) {
info(udevice->udev, "device node '%s' not found\n", filename);
return 0;
int retval = 0;
/* build argv from comand */
- strlcpy(arg, command, sizeof(arg));
+ util_strlcpy(arg, command, sizeof(arg));
i = 0;
if (strchr(arg, ' ') != NULL) {
char *pos = arg;
/* allow programs in /lib/udev called without the path */
if (strchr(argv[0], '/') == NULL) {
- strlcpy(program, UDEV_PREFIX "/lib/udev/", sizeof(program));
- strlcat(program, argv[0], sizeof(program));
+ util_strlcpy(program, UDEV_PREFIX "/lib/udev/", sizeof(program));
+ util_strlcat(program, argv[0], sizeof(program));
argv[0] = program;
}
char name[NAME_SIZE];
char *pos;
- strlcpy(name, name_loop->name, sizeof(name));
+ util_strlcpy(name, name_loop->name, sizeof(name));
pos = strchr(name, '=');
if (pos) {
pos[0] = '\0';
saddr.sun_family = AF_LOCAL;
if (sockpath[0] == '@') {
/* abstract namespace socket requested */
- strlcpy(&saddr.sun_path[1], &sockpath[1], sizeof(saddr.sun_path)-1);
+ util_strlcpy(&saddr.sun_path[1], &sockpath[1], sizeof(saddr.sun_path)-1);
saddrlen = offsetof(struct sockaddr_un, sun_path) + 1 + strlen(&saddr.sun_path[1]);
} else if (stat(sockpath, &stats) == 0 && S_ISSOCK(stats.st_mode)) {
/* existing socket file */
- strlcpy(saddr.sun_path, sockpath, sizeof(saddr.sun_path));
+ util_strlcpy(saddr.sun_path, sockpath, sizeof(saddr.sun_path));
saddrlen = offsetof(struct sockaddr_un, sun_path) + strlen(saddr.sun_path);
} else {
/* no socket file, assume abstract namespace socket */
- strlcpy(&saddr.sun_path[1], sockpath, sizeof(saddr.sun_path)-1);
+ util_strlcpy(&saddr.sun_path[1], sockpath, sizeof(saddr.sun_path)-1);
saddrlen = offsetof(struct sockaddr_un, sun_path) + 1 + strlen(&saddr.sun_path[1]);
}
bufpos = snprintf(buf, sizeof(buf), "%s@%s", action, devpath);
bufpos++;
for (i = 0; environ[i] != NULL && bufpos < (sizeof(buf)); i++) {
- bufpos += strlcpy(&buf[bufpos], environ[i], sizeof(buf) - bufpos);
+ bufpos += util_strlcpy(&buf[bufpos], environ[i], sizeof(buf) - bufpos);
bufpos++;
}
if (bufpos > sizeof(buf))
} else {
char program[PATH_SIZE];
- strlcpy(program, name_loop->name, sizeof(program));
+ util_strlcpy(program, name_loop->name, sizeof(program));
udev_rules_apply_format(udevice, program, sizeof(program));
if (run_program(udevice->udev, program, udevice->dev->subsystem, NULL, 0, NULL) != 0)
if (!name_loop->ignore_error)
/* a relative path is a device attribute */
if (file[0] != '/') {
- strlcpy(devicepath, udev_get_sys_path(udevice->udev), sizeof(devicepath));
- strlcat(devicepath, udevice->dev->devpath, sizeof(devicepath));
+ util_strlcpy(devicepath, udev_get_sys_path(udevice->udev), sizeof(devicepath));
+ util_strlcat(devicepath, udevice->dev->devpath, sizeof(devicepath));
- strlcpy(filepath, devicepath, sizeof(filepath));
- strlcat(filepath, "/", sizeof(filepath));
- strlcat(filepath, file, sizeof(filepath));
+ util_strlcpy(filepath, devicepath, sizeof(filepath));
+ util_strlcat(filepath, "/", sizeof(filepath));
+ util_strlcat(filepath, file, sizeof(filepath));
file = filepath;
}
goto out;
attrib = &attrib[1];
- strlcpy(subsys, &attrstr[1], sizeof(subsys));
+ util_strlcpy(subsys, &attrstr[1], sizeof(subsys));
pos = strchr(subsys, ']');
if (pos == NULL)
goto out;
DIR *dir;
pos[1] = '\0';
- strlcpy(str, &pos[2], sizeof(str));
+ util_strlcpy(str, &pos[2], sizeof(str));
dir = opendir(attr);
if (dir != NULL) {
struct dirent *dent;
if (dent->d_name[0] == '.')
continue;
- strlcat(attr, dent->d_name, len);
- strlcat(attr, str, len);
+ util_strlcat(attr, dent->d_name, len);
+ util_strlcat(attr, str, len);
if (stat(attr, &stats) == 0) {
found = 1;
break;
closedir(dir);
}
if (!found)
- strlcat(attr, str, len);
+ util_strlcat(attr, str, len);
}
return found;
if (head[1] == '\0')
break;
if (head[1] == '$') {
- strlcpy(temp, head+2, sizeof(temp));
- strlcpy(head+1, temp, maxsize);
+ util_strlcpy(temp, head+2, sizeof(temp));
+ util_strlcpy(head+1, temp, maxsize);
head++;
continue;
}
if (head[1] == '\0')
break;
if (head[1] == '%') {
- strlcpy(temp, head+2, sizeof(temp));
- strlcpy(head+1, temp, maxsize);
+ util_strlcpy(temp, head+2, sizeof(temp));
+ util_strlcpy(head+1, temp, maxsize);
head++;
continue;
}
break;
found:
attr = get_format_attribute(udevice->udev, &tail);
- strlcpy(temp, tail, sizeof(temp));
+ util_strlcpy(temp, tail, sizeof(temp));
dbg(udevice->udev, "format=%i, string='%s', tail='%s'\n", type ,string, tail);
switch (type) {
case SUBST_DEVPATH:
- strlcat(string, udevice->dev->devpath, maxsize);
+ util_strlcat(string, udevice->dev->devpath, maxsize);
dbg(udevice->udev, "substitute devpath '%s'\n", udevice->dev->devpath);
break;
case SUBST_KERNEL:
- strlcat(string, udevice->dev->kernel, maxsize);
+ util_strlcat(string, udevice->dev->kernel, maxsize);
dbg(udevice->udev, "substitute kernel name '%s'\n", udevice->dev->kernel);
break;
case SUBST_KERNEL_NUMBER:
- strlcat(string, udevice->dev->kernel_number, maxsize);
+ util_strlcat(string, udevice->dev->kernel_number, maxsize);
dbg(udevice->udev, "substitute kernel number '%s'\n", udevice->dev->kernel_number);
break;
case SUBST_ID:
if (udevice->dev_parent != NULL) {
- strlcat(string, udevice->dev_parent->kernel, maxsize);
+ util_strlcat(string, udevice->dev_parent->kernel, maxsize);
dbg(udevice->udev, "substitute id '%s'\n", udevice->dev_parent->kernel);
}
break;
case SUBST_DRIVER:
if (udevice->dev_parent != NULL) {
- strlcat(string, udevice->dev_parent->driver, maxsize);
+ util_strlcat(string, udevice->dev_parent->driver, maxsize);
dbg(udevice->udev, "substitute driver '%s'\n", udevice->dev_parent->driver);
}
break;
case SUBST_MAJOR:
sprintf(temp2, "%d", major(udevice->devt));
- strlcat(string, temp2, maxsize);
+ util_strlcat(string, temp2, maxsize);
dbg(udevice->udev, "substitute major number '%s'\n", temp2);
break;
case SUBST_MINOR:
sprintf(temp2, "%d", minor(udevice->devt));
- strlcat(string, temp2, maxsize);
+ util_strlcat(string, temp2, maxsize);
dbg(udevice->udev, "substitute minor number '%s'\n", temp2);
break;
case SUBST_RESULT:
err(udevice->udev, "requested part of result string not found\n");
break;
}
- strlcpy(temp2, cpos, sizeof(temp2));
+ util_strlcpy(temp2, cpos, sizeof(temp2));
/* %{2+}c copies the whole string from the second part on */
if (rest[0] != '+') {
cpos = strchr(temp2, ' ');
if (cpos)
cpos[0] = '\0';
}
- strlcat(string, temp2, maxsize);
+ util_strlcat(string, temp2, maxsize);
dbg(udevice->udev, "substitute part of result string '%s'\n", temp2);
} else {
- strlcat(string, udevice->program_result, maxsize);
+ util_strlcat(string, udevice->program_result, maxsize);
dbg(udevice->udev, "substitute result string '%s'\n", udevice->program_result);
}
break;
break;
/* strip trailing whitespace, and replace unwanted characters */
- size = strlcpy(temp2, value, sizeof(temp2));
+ size = util_strlcpy(temp2, value, sizeof(temp2));
if (size >= sizeof(temp2))
size = sizeof(temp2)-1;
while (size > 0 && isspace(temp2[size-1]))
count = util_replace_chars(temp2, ALLOWED_CHARS_INPUT);
if (count > 0)
info(udevice->udev, "%i character(s) replaced\n" , count);
- strlcat(string, temp2, maxsize);
+ util_strlcat(string, temp2, maxsize);
dbg(udevice->udev, "substitute sysfs value '%s'\n", temp2);
}
break;
if (udev_parent != NULL) {
/* lookup the name in the udev_db with the DEVPATH of the parent */
if (udev_db_get_device(udev_parent, dev_parent->devpath) == 0) {
- strlcat(string, udev_parent->name, maxsize);
+ util_strlcat(string, udev_parent->name, maxsize);
dbg(udevice->udev, "substitute parent node name'%s'\n", udev_parent->name);
} else
dbg(udevice->udev, "parent not found in database\n");
udevice->tmp_node[sizeof(udevice->tmp_node)-1] = '\0';
udev_node_mknod(udevice, udevice->tmp_node, udevice->devt, 0600, 0, 0);
}
- strlcat(string, udevice->tmp_node, maxsize);
+ util_strlcat(string, udevice->tmp_node, maxsize);
dbg(udevice->udev, "substitute temporary device node name '%s'\n", udevice->tmp_node);
break;
case SUBST_NAME:
if (udevice->name[0] == '\0') {
- strlcat(string, udevice->dev->kernel, maxsize);
+ util_strlcat(string, udevice->dev->kernel, maxsize);
dbg(udevice->udev, "substitute udevice->kernel '%s'\n", udevice->name);
} else {
- strlcat(string, udevice->name, maxsize);
+ util_strlcat(string, udevice->name, maxsize);
dbg(udevice->udev, "substitute udevice->name '%s'\n", udevice->name);
}
break;
char symlinks[PATH_SIZE] = "";
list_for_each_entry(name_loop, &udevice->symlink_list, node) {
- strlcat(symlinks, name_loop->name, sizeof(symlinks));
- strlcat(symlinks, " ", sizeof(symlinks));
+ util_strlcat(symlinks, name_loop->name, sizeof(symlinks));
+ util_strlcat(symlinks, " ", sizeof(symlinks));
}
util_remove_trailing_chars(symlinks, ' ');
- strlcat(string, symlinks, maxsize);
+ util_strlcat(string, symlinks, maxsize);
}
break;
case SUBST_ROOT:
- strlcat(string, udev_get_dev_path(udevice->udev), maxsize);
+ util_strlcat(string, udev_get_dev_path(udevice->udev), maxsize);
dbg(udevice->udev, "substitute udev_root '%s'\n", udev_get_dev_path(udevice->udev));
break;
case SUBST_SYS:
- strlcat(string, udev_get_sys_path(udevice->udev), maxsize);
+ util_strlcat(string, udev_get_sys_path(udevice->udev), maxsize);
dbg(udevice->udev, "substitute sys_path '%s'\n", udev_get_sys_path(udevice->udev));
break;
case SUBST_ENV:
break;
}
dbg(udevice->udev, "substitute env '%s=%s'\n", attr, pos);
- strlcat(string, pos, maxsize);
+ util_strlcat(string, pos, maxsize);
break;
default:
err(udevice->udev, "unknown substitution type=%i\n", type);
head[len] = '\0';
dbg(udevice->udev, "truncate to %i chars, subtitution string becomes '%s'\n", len, head);
}
- strlcat(string, temp, maxsize);
+ util_strlcat(string, temp, maxsize);
}
}
return 0;
/* look for a matching string, parts are separated by '|' */
- strlcpy(value, rule->buf + key->val_off, sizeof(value));
+ util_strlcpy(value, rule->buf + key->val_off, sizeof(value));
key_value = value;
dbg(udev, "key %s value='%s'\n", key_name, key_value);
while (key_value) {
struct stat statbuf;
int match;
- strlcpy(filename, key_val(rule, &rule->test), sizeof(filename));
+ util_strlcpy(filename, key_val(rule, &rule->test), sizeof(filename));
udev_rules_apply_format(udevice, filename, sizeof(filename));
if (attr_get_by_subsys_id(udevice->udev, filename, devpath, sizeof(devpath), &attr)) {
- strlcpy(filename, udev_get_sys_path(udevice->udev), sizeof(filename));
- strlcat(filename, devpath, sizeof(filename));
+ util_strlcpy(filename, udev_get_sys_path(udevice->udev), sizeof(filename));
+ util_strlcat(filename, devpath, sizeof(filename));
if (attr != NULL) {
- strlcat(filename, "/", sizeof(filename));
- strlcat(filename, attr, sizeof(filename));
+ util_strlcat(filename, "/", sizeof(filename));
+ util_strlcat(filename, attr, sizeof(filename));
}
} else if (filename[0] != '/') {
char tmp[PATH_SIZE];
- strlcpy(tmp, udev_get_sys_path(udevice->udev), sizeof(tmp));
- strlcat(tmp, udevice->dev->devpath, sizeof(tmp));
- strlcat(tmp, "/", sizeof(tmp));
- strlcat(tmp, filename, sizeof(tmp));
- strlcpy(filename, tmp, sizeof(filename));
+ util_strlcpy(tmp, udev_get_sys_path(udevice->udev), sizeof(tmp));
+ util_strlcat(tmp, udevice->dev->devpath, sizeof(tmp));
+ util_strlcat(tmp, "/", sizeof(tmp));
+ util_strlcat(tmp, filename, sizeof(tmp));
+ util_strlcpy(filename, tmp, sizeof(filename));
}
attr_subst_subdir(filename, sizeof(filename));
char filename[PATH_SIZE];
int found;
- strlcpy(filename, key_val(rule, &rule->wait_for), sizeof(filename));
+ util_strlcpy(filename, key_val(rule, &rule->wait_for), sizeof(filename));
udev_rules_apply_format(udevice, filename, sizeof(filename));
found = (wait_for_file(udevice, filename, 10) == 0);
if (!found && (rule->wait_for.operation != KEY_OP_NOMATCH))
value = sysfs_attr_get_value(udevice->udev, udevice->dev->devpath, key_name);
if (value == NULL)
goto nomatch;
- strlcpy(val, value, sizeof(val));
+ util_strlcpy(val, value, sizeof(val));
/* strip trailing whitespace of value, if not asked to match for it */
len = strlen(key_value);
value = sysfs_attr_get_value(udevice->udev, udevice->dev->devpath, key_name);
if (value == NULL)
goto try_parent;
- strlcpy(val, value, sizeof(val));
+ util_strlcpy(val, value, sizeof(val));
/* strip trailing whitespace of value, if not asked to match for it */
len = strlen(key_value);
char program[PATH_SIZE];
char result[PATH_SIZE];
- strlcpy(program, key_val(rule, &rule->program), sizeof(program));
+ util_strlcpy(program, key_val(rule, &rule->program), sizeof(program));
udev_rules_apply_format(udevice, program, sizeof(program));
if (run_program(udevice->udev, program, udevice->dev->subsystem, result, sizeof(result), NULL) != 0) {
dbg(udevice->udev, "PROGRAM is false\n");
info(udevice->udev, "%i character(s) replaced\n" , count);
}
dbg(udevice->udev, "result is '%s'\n", result);
- strlcpy(udevice->program_result, result, sizeof(udevice->program_result));
+ util_strlcpy(udevice->program_result, result, sizeof(udevice->program_result));
dbg(udevice->udev, "PROGRAM returned successful\n");
if (rule->program.operation == KEY_OP_NOMATCH)
goto nomatch;
char import[PATH_SIZE];
int rc = -1;
- strlcpy(import, key_val(rule, &rule->import), sizeof(import));
+ util_strlcpy(import, key_val(rule, &rule->import), sizeof(import));
udev_rules_apply_format(udevice, import, sizeof(import));
dbg(udevice->udev, "check for IMPORT import='%s'\n", import);
if (rule->import_type == IMPORT_PROGRAM) {
const char *value = key_val(rule, &pair->key);
/* make sure we don't write to the same string we possibly read from */
- strlcpy(temp_value, value, sizeof(temp_value));
+ util_strlcpy(temp_value, value, sizeof(temp_value));
udev_rules_apply_format(udevice, temp_value, NAME_SIZE);
if (temp_value[0] == '\0') {
if (attr_get_by_subsys_id(udevice->udev, key_name, devpath, sizeof(devpath), &attrib)) {
if (attrib != NULL) {
- strlcpy(attr, udev_get_sys_path(udevice->udev), sizeof(attr));
- strlcat(attr, devpath, sizeof(attr));
- strlcat(attr, "/", sizeof(attr));
- strlcat(attr, attrib, sizeof(attr));
+ util_strlcpy(attr, udev_get_sys_path(udevice->udev), sizeof(attr));
+ util_strlcat(attr, devpath, sizeof(attr));
+ util_strlcat(attr, "/", sizeof(attr));
+ util_strlcat(attr, attrib, sizeof(attr));
}
}
if (attr[0] == '\0') {
- strlcpy(attr, udev_get_sys_path(udevice->udev), sizeof(attr));
- strlcat(attr, udevice->dev->devpath, sizeof(attr));
- strlcat(attr, "/", sizeof(attr));
- strlcat(attr, key_name, sizeof(attr));
+ util_strlcpy(attr, udev_get_sys_path(udevice->udev), sizeof(attr));
+ util_strlcat(attr, udevice->dev->devpath, sizeof(attr));
+ util_strlcat(attr, "/", sizeof(attr));
+ util_strlcat(attr, key_name, sizeof(attr));
}
attr_subst_subdir(attr, sizeof(attr));
- strlcpy(value, key_val(rule, &pair->key), sizeof(value));
+ util_strlcpy(value, key_val(rule, &pair->key), sizeof(value));
udev_rules_apply_format(udevice, value, sizeof(value));
info(udevice->udev, "writing '%s' to sysfs file '%s'\n", value, attr);
f = fopen(attr, "w");
if (rule->mode.operation == KEY_OP_ASSIGN_FINAL)
udevice->mode_final = 1;
char buf[20];
- strlcpy(buf, key_val(rule, &rule->mode), sizeof(buf));
+ util_strlcpy(buf, key_val(rule, &rule->mode), sizeof(buf));
udev_rules_apply_format(udevice, buf, sizeof(buf));
udevice->mode = strtol(buf, NULL, 8);
dbg(udevice->udev, "applied mode=%#o to '%s'\n", udevice->mode, udevice->dev->kernel);
if (!udevice->owner_final && rule->owner.operation != KEY_OP_UNSET) {
if (rule->owner.operation == KEY_OP_ASSIGN_FINAL)
udevice->owner_final = 1;
- strlcpy(udevice->owner, key_val(rule, &rule->owner), sizeof(udevice->owner));
+ util_strlcpy(udevice->owner, key_val(rule, &rule->owner), sizeof(udevice->owner));
udev_rules_apply_format(udevice, udevice->owner, sizeof(udevice->owner));
dbg(udevice->udev, "applied owner='%s' to '%s'\n", udevice->owner, udevice->dev->kernel);
}
if (!udevice->group_final && rule->group.operation != KEY_OP_UNSET) {
if (rule->group.operation == KEY_OP_ASSIGN_FINAL)
udevice->group_final = 1;
- strlcpy(udevice->group, key_val(rule, &rule->group), sizeof(udevice->group));
+ util_strlcpy(udevice->group, key_val(rule, &rule->group), sizeof(udevice->group));
udev_rules_apply_format(udevice, udevice->group, sizeof(udevice->group));
dbg(udevice->udev, "applied group='%s' to '%s'\n", udevice->group, udevice->dev->kernel);
}
name_list_cleanup(udevice->udev, &udevice->symlink_list);
}
/* allow multiple symlinks separated by spaces */
- strlcpy(temp, key_val(rule, &rule->symlink), sizeof(temp));
+ util_strlcpy(temp, key_val(rule, &rule->symlink), sizeof(temp));
udev_rules_apply_format(udevice, temp, sizeof(temp));
if (rule->string_escape == ESCAPE_UNSET ||
rule->string_escape == ESCAPE_REPLACE) {
int count;
name_set = 1;
- strlcpy(udevice->name, key_val(rule, &rule->name), sizeof(udevice->name));
+ util_strlcpy(udevice->name, key_val(rule, &rule->name), sizeof(udevice->name));
udev_rules_apply_format(udevice, udevice->name, sizeof(udevice->name));
if (rule->string_escape == ESCAPE_UNSET ||
rule->string_escape == ESCAPE_REPLACE) {
if (!name_set) {
info(udevice->udev, "no node name set, will use kernel name '%s'\n", udevice->dev->kernel);
- strlcpy(udevice->name, udevice->dev->kernel, sizeof(udevice->name));
+ util_strlcpy(udevice->name, udevice->dev->kernel, sizeof(udevice->name));
}
if (udevice->tmp_node[0] != '\0') {
key->operation = operation;
key->val_off = rule->bufsize;
- strlcpy(rule->buf + rule->bufsize, value, val_len+1);
+ util_strlcpy(rule->buf + rule->bufsize, value, val_len+1);
rule->bufsize += val_len+1;
return 0;
/* add the key-name of the pair */
pairs->keys[pairs->count].key_name_off = rule->bufsize;
- strlcpy(rule->buf + rule->bufsize, key, key_len+1);
+ util_strlcpy(rule->buf + rule->bufsize, key, key_len+1);
rule->bufsize += key_len+1;
pairs->count++;
char *pos;
struct stat statbuf;
- strlcpy(file, value, sizeof(file));
+ util_strlcpy(file, value, sizeof(file));
pos = strchr(file, ' ');
if (pos)
pos[0] = '\0';
/* allow programs in /lib/udev called without the path */
if (strchr(file, '/') == NULL) {
- strlcpy(file, UDEV_PREFIX "/lib/udev/", sizeof(file));
- strlcat(file, value, sizeof(file));
+ util_strlcpy(file, UDEV_PREFIX "/lib/udev/", sizeof(file));
+ util_strlcat(file, value, sizeof(file));
pos = strchr(file, ' ');
if (pos)
pos[0] = '\0';
add_matching_files(udev, &name_list, SYSCONFDIR "/udev/rules.d", ".rules");
/* read dynamic/temporary rules */
- strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
- strlcat(filename, "/.udev/rules.d", sizeof(filename));
+ util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
+ util_strlcat(filename, "/.udev/rules.d", sizeof(filename));
if (stat(filename, &statbuf) != 0) {
create_path(udev, filename);
udev_selinux_setfscreatecon(udev, filename, S_IFDIR|0755);
+++ /dev/null
-/*
- * Copyright (C) 2005-2008 Kay Sievers <kay.sievers@vrfy.org>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/types.h>
-
-#include "udev_sysdeps.h"
-
-#ifndef HAVE_STRLCPY
-size_t strlcpy(char *dst, const char *src, size_t size)
-{
- size_t bytes = 0;
- char *q = dst;
- const char *p = src;
- char ch;
-
- while ((ch = *p++)) {
- if (bytes+1 < size)
- *q++ = ch;
- bytes++;
- }
-
- /* If size == 0 there is no space for a final null... */
- if (size)
- *q = '\0';
- return bytes;
-}
-
-size_t strlcat(char *dst, const char *src, size_t size)
-{
- size_t bytes = 0;
- char *q = dst;
- const char *p = src;
- char ch;
-
- while (bytes < size && *q) {
- q++;
- bytes++;
- }
- if (bytes == size)
- return (bytes + strlen(src));
-
- while ((ch = *p++)) {
- if (bytes+1 < size)
- *q++ = ch;
- bytes++;
- }
-
- *q = '\0';
- return bytes;
-}
-#endif /* HAVE_STRLCPY */
#define IN_MOVE 0
#define IN_CLOSE_WRITE 0
-#endif
-
-#ifndef HAVE_STRLCPY
-extern size_t strlcpy(char *dst, const char *src, size_t size);
-extern size_t strlcat(char *dst, const char *src, size_t size);
-#endif
-
+#endif /* HAVE_INOTIFY */
#endif
{
char *pos;
- strlcpy(dev->devpath, devpath, sizeof(dev->devpath));
+ util_strlcpy(dev->devpath, devpath, sizeof(dev->devpath));
if (subsystem != NULL)
- strlcpy(dev->subsystem, subsystem, sizeof(dev->subsystem));
+ util_strlcpy(dev->subsystem, subsystem, sizeof(dev->subsystem));
if (driver != NULL)
- strlcpy(dev->driver, driver, sizeof(dev->driver));
+ util_strlcpy(dev->driver, driver, sizeof(dev->driver));
/* set kernel name */
pos = strrchr(dev->devpath, '/');
if (pos == NULL)
return;
- strlcpy(dev->kernel, &pos[1], sizeof(dev->kernel));
+ util_strlcpy(dev->kernel, &pos[1], sizeof(dev->kernel));
dbg(udev, "kernel='%s'\n", dev->kernel);
/* some devices have '!' in their name, change that to '/' */
pos = &dev->kernel[strlen(dev->kernel)];
while (isdigit(pos[-1]))
pos--;
- strlcpy(dev->kernel_number, pos, sizeof(dev->kernel_number));
+ util_strlcpy(dev->kernel_number, pos, sizeof(dev->kernel_number));
dbg(udev, "kernel_number='%s'\n", dev->kernel_number);
}
int i;
int back;
- strlcpy(link_path, udev_get_sys_path(udev), sizeof(link_path));
- strlcat(link_path, devpath, sizeof(link_path));
+ util_strlcpy(link_path, udev_get_sys_path(udev), sizeof(link_path));
+ util_strlcat(link_path, devpath, sizeof(link_path));
len = readlink(link_path, link_target, sizeof(link_target));
if (len <= 0)
return -1;
pos[0] = '\0';
}
dbg(udev, "after moving back '%s'\n", devpath);
- strlcat(devpath, "/", size);
- strlcat(devpath, &link_target[back * 3], size);
+ util_strlcat(devpath, "/", size);
+ util_strlcat(devpath, &link_target[back * 3], size);
return 0;
}
return NULL;
dbg(udev, "open '%s'\n", devpath);
- strlcpy(devpath_real, devpath, sizeof(devpath_real));
+ util_strlcpy(devpath_real, devpath, sizeof(devpath_real));
util_remove_trailing_chars(devpath_real, '/');
if (devpath[0] == '\0' )
return NULL;
}
/* if we got a link, resolve it to the real device */
- strlcpy(path, udev_get_sys_path(udev), sizeof(path));
- strlcat(path, devpath_real, sizeof(path));
+ util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
+ util_strlcat(path, devpath_real, sizeof(path));
if (lstat(path, &statbuf) != 0) {
dbg(udev, "stat '%s' failed: %s\n", path, strerror(errno));
return NULL;
sysfs_device_set_values(udev, dev, devpath_real, NULL, NULL);
/* get subsystem name */
- strlcpy(link_path, udev_get_sys_path(udev), sizeof(link_path));
- strlcat(link_path, dev->devpath, sizeof(link_path));
- strlcat(link_path, "/subsystem", sizeof(link_path));
+ util_strlcpy(link_path, udev_get_sys_path(udev), sizeof(link_path));
+ util_strlcat(link_path, dev->devpath, sizeof(link_path));
+ util_strlcat(link_path, "/subsystem", sizeof(link_path));
len = readlink(link_path, link_target, sizeof(link_target));
if (len > 0) {
/* get subsystem from "subsystem" link */
dbg(udev, "subsystem link '%s' points to '%s'\n", link_path, link_target);
pos = strrchr(link_target, '/');
if (pos != NULL)
- strlcpy(dev->subsystem, &pos[1], sizeof(dev->subsystem));
+ util_strlcpy(dev->subsystem, &pos[1], sizeof(dev->subsystem));
} else if (strstr(dev->devpath, "/drivers/") != NULL) {
- strlcpy(dev->subsystem, "drivers", sizeof(dev->subsystem));
+ util_strlcpy(dev->subsystem, "drivers", sizeof(dev->subsystem));
} else if (strncmp(dev->devpath, "/module/", 8) == 0) {
- strlcpy(dev->subsystem, "module", sizeof(dev->subsystem));
+ util_strlcpy(dev->subsystem, "module", sizeof(dev->subsystem));
} else if (strncmp(dev->devpath, "/subsystem/", 11) == 0) {
pos = strrchr(dev->devpath, '/');
if (pos == &dev->devpath[10])
- strlcpy(dev->subsystem, "subsystem", sizeof(dev->subsystem));
+ util_strlcpy(dev->subsystem, "subsystem", sizeof(dev->subsystem));
} else if (strncmp(dev->devpath, "/class/", 7) == 0) {
pos = strrchr(dev->devpath, '/');
if (pos == &dev->devpath[6])
- strlcpy(dev->subsystem, "subsystem", sizeof(dev->subsystem));
+ util_strlcpy(dev->subsystem, "subsystem", sizeof(dev->subsystem));
} else if (strncmp(dev->devpath, "/bus/", 5) == 0) {
pos = strrchr(dev->devpath, '/');
if (pos == &dev->devpath[4])
- strlcpy(dev->subsystem, "subsystem", sizeof(dev->subsystem));
+ util_strlcpy(dev->subsystem, "subsystem", sizeof(dev->subsystem));
}
/* get driver name */
- strlcpy(link_path, udev_get_sys_path(udev), sizeof(link_path));
- strlcat(link_path, dev->devpath, sizeof(link_path));
- strlcat(link_path, "/driver", sizeof(link_path));
+ util_strlcpy(link_path, udev_get_sys_path(udev), sizeof(link_path));
+ util_strlcat(link_path, dev->devpath, sizeof(link_path));
+ util_strlcat(link_path, "/driver", sizeof(link_path));
len = readlink(link_path, link_target, sizeof(link_target));
if (len > 0) {
link_target[len] = '\0';
dbg(udev, "driver link '%s' points to '%s'\n", link_path, link_target);
pos = strrchr(link_target, '/');
if (pos != NULL)
- strlcpy(dev->driver, &pos[1], sizeof(dev->driver));
+ util_strlcpy(dev->driver, &pos[1], sizeof(dev->driver));
}
dbg(udev, "add to cache 'devpath=%s', subsystem='%s', driver='%s'\n", dev->devpath, dev->subsystem, dev->driver);
if (dev->parent != NULL)
return dev->parent;
- strlcpy(parent_devpath, dev->devpath, sizeof(parent_devpath));
+ util_strlcpy(parent_devpath, dev->devpath, sizeof(parent_devpath));
dbg(udev, "'%s'\n", parent_devpath);
/* strip last element */
return dev->parent;
device_link:
- strlcpy(parent_devpath, dev->devpath, sizeof(parent_devpath));
- strlcat(parent_devpath, "/device", sizeof(parent_devpath));
+ util_strlcpy(parent_devpath, dev->devpath, sizeof(parent_devpath));
+ util_strlcat(parent_devpath, "/device", sizeof(parent_devpath));
if (sysfs_resolve_link(udev, parent_devpath, sizeof(parent_devpath)) != 0)
return NULL;
size_t sysfs_len;
dbg(udev, "open '%s'/'%s'\n", devpath, attr_name);
- sysfs_len = strlcpy(path_full, udev_get_sys_path(udev), sizeof(path_full));
+ sysfs_len = util_strlcpy(path_full, udev_get_sys_path(udev), sizeof(path_full));
if(sysfs_len >= sizeof(path_full))
sysfs_len = sizeof(path_full) - 1;
path = &path_full[sysfs_len];
- strlcat(path_full, devpath, sizeof(path_full));
- strlcat(path_full, "/", sizeof(path_full));
- strlcat(path_full, attr_name, sizeof(path_full));
+ util_strlcat(path_full, devpath, sizeof(path_full));
+ util_strlcat(path_full, "/", sizeof(path_full));
+ util_strlcat(path_full, attr_name, sizeof(path_full));
/* look for attribute in cache */
list_for_each_entry(attr_loop, &attr_list, node) {
if (attr == NULL)
return NULL;
memset(attr, 0x00, sizeof(struct sysfs_attr));
- strlcpy(attr->path, path, sizeof(attr->path));
+ util_strlcpy(attr->path, path, sizeof(attr->path));
dbg(udev, "add to cache '%s'\n", path_full);
list_add(&attr->node, &attr_list);
pos = strrchr(link_target, '/');
if (pos != NULL) {
dbg(udev, "cache '%s' with link value '%s'\n", path_full, value);
- strlcpy(attr->value_local, &pos[1], sizeof(attr->value_local));
+ util_strlcpy(attr->value_local, &pos[1], sizeof(attr->value_local));
attr->value = attr->value_local;
}
}
value[size] = '\0';
util_remove_trailing_chars(value, '\n');
dbg(udev, "cache '%s' with attribute value '%s'\n", path_full, value);
- strlcpy(attr->value_local, value, sizeof(attr->value_local));
+ util_strlcpy(attr->value_local, value, sizeof(attr->value_local));
attr->value = attr->value_local;
out:
char *path;
struct stat statbuf;
- sysfs_len = strlcpy(path_full, udev_get_sys_path(udev), sizeof(path_full));
+ sysfs_len = util_strlcpy(path_full, udev_get_sys_path(udev), sizeof(path_full));
path = &path_full[sysfs_len];
if (strcmp(subsystem, "subsystem") == 0) {
- strlcpy(path, "/subsystem/", sizeof(path_full) - sysfs_len);
- strlcat(path, id, sizeof(path_full) - sysfs_len);
+ util_strlcpy(path, "/subsystem/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, id, sizeof(path_full) - sysfs_len);
if (stat(path_full, &statbuf) == 0)
goto found;
- strlcpy(path, "/bus/", sizeof(path_full) - sysfs_len);
- strlcat(path, id, sizeof(path_full) - sysfs_len);
+ util_strlcpy(path, "/bus/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, id, sizeof(path_full) - sysfs_len);
if (stat(path_full, &statbuf) == 0)
goto found;
goto out;
- strlcpy(path, "/class/", sizeof(path_full) - sysfs_len);
- strlcat(path, id, sizeof(path_full) - sysfs_len);
+ util_strlcpy(path, "/class/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, id, sizeof(path_full) - sysfs_len);
if (stat(path_full, &statbuf) == 0)
goto found;
}
if (strcmp(subsystem, "module") == 0) {
- strlcpy(path, "/module/", sizeof(path_full) - sysfs_len);
- strlcat(path, id, sizeof(path_full) - sysfs_len);
+ util_strlcpy(path, "/module/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, id, sizeof(path_full) - sysfs_len);
if (stat(path_full, &statbuf) == 0)
goto found;
goto out;
char subsys[NAME_SIZE];
char *driver;
- strlcpy(subsys, id, sizeof(subsys));
+ util_strlcpy(subsys, id, sizeof(subsys));
driver = strchr(subsys, ':');
if (driver != NULL) {
driver[0] = '\0';
driver = &driver[1];
- strlcpy(path, "/subsystem/", sizeof(path_full) - sysfs_len);
- strlcat(path, subsys, sizeof(path_full) - sysfs_len);
- strlcat(path, "/drivers/", sizeof(path_full) - sysfs_len);
- strlcat(path, driver, sizeof(path_full) - sysfs_len);
+ util_strlcpy(path, "/subsystem/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, subsys, sizeof(path_full) - sysfs_len);
+ util_strlcat(path, "/drivers/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, driver, sizeof(path_full) - sysfs_len);
if (stat(path_full, &statbuf) == 0)
goto found;
- strlcpy(path, "/bus/", sizeof(path_full) - sysfs_len);
- strlcat(path, subsys, sizeof(path_full) - sysfs_len);
- strlcat(path, "/drivers/", sizeof(path_full) - sysfs_len);
- strlcat(path, driver, sizeof(path_full) - sysfs_len);
+ util_strlcpy(path, "/bus/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, subsys, sizeof(path_full) - sysfs_len);
+ util_strlcat(path, "/drivers/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, driver, sizeof(path_full) - sysfs_len);
if (stat(path_full, &statbuf) == 0)
goto found;
}
goto out;
}
- strlcpy(path, "/subsystem/", sizeof(path_full) - sysfs_len);
- strlcat(path, subsystem, sizeof(path_full) - sysfs_len);
- strlcat(path, "/devices/", sizeof(path_full) - sysfs_len);
- strlcat(path, id, sizeof(path_full) - sysfs_len);
+ util_strlcpy(path, "/subsystem/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, subsystem, sizeof(path_full) - sysfs_len);
+ util_strlcat(path, "/devices/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, id, sizeof(path_full) - sysfs_len);
if (stat(path_full, &statbuf) == 0)
goto found;
- strlcpy(path, "/bus/", sizeof(path_full) - sysfs_len);
- strlcat(path, subsystem, sizeof(path_full) - sysfs_len);
- strlcat(path, "/devices/", sizeof(path_full) - sysfs_len);
- strlcat(path, id, sizeof(path_full) - sysfs_len);
+ util_strlcpy(path, "/bus/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, subsystem, sizeof(path_full) - sysfs_len);
+ util_strlcat(path, "/devices/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, id, sizeof(path_full) - sysfs_len);
if (stat(path_full, &statbuf) == 0)
goto found;
- strlcpy(path, "/class/", sizeof(path_full) - sysfs_len);
- strlcat(path, subsystem, sizeof(path_full) - sysfs_len);
- strlcat(path, "/", sizeof(path_full) - sysfs_len);
- strlcat(path, id, sizeof(path_full) - sysfs_len);
+ util_strlcpy(path, "/class/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, subsystem, sizeof(path_full) - sysfs_len);
+ util_strlcat(path, "/", sizeof(path_full) - sysfs_len);
+ util_strlcat(path, id, sizeof(path_full) - sysfs_len);
if (stat(path_full, &statbuf) == 0)
goto found;
out:
found:
if (S_ISLNK(statbuf.st_mode))
sysfs_resolve_link(udev, path, sizeof(path_full) - sysfs_len);
- strlcpy(devpath_full, path, len);
+ util_strlcpy(devpath_full, path, len);
return 1;
}
if (name_new == NULL)
return NULL;
memset(name_new, 0x00, sizeof(struct name_entry));
- strlcpy(name_new->name, name, sizeof(name_new->name));
+ util_strlcpy(name_new->name, name, sizeof(name_new->name));
dbg(udev, "adding '%s'\n", name_new->name);
list_add_tail(&name_new->node, &name_loop->node);
struct stat stats;
int ret;
- strlcpy(p, path, sizeof(p));
+ util_strlcpy(p, path, sizeof(p));
pos = strrchr(p, '/');
if (pos == p || pos == NULL)
return 0;
DIR *dir;
struct dirent *dent;
- strlcpy(path, udev_get_sys_path(udev), sizeof(path));
- strlcat(path, devpath, sizeof(path));
+ util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
+ util_strlcat(path, devpath, sizeof(path));
dir = opendir(path);
if (dir != NULL) {
if (strcmp(dent->d_name, "dev") == 0)
continue;
- strlcpy(filename, path, sizeof(filename));
- strlcat(filename, "/", sizeof(filename));
- strlcat(filename, dent->d_name, sizeof(filename));
+ util_strlcpy(filename, path, sizeof(filename));
+ util_strlcat(filename, "/", sizeof(filename));
+ util_strlcat(filename, dent->d_name, sizeof(filename));
if (lstat(filename, &statbuf) != 0)
continue;
if (S_ISLNK(statbuf.st_mode))
attr_value = sysfs_attr_get_value(udev, devpath, dent->d_name);
if (attr_value == NULL)
continue;
- len = strlcpy(value, attr_value, sizeof(value));
+ len = util_strlcpy(value, attr_value, sizeof(value));
if(len >= sizeof(value))
len = sizeof(value) - 1;
dbg(udev, "attr '%s'='%s'(%zi)\n", dent->d_name, value, len);
info(udev, "found db entry '%s'\n", device->name);
/* make sure, we don't get a link of a different device */
- strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
- strlcat(filename, "/", sizeof(filename));
- strlcat(filename, name, sizeof(filename));
+ util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
+ util_strlcat(filename, "/", sizeof(filename));
+ util_strlcat(filename, name, sizeof(filename));
if (stat(filename, &statbuf) != 0)
goto next;
if (major(udevice_loop->devt) > 0 && udevice_loop->devt != statbuf.st_rdev) {
case 'n':
/* remove /dev if given */
if (strncmp(optarg, udev_get_dev_path(udev), strlen(udev_get_dev_path(udev))) == 0)
- strlcpy(name, &optarg[strlen(udev_get_dev_path(udev))+1], sizeof(name));
+ util_strlcpy(name, &optarg[strlen(udev_get_dev_path(udev))+1], sizeof(name));
else
- strlcpy(name, optarg, sizeof(name));
+ util_strlcpy(name, optarg, sizeof(name));
util_remove_trailing_chars(name, '/');
dbg(udev, "name: %s\n", name);
break;
case 'p':
/* remove /sys if given */
if (strncmp(optarg, udev_get_sys_path(udev), strlen(udev_get_sys_path(udev))) == 0)
- strlcpy(path, &optarg[strlen(udev_get_sys_path(udev))], sizeof(path));
+ util_strlcpy(path, &optarg[strlen(udev_get_sys_path(udev))], sizeof(path));
else
- strlcpy(path, optarg, sizeof(path));
+ util_strlcpy(path, optarg, sizeof(path));
util_remove_trailing_chars(path, '/');
/* possibly resolve to real devpath */
char *pos;
/* also check if the parent is a link */
- strlcpy(temp, path, sizeof(temp));
+ util_strlcpy(temp, path, sizeof(temp));
pos = strrchr(temp, '/');
if (pos != 0) {
char tail[PATH_SIZE];
- strlcpy(tail, pos, sizeof(tail));
+ util_strlcpy(tail, pos, sizeof(tail));
pos[0] = '\0';
if (sysfs_resolve_link(udev, temp, sizeof(temp)) == 0) {
- strlcpy(path, temp, sizeof(path));
- strlcat(path, tail, sizeof(path));
+ util_strlcpy(path, temp, sizeof(path));
+ util_strlcat(path, tail, sizeof(path));
}
}
}
break;
case 'd':
action = ACTION_DEVICE_ID_FILE;
- strlcpy(name, optarg, sizeof(name));
+ util_strlcpy(name, optarg, sizeof(name));
break;
case 'a':
action = ACTION_ATTRIBUTE_WALK;
}
}
- strlcpy(queuename, udev_get_dev_path(udev), sizeof(queuename));
- strlcat(queuename, "/.udev/queue", sizeof(queuename));
+ util_strlcpy(queuename, udev_get_dev_path(udev), sizeof(queuename));
+ util_strlcat(queuename, "/.udev/queue", sizeof(queuename));
loop = timeout * LOOP_PER_SECOND;
while (loop--) {
}
/* read current udev seqnum */
- strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
- strlcat(filename, "/.udev/uevent_seqnum", sizeof(filename));
+ util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
+ util_strlcat(filename, "/.udev/uevent_seqnum", sizeof(filename));
fd = open(filename, O_RDONLY);
if (fd < 0)
goto exit;
info(udev, "udev seqnum = %llu\n", seq_udev);
/* read current kernel seqnum */
- strlcpy(filename, udev_get_sys_path(udev), sizeof(filename));
- strlcat(filename, "/kernel/uevent_seqnum", sizeof(filename));
+ util_strlcpy(filename, udev_get_sys_path(udev), sizeof(filename));
+ util_strlcat(filename, "/kernel/uevent_seqnum", sizeof(filename));
fd = open(filename, O_RDONLY);
if (fd < 0)
goto exit;
int rc = -1;
/* read uevent file */
- strlcpy(path, udev_get_sys_path(udev), sizeof(path));
- strlcat(path, devpath, sizeof(path));
- strlcat(path, "/uevent", sizeof(path));
+ util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
+ util_strlcat(path, devpath, sizeof(path));
+ util_strlcat(path, "/uevent", sizeof(path));
fd = open(path, O_RDONLY);
if (fd < 0)
goto out;
}
if (subsystem != NULL)
- strlcpy(dev->subsystem, subsystem, sizeof(dev->subsystem));
+ util_strlcpy(dev->subsystem, subsystem, sizeof(dev->subsystem));
/* override built-in sysfs device */
udevice->dev = dev;
- strlcpy(udevice->action, action, sizeof(udevice->action));
+ util_strlcpy(udevice->action, action, sizeof(udevice->action));
udevice->devt = udev_device_get_devt(udevice);
/* simulate node creation with test flag */
list_for_each_entry(name_loop, &udevice->run_list, node) {
char program[PATH_SIZE];
- strlcpy(program, name_loop->name, sizeof(program));
+ util_strlcpy(program, name_loop->name, sizeof(program));
udev_rules_apply_format(udevice, program, sizeof(program));
info(udev, "run: '%s'\n", program);
}
dbg(udev, "add '%s'\n" , path);
/* we only have a device, if we have an uevent file */
- strlcpy(filename, path, sizeof(filename));
- strlcat(filename, "/uevent", sizeof(filename));
+ util_strlcpy(filename, path, sizeof(filename));
+ util_strlcat(filename, "/uevent", sizeof(filename));
if (stat(filename, &statbuf) < 0)
return -1;
if (!(statbuf.st_mode & S_IWUSR))
return -1;
- strlcpy(devpath, &path[strlen(udev_get_sys_path(udev))], sizeof(devpath));
+ util_strlcpy(devpath, &path[strlen(udev_get_sys_path(udev))], sizeof(devpath));
/* resolve possible link to real target */
if (lstat(path, &statbuf) < 0)
char filename[PATH_SIZE];
int fd;
- strlcpy(filename, udev_get_sys_path(udev), sizeof(filename));
- strlcat(filename, devpath, sizeof(filename));
- strlcat(filename, "/uevent", sizeof(filename));
+ util_strlcpy(filename, udev_get_sys_path(udev), sizeof(filename));
+ util_strlcat(filename, devpath, sizeof(filename));
+ util_strlcat(filename, "/uevent", sizeof(filename));
if (verbose)
printf("%s\n", devpath);
bufpos++;
/* add subsystem */
- strlcpy(path, udev_get_sys_path(udev), sizeof(path));
- strlcat(path, devpath, sizeof(path));
- strlcat(path, "/subsystem", sizeof(path));
+ util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
+ util_strlcat(path, devpath, sizeof(path));
+ util_strlcat(path, "/subsystem", sizeof(path));
len = readlink(path, link_target, sizeof(link_target));
if (len > 0) {
char *pos;
/* add symlinks and node name */
path[0] = '\0';
list_for_each_entry(name_loop, &udevice->symlink_list, node) {
- strlcat(path, udev_get_dev_path(udev), sizeof(path));
- strlcat(path, "/", sizeof(path));
- strlcat(path, name_loop->name, sizeof(path));
- strlcat(path, " ", sizeof(path));
+ util_strlcat(path, udev_get_dev_path(udev), sizeof(path));
+ util_strlcat(path, "/", sizeof(path));
+ util_strlcat(path, name_loop->name, sizeof(path));
+ util_strlcat(path, " ", sizeof(path));
}
util_remove_trailing_chars(path, ' ');
if (path[0] != '\0') {
bufpos++;
}
if (udevice->name[0] != '\0') {
- strlcpy(path, udev_get_dev_path(udev), sizeof(path));
- strlcat(path, "/", sizeof(path));
- strlcat(path, udevice->name, sizeof(path));
+ util_strlcpy(path, udev_get_dev_path(udev), sizeof(path));
+ util_strlcat(path, "/", sizeof(path));
+ util_strlcat(path, udevice->name, sizeof(path));
bufpos += snprintf(&buf[bufpos], sizeof(buf)-1, "DEVNAME=%s", path);
bufpos++;
}
/* add keys from device "uevent" file */
- strlcpy(path, udev_get_sys_path(udev), sizeof(path));
- strlcat(path, devpath, sizeof(path));
- strlcat(path, "/uevent", sizeof(path));
+ util_strlcpy(path, udev_get_sys_path(udev), sizeof(path));
+ util_strlcat(path, devpath, sizeof(path));
+ util_strlcat(path, "/uevent", sizeof(path));
fd = open(path, O_RDONLY);
if (fd >= 0) {
char value[4096];
if (next == NULL)
break;
next[0] = '\0';
- bufpos += strlcpy(&buf[bufpos], key, sizeof(buf) - bufpos-1);
+ bufpos += util_strlcpy(&buf[bufpos], key, sizeof(buf) - bufpos-1);
bufpos++;
key = &next[1];
}
/* add keys from database */
list_for_each_entry(name_loop, &udevice->env_list, node) {
- bufpos += strlcpy(&buf[bufpos], name_loop->name, sizeof(buf) - bufpos-1);
+ bufpos += util_strlcpy(&buf[bufpos], name_loop->name, sizeof(buf) - bufpos-1);
bufpos++;
}
if (bufpos > sizeof(buf))
char file[PATH_SIZE];
char *match_value;
- strlcpy(attr, attr_value, sizeof(attr));
+ util_strlcpy(attr, attr_value, sizeof(attr));
/* separate attr and match value */
match_value = strchr(attr, '=');
match_value = &match_value[1];
}
- strlcpy(file, path, sizeof(file));
- strlcat(file, "/", sizeof(file));
- strlcat(file, attr, sizeof(file));
+ util_strlcpy(file, path, sizeof(file));
+ util_strlcat(file, "/", sizeof(file));
+ util_strlcat(file, attr, sizeof(file));
if (match_value != NULL) {
/* match file content */
else
return;
- strlcpy(base, udev_get_sys_path(udev), sizeof(base));
- strlcat(base, "/", sizeof(base));
- strlcat(base, subsys, sizeof(base));
+ util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
+ util_strlcat(base, "/", sizeof(base));
+ util_strlcat(base, subsys, sizeof(base));
dir = opendir(base);
if (dir != NULL) {
if (subsystem_filtered(dent->d_name))
continue;
- strlcpy(dirname, base, sizeof(dirname));
- strlcat(dirname, "/", sizeof(dirname));
- strlcat(dirname, dent->d_name, sizeof(dirname));
+ util_strlcpy(dirname, base, sizeof(dirname));
+ util_strlcat(dirname, "/", sizeof(dirname));
+ util_strlcat(dirname, dent->d_name, sizeof(dirname));
if (scan == SCAN_SUBSYSTEM) {
if (attr_filtered(dirname))
continue;
}
- strlcat(dirname, subdir, sizeof(dirname));
+ util_strlcat(dirname, subdir, sizeof(dirname));
/* look for devices/drivers */
dir2 = opendir(dirname);
if (dent2->d_name[0] == '.')
continue;
- strlcpy(dirname2, dirname, sizeof(dirname2));
- strlcat(dirname2, "/", sizeof(dirname2));
- strlcat(dirname2, dent2->d_name, sizeof(dirname2));
+ util_strlcpy(dirname2, dirname, sizeof(dirname2));
+ util_strlcat(dirname2, "/", sizeof(dirname2));
+ util_strlcat(dirname2, dent2->d_name, sizeof(dirname2));
if (attr_filtered(dirname2))
continue;
device_list_insert(udev, dirname2);
if (subsystem_filtered("block"))
return;
- strlcpy(base, udev_get_sys_path(udev), sizeof(base));
- strlcat(base, "/block", sizeof(base));
+ util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
+ util_strlcat(base, "/block", sizeof(base));
dir = opendir(base);
if (dir != NULL) {
if (dent->d_name[0] == '.')
continue;
- strlcpy(dirname, base, sizeof(dirname));
- strlcat(dirname, "/", sizeof(dirname));
- strlcat(dirname, dent->d_name, sizeof(dirname));
+ util_strlcpy(dirname, base, sizeof(dirname));
+ util_strlcat(dirname, "/", sizeof(dirname));
+ util_strlcat(dirname, dent->d_name, sizeof(dirname));
if (attr_filtered(dirname))
continue;
if (device_list_insert(udev, dirname) != 0)
if (!strcmp(dent2->d_name,"device"))
continue;
- strlcpy(dirname2, dirname, sizeof(dirname2));
- strlcat(dirname2, "/", sizeof(dirname2));
- strlcat(dirname2, dent2->d_name, sizeof(dirname2));
+ util_strlcpy(dirname2, dirname, sizeof(dirname2));
+ util_strlcat(dirname2, "/", sizeof(dirname2));
+ util_strlcat(dirname2, dent2->d_name, sizeof(dirname2));
if (attr_filtered(dirname2))
continue;
device_list_insert(udev, dirname2);
DIR *dir;
struct dirent *dent;
- strlcpy(base, udev_get_sys_path(udev), sizeof(base));
- strlcat(base, "/class", sizeof(base));
+ util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
+ util_strlcat(base, "/class", sizeof(base));
dir = opendir(base);
if (dir != NULL) {
if (subsystem_filtered(dent->d_name))
continue;
- strlcpy(dirname, base, sizeof(dirname));
- strlcat(dirname, "/", sizeof(dirname));
- strlcat(dirname, dent->d_name, sizeof(dirname));
+ util_strlcpy(dirname, base, sizeof(dirname));
+ util_strlcat(dirname, "/", sizeof(dirname));
+ util_strlcat(dirname, dent->d_name, sizeof(dirname));
dir2 = opendir(dirname);
if (dir2 != NULL) {
for (dent2 = readdir(dir2); dent2 != NULL; dent2 = readdir(dir2)) {
if (!strcmp(dent2->d_name, "device"))
continue;
- strlcpy(dirname2, dirname, sizeof(dirname2));
- strlcat(dirname2, "/", sizeof(dirname2));
- strlcat(dirname2, dent2->d_name, sizeof(dirname2));
+ util_strlcpy(dirname2, dirname, sizeof(dirname2));
+ util_strlcat(dirname2, "/", sizeof(dirname2));
+ util_strlcat(dirname2, dent2->d_name, sizeof(dirname2));
if (attr_filtered(dirname2))
continue;
device_list_insert(udev, dirname2);
DIR *dir;
struct dirent *dent;
- strlcpy(base, udev_get_dev_path(udev), sizeof(base));
- strlcat(base, "/.udev/failed", sizeof(base));
+ util_strlcpy(base, udev_get_dev_path(udev), sizeof(base));
+ util_strlcat(base, "/.udev/failed", sizeof(base));
dir = opendir(base);
if (dir != NULL) {
if (dent->d_name[0] == '.')
continue;
- start = strlcpy(device, udev_get_sys_path(udev), sizeof(device));
+ start = util_strlcpy(device, udev_get_sys_path(udev), sizeof(device));
if(start >= sizeof(device))
start = sizeof(device) - 1;
- strlcat(device, dent->d_name, sizeof(device));
+ util_strlcat(device, dent->d_name, sizeof(device));
util_path_decode(&device[start]);
device_list_insert(udev, device);
}
saddr.sun_family = AF_LOCAL;
if (sockpath[0] == '@') {
/* abstract namespace socket requested */
- strlcpy(&saddr.sun_path[1], &sockpath[1], sizeof(saddr.sun_path)-1);
+ util_strlcpy(&saddr.sun_path[1], &sockpath[1], sizeof(saddr.sun_path)-1);
saddrlen = offsetof(struct sockaddr_un, sun_path) + 1 + strlen(&saddr.sun_path[1]);
} else if (stat(sockpath, &stats) == 0 && S_ISSOCK(stats.st_mode)) {
/* existing socket file */
- strlcpy(saddr.sun_path, sockpath, sizeof(saddr.sun_path));
+ util_strlcpy(saddr.sun_path, sockpath, sizeof(saddr.sun_path));
saddrlen = offsetof(struct sockaddr_un, sun_path) + strlen(saddr.sun_path);
} else {
/* no socket file, assume abstract namespace socket */
- strlcpy(&saddr.sun_path[1], sockpath, sizeof(saddr.sun_path)-1);
+ util_strlcpy(&saddr.sun_path[1], sockpath, sizeof(saddr.sun_path)-1);
saddrlen = offsetof(struct sockaddr_un, sun_path) + 1 + strlen(&saddr.sun_path[1]);
}
} else if (env != NULL) {
struct stat statbuf;
/* if we have /sys/subsystem, forget all the old stuff */
- strlcpy(base, udev_get_sys_path(udev), sizeof(base));
- strlcat(base, "/subsystem", sizeof(base));
+ util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
+ util_strlcat(base, "/subsystem", sizeof(base));
if (stat(base, &statbuf) == 0) {
scan_subsystem(udev, "subsystem", SCAN_SUBSYSTEM);
exec_list(udev, action, env);
scan_class(udev);
/* scan "block" if it isn't a "class" */
- strlcpy(base, udev_get_sys_path(udev), sizeof(base));
- strlcat(base, "/class/block", sizeof(base));
+ util_strlcpy(base, udev_get_sys_path(udev), sizeof(base));
+ util_strlcat(base, "/class/block", sizeof(base));
if (stat(base, &statbuf) != 0)
scan_block(udev);
exec_list(udev, action, env);
udevice = udev_device_init(msg->udev);
if (udevice == NULL)
return -1;
- strlcpy(udevice->action, msg->action, sizeof(udevice->action));
+ util_strlcpy(udevice->action, msg->action, sizeof(udevice->action));
sysfs_device_set_values(udevice->udev, udevice->dev, msg->devpath, msg->subsystem, msg->driver);
udevice->devpath_old = msg->devpath_old;
udevice->devt = msg->devt;
snprintf(filename, sizeof(filename), "%s/.udev/queue/%llu", udev_get_dev_path(msg->udev), msg->seqnum);
/* location of failed file */
- strlcpy(filename_failed, udev_get_dev_path(msg->udev), sizeof(filename_failed));
- strlcat(filename_failed, "/", sizeof(filename_failed));
- start = strlcat(filename_failed, ".udev/failed/", sizeof(filename_failed));
- strlcat(filename_failed, msg->devpath, sizeof(filename_failed));
+ util_strlcpy(filename_failed, udev_get_dev_path(msg->udev), sizeof(filename_failed));
+ util_strlcat(filename_failed, "/", sizeof(filename_failed));
+ start = util_strlcat(filename_failed, ".udev/failed/", sizeof(filename_failed));
+ util_strlcat(filename_failed, msg->devpath, sizeof(filename_failed));
util_path_encode(&filename_failed[start], sizeof(filename_failed) - start);
switch (state) {
/* "move" event - rename failed file to current name, do not delete failed */
char filename_failed_old[PATH_SIZE];
- strlcpy(filename_failed_old, udev_get_dev_path(msg->udev), sizeof(filename_failed_old));
- strlcat(filename_failed_old, "/", sizeof(filename_failed_old));
- start = strlcat(filename_failed_old, ".udev/failed/", sizeof(filename_failed_old));
- strlcat(filename_failed_old, msg->devpath_old, sizeof(filename_failed_old));
+ util_strlcpy(filename_failed_old, udev_get_dev_path(msg->udev), sizeof(filename_failed_old));
+ util_strlcat(filename_failed_old, "/", sizeof(filename_failed_old));
+ start = util_strlcat(filename_failed_old, ".udev/failed/", sizeof(filename_failed_old));
+ util_strlcat(filename_failed_old, msg->devpath_old, sizeof(filename_failed_old));
util_path_encode(&filename_failed_old[start], sizeof(filename) - start);
if (rename(filename_failed_old, filename_failed) == 0)
export_event_state(msg, EVENT_QUEUED);
info(msg->udev, "seq %llu queued, '%s' '%s'\n", msg->seqnum, msg->action, msg->subsystem);
- strlcpy(filename, udev_get_dev_path(msg->udev), sizeof(filename));
- strlcat(filename, "/.udev/uevent_seqnum", sizeof(filename));
+ util_strlcpy(filename, udev_get_dev_path(msg->udev), sizeof(filename));
+ util_strlcat(filename, "/.udev/uevent_seqnum", sizeof(filename));
fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0644);
if (fd >= 0) {
char str[32];
char seqnum[32];
ssize_t len = 0;
- strlcpy(filename, udev_get_sys_path(udev), sizeof(filename));
- strlcat(filename, "/kernel/uevent_seqnum", sizeof(filename));
+ util_strlcpy(filename, udev_get_sys_path(udev), sizeof(filename));
+ util_strlcat(filename, "/kernel/uevent_seqnum", sizeof(filename));
fd = open(filename, O_RDONLY);
if (fd >= 0) {
len = read(fd, seqnum, sizeof(seqnum)-1);
strcpy(seqnum, "0\n");
len = 3;
}
- strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
- strlcat(filename, "/.udev/uevent_seqnum", sizeof(filename));
+ util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
+ util_strlcat(filename, "/.udev/uevent_seqnum", sizeof(filename));
create_path(udev, filename);
fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0644);
if (fd >= 0) {
IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
/* watch dynamic rules directory */
- strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
- strlcat(filename, "/.udev/rules.d", sizeof(filename));
+ util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
+ util_strlcat(filename, "/.udev/rules.d", sizeof(filename));
inotify_add_watch(inotify_fd, filename,
IN_CREATE | IN_DELETE | IN_MOVE | IN_CLOSE_WRITE);
}
~ianmdlvl / elogind.git / commitdiff