libudev: list - use bit flags for 'sort' and 'unique'

diff --git a/Makefile.am b/Makefile.am
index 5ddf83acab3f48d30b2e3ab440cb30e827747ac0..2aff45e2a912b937deb3f45341235f5b47bbd99a 100644 (file)
--- a/Makefile.am
+++ b/Makefile.am
@@ -35,7 +35,7 @@ DISTCHECK_HOOKS =
 # libudev
 # ------------------------------------------------------------------------------
 LIBUDEV_CURRENT=11
-LIBUDEV_REVISION=2
+LIBUDEV_REVISION=3
 LIBUDEV_AGE=11
 
 SUBDIRS += libudev/docs

diff --git a/libudev/libudev-device-private.c b/libudev/libudev-device-private.c
index ee9e297cea2ef21770841f16ec932587c1917eef..b78b6c9553503b61e0c9aa07731c6ce2b894b2da 100644 (file)
--- a/libudev/libudev-device-private.c
+++ b/libudev/libudev-device-private.c
@@ -86,7 +86,7 @@ static bool device_has_info(struct udev_device *udev_device)
        if (udev_device_get_devlink_priority(udev_device) != 0)
                return true;
        udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(udev_device))
-               if (udev_list_entry_get_flags(list_entry))
+               if (udev_list_entry_get_num(list_entry))
                        return true;
        if (udev_device_get_tags_list_entry(udev_device) != NULL)
                return true;
@@ -157,7 +157,7 @@ int udev_device_update_db(struct udev_device *udev_device)
                if (udev_device_get_usec_initialized(udev_device) > 0)
                        fprintf(f, "I:%llu\n", udev_device_get_usec_initialized(udev_device));
                udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(udev_device)) {
-                       if (!udev_list_entry_get_flags(list_entry))
+                       if (!udev_list_entry_get_num(list_entry))
                                continue;
                        fprintf(f, "E:%s=%s\n",
                                udev_list_entry_get_name(list_entry),

diff --git a/libudev/libudev-device.c b/libudev/libudev-device.c
index 0ef7260de223a78615b3831cd83906953e090a6e..ffde21ad57d9d5274b56ff6871a4c30cfa19dcd1 100644 (file)
--- a/libudev/libudev-device.c
+++ b/libudev/libudev-device.c
@@ -103,7 +103,7 @@ struct udev_list_entry *udev_device_add_property(struct udev_device *udev_device
                        udev_list_entry_delete(list_entry);
                return NULL;
        }
-       return udev_list_entry_add(udev_device->udev, &udev_device->properties_list, key, value, 1, 0);
+       return udev_list_entry_add(udev_device->udev, &udev_device->properties_list, key, value, UDEV_LIST_UNIQUE);
 }
 
 static struct udev_list_entry *udev_device_add_property_from_string(struct udev_device *udev_device, const char *property)
@@ -289,7 +289,7 @@ int udev_device_read_db(struct udev_device *udev_device, const char *dbfile)
                        break;
                case 'E':
                        entry = udev_device_add_property_from_string(udev_device, val);
-                       udev_list_entry_set_flags(entry, 1);
+                       udev_list_entry_set_num(entry, true);
                        break;
                case 'G':
                        udev_device_add_tag(udev_device, val);
@@ -1216,7 +1216,7 @@ const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const
        util_strscpyl(path, sizeof(path), udev_device_get_syspath(udev_device), "/", sysattr, NULL);
        if (lstat(path, &statbuf) != 0) {
                dbg(udev_device->udev, "no attribute '%s', keep negative entry\n", path);
-               udev_list_entry_add(udev_device->udev, &udev_device->sysattr_value_list, sysattr, NULL, 0, 0);
+               udev_list_entry_add(udev_device->udev, &udev_device->sysattr_value_list, sysattr, NULL, 0);
                goto out;
        }
 
@@ -1240,7 +1240,7 @@ const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const
                if (pos != NULL) {
                        pos = &pos[1];
                        dbg(udev_device->udev, "cache '%s' with link value '%s'\n", sysattr, pos);
-                       list_entry = udev_list_entry_add(udev_device->udev, &udev_device->sysattr_value_list, sysattr, pos, 0, 0);
+                       list_entry = udev_list_entry_add(udev_device->udev, &udev_device->sysattr_value_list, sysattr, pos, 0);
                        val = udev_list_entry_get_value(list_entry);
                }
 
@@ -1272,7 +1272,7 @@ const char *udev_device_get_sysattr_value(struct udev_device *udev_device, const
        value[size] = '\0';
        util_remove_trailing_chars(value, '\n');
        dbg(udev_device->udev, "'%s' has attribute value '%s'\n", path, value);
-       list_entry = udev_list_entry_add(udev_device->udev, &udev_device->sysattr_value_list, sysattr, value, 0, 0);
+       list_entry = udev_list_entry_add(udev_device->udev, &udev_device->sysattr_value_list, sysattr, value, 0);
        val = udev_list_entry_get_value(list_entry);
 out:
        return val;
@@ -1311,7 +1311,7 @@ static int udev_device_sysattr_list_read(struct udev_device *udev_device)
                        continue;
 
                udev_list_entry_add(udev_device->udev, &udev_device->sysattr_list,
-                                   dent->d_name, NULL, 0, 0);
+                                   dent->d_name, NULL, 0);
                num++;
        }
 
@@ -1419,11 +1419,11 @@ int udev_device_add_devlink(struct udev_device *udev_device, const char *devlink
        struct udev_list_entry *list_entry;
 
        udev_device->devlinks_uptodate = false;
-       list_entry = udev_list_entry_add(udev_device->udev, &udev_device->devlinks_list, devlink, NULL, 1, 0);
+       list_entry = udev_list_entry_add(udev_device->udev, &udev_device->devlinks_list, devlink, NULL, UDEV_LIST_UNIQUE);
        if (list_entry == NULL)
                return -ENOMEM;
        if (unique)
-               udev_list_entry_set_flags(list_entry, 1);
+               udev_list_entry_set_num(list_entry, true);
        return 0;
 }
 
@@ -1491,7 +1491,7 @@ int udev_device_add_tag(struct udev_device *udev_device, const char *tag)
        if (strchr(tag, ':') != NULL || strchr(tag, ' ') != NULL)
                return -EINVAL;
        udev_device->tags_uptodate = false;
-       if (udev_list_entry_add(udev_device->udev, &udev_device->tags_list, tag, NULL, 1, 0) != NULL)
+       if (udev_list_entry_add(udev_device->udev, &udev_device->tags_list, tag, NULL, UDEV_LIST_UNIQUE) != NULL)
                return 0;
        return -ENOMEM;
 }

diff --git a/libudev/libudev-enumerate.c b/libudev/libudev-enumerate.c
index 6870bb611598a3f752b67d2301624a4506c00869..018d89cc049e73ca8be500474cc68c52c978c524 100644 (file)
--- a/libudev/libudev-enumerate.c
+++ b/libudev/libudev-enumerate.c
@@ -295,24 +295,24 @@ struct udev_list_entry *udev_enumerate_get_list_entry(struct udev_enumerate *ude
                            strncmp(entry->syspath, move_later->syspath, move_later_prefix) != 0) {
 
                                udev_list_entry_add(udev_enumerate->udev, &udev_enumerate->devices_list,
-                                           move_later->syspath, NULL, 0, 0);
+                                           move_later->syspath, NULL, 0);
                                move_later = NULL;
                        }
 
                        udev_list_entry_add(udev_enumerate->udev, &udev_enumerate->devices_list,
-                                           entry->syspath, NULL, 0, 0);
+                                           entry->syspath, NULL, 0);
                }
 
                if (move_later)
                        udev_list_entry_add(udev_enumerate->udev, &udev_enumerate->devices_list,
-                                           move_later->syspath, NULL, 0, 0);
+                                           move_later->syspath, NULL, 0);
 
                /* add and cleanup delayed devices from end of list */
                for (i = max; i < udev_enumerate->devices_cur; i++) {
                        struct syspath *entry = &udev_enumerate->devices[i];
 
                        udev_list_entry_add(udev_enumerate->udev, &udev_enumerate->devices_list,
-                                           entry->syspath, NULL, 0, 0);
+                                           entry->syspath, NULL, 0);
                        free(entry->syspath);
                }
                udev_enumerate->devices_cur = max;
@@ -336,7 +336,7 @@ int udev_enumerate_add_match_subsystem(struct udev_enumerate *udev_enumerate, co
        if (subsystem == NULL)
                return 0;
        if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
-                               &udev_enumerate->subsystem_match_list, subsystem, NULL, 1, 0) == NULL)
+                               &udev_enumerate->subsystem_match_list, subsystem, NULL, UDEV_LIST_UNIQUE) == NULL)
                return -ENOMEM;
        return 0;
 }
@@ -355,7 +355,7 @@ int udev_enumerate_add_nomatch_subsystem(struct udev_enumerate *udev_enumerate,
        if (subsystem == NULL)
                return 0;
        if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
-                               &udev_enumerate->subsystem_nomatch_list, subsystem, NULL, 1, 0) == NULL)
+                               &udev_enumerate->subsystem_nomatch_list, subsystem, NULL, UDEV_LIST_UNIQUE) == NULL)
                return -ENOMEM;
        return 0;
 }
@@ -375,7 +375,7 @@ int udev_enumerate_add_match_sysattr(struct udev_enumerate *udev_enumerate, cons
        if (sysattr == NULL)
                return 0;
        if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
-                          &udev_enumerate->sysattr_match_list, sysattr, value, 0, 0) == NULL)
+                               &udev_enumerate->sysattr_match_list, sysattr, value, 0) == NULL)
                return -ENOMEM;
        return 0;
 }
@@ -395,7 +395,7 @@ int udev_enumerate_add_nomatch_sysattr(struct udev_enumerate *udev_enumerate, co
        if (sysattr == NULL)
                return 0;
        if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
-                          &udev_enumerate->sysattr_nomatch_list, sysattr, value, 0, 0) == NULL)
+                          &udev_enumerate->sysattr_nomatch_list, sysattr, value, 0) == NULL)
                return -ENOMEM;
        return 0;
 }
@@ -435,7 +435,7 @@ int udev_enumerate_add_match_property(struct udev_enumerate *udev_enumerate, con
        if (property == NULL)
                return 0;
        if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
-                               &udev_enumerate->properties_match_list, property, value, 0, 0) == NULL)
+                               &udev_enumerate->properties_match_list, property, value, 0) == NULL)
                return -ENOMEM;
        return 0;
 }
@@ -454,7 +454,7 @@ int udev_enumerate_add_match_tag(struct udev_enumerate *udev_enumerate, const ch
        if (tag == NULL)
                return 0;
        if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
-                               &udev_enumerate->tags_match_list, tag, NULL, 1, 0) == NULL)
+                               &udev_enumerate->tags_match_list, tag, NULL, UDEV_LIST_UNIQUE) == NULL)
                return -ENOMEM;
        return 0;
 }
@@ -499,7 +499,7 @@ int udev_enumerate_add_match_sysname(struct udev_enumerate *udev_enumerate, cons
        if (sysname == NULL)
                return 0;
        if (udev_list_entry_add(udev_enumerate_get_udev(udev_enumerate),
-                               &udev_enumerate->sysname_match_list, sysname, NULL, 1, 0) == NULL)
+                               &udev_enumerate->sysname_match_list, sysname, NULL, UDEV_LIST_UNIQUE) == NULL)
                return -ENOMEM;
        return 0;
 }

diff --git a/libudev/libudev-list.c b/libudev/libudev-list.c
index b5e96458cc26657d3333b39b5ef2734f65531ae4..29453ac251fc391b64534b5c27f4cb49c6b0118a 100644 (file)
--- a/libudev/libudev-list.c
+++ b/libudev/libudev-list.c
@@ -38,10 +38,10 @@ struct udev_list_entry {
        struct udev_list_node *list;
        char *name;
        char *value;
-       unsigned int flags;
+       int num;
 };
 
-/* list head point to itself if empty */
+/* the list's head points to itself if empty */
 void udev_list_init(struct udev_list_node *list)
 {
        list->next = list;
@@ -114,12 +114,12 @@ void udev_list_entry_insert_before(struct udev_list_entry *new, struct udev_list
 
 struct udev_list_entry *udev_list_entry_add(struct udev *udev, struct udev_list_node *list,
                                            const char *name, const char *value,
-                                           int unique, int sort)
+                                           unsigned int flags)
 {
        struct udev_list_entry *entry_loop = NULL;
        struct udev_list_entry *entry_new;
 
-       if (unique)
+       if (flags & UDEV_LIST_UNIQUE) {
                udev_list_entry_foreach(entry_loop, udev_list_get_entry(list)) {
                        if (strcmp(entry_loop->name, name) == 0) {
                                dbg(udev, "'%s' is already in the list\n", name);
@@ -136,12 +136,14 @@ struct udev_list_entry *udev_list_entry_add(struct udev *udev, struct udev_list_
                                return entry_loop;
                        }
                }
+       }
 
-       if (sort)
+       if (flags & UDEV_LIST_SORT) {
                udev_list_entry_foreach(entry_loop, udev_list_get_entry(list)) {
                        if (strcmp(entry_loop->name, name) > 0)
                                break;
                }
+       }
 
        entry_new = malloc(sizeof(struct udev_list_entry));
        if (entry_new == NULL)
@@ -153,6 +155,7 @@ struct udev_list_entry *udev_list_entry_add(struct udev *udev, struct udev_list_
                free(entry_new);
                return NULL;
        }
+
        if (value != NULL) {
                entry_new->value = strdup(value);
                if (entry_new->value == NULL) {
@@ -161,10 +164,12 @@ struct udev_list_entry *udev_list_entry_add(struct udev *udev, struct udev_list_
                        return NULL;
                }
        }
+
        if (entry_loop != NULL)
                udev_list_entry_insert_before(entry_new, entry_loop);
        else
                udev_list_entry_append(entry_new, list);
+
        dbg(udev, "'%s=%s' added\n", entry_new->name, entry_new->value);
        return entry_new;
 }
@@ -258,16 +263,16 @@ const char *udev_list_entry_get_value(struct udev_list_entry *list_entry)
        return list_entry->value;
 }
 
-unsigned int udev_list_entry_get_flags(struct udev_list_entry *list_entry)
+int udev_list_entry_get_num(struct udev_list_entry *list_entry)
 {
        if (list_entry == NULL)
                return -EINVAL;
-       return list_entry->flags;
+       return list_entry->num;
 }
 
-void udev_list_entry_set_flags(struct udev_list_entry *list_entry, unsigned int flags)
+void udev_list_entry_set_num(struct udev_list_entry *list_entry, int num)
 {
        if (list_entry == NULL)
                return;
-       list_entry->flags = flags;
+       list_entry->num = num;
 }

diff --git a/libudev/libudev-monitor.c b/libudev/libudev-monitor.c
index d890b4b142bd5f1dba57ce8fb02712ad20715784..5917b9e497ce03347138e688fd97dd0f78f0a2ec 100644 (file)
--- a/libudev/libudev-monitor.c
+++ b/libudev/libudev-monitor.c
@@ -830,7 +830,7 @@ int udev_monitor_filter_add_match_subsystem_devtype(struct udev_monitor *udev_mo
        if (subsystem == NULL)
                return -EINVAL;
        if (udev_list_entry_add(udev_monitor->udev,
-                               &udev_monitor->filter_subsystem_list, subsystem, devtype, 0, 0) == NULL)
+                               &udev_monitor->filter_subsystem_list, subsystem, devtype, 0) == NULL)
                return -ENOMEM;
        return 0;
 }
@@ -854,7 +854,7 @@ int udev_monitor_filter_add_match_tag(struct udev_monitor *udev_monitor, const c
        if (tag == NULL)
                return -EINVAL;
        if (udev_list_entry_add(udev_monitor->udev,
-                               &udev_monitor->filter_tag_list, tag, NULL, 0, 0) == NULL)
+                               &udev_monitor->filter_tag_list, tag, NULL, 0) == NULL)
                return -ENOMEM;
        return 0;
 }

diff --git a/libudev/libudev-private.h b/libudev/libudev-private.h
index c47bbce2d6ee0fa5335b50150e416112629b6f53..dbe7fd17fc5c12670b9542290f263cee0baf4939 100644 (file)
--- a/libudev/libudev-private.h
+++ b/libudev/libudev-private.h
@@ -157,6 +157,11 @@ const char *udev_ctrl_get_set_env(struct udev_ctrl_msg *ctrl_msg);
 int udev_ctrl_get_set_children_max(struct udev_ctrl_msg *ctrl_msg);
 
 /* libudev-list.c */
+enum udev_list_flags {
+       UDEV_LIST_NONE =        0,
+       UDEV_LIST_UNIQUE =      1,
+       UDEV_LIST_SORT =        1 << 1,
+};
 struct udev_list_node {
        struct udev_list_node *next, *prev;
 };
@@ -174,16 +179,15 @@ void udev_list_node_remove(struct udev_list_node *entry);
             node != list; \
             node = tmp, tmp = (tmp)->next)
 struct udev_list_entry *udev_list_entry_add(struct udev *udev, struct udev_list_node *list,
-                                                  const char *name, const char *value,
-                                                  int unique, int sort);
+                                                  const char *name, const char *value, unsigned int flags);
 void udev_list_entry_delete(struct udev_list_entry *entry);
 void udev_list_entry_remove(struct udev_list_entry *entry);
 void udev_list_entry_insert_before(struct udev_list_entry *new, struct udev_list_entry *entry);
 void udev_list_entry_append(struct udev_list_entry *new, struct udev_list_node *list);
 void udev_list_cleanup_entries(struct udev *udev, struct udev_list_node *name_list);
 struct udev_list_entry *udev_list_get_entry(struct udev_list_node *list);
-unsigned int udev_list_entry_get_flags(struct udev_list_entry *list_entry);
-void udev_list_entry_set_flags(struct udev_list_entry *list_entry, unsigned int flags);
+int udev_list_entry_get_num(struct udev_list_entry *list_entry);
+void udev_list_entry_set_num(struct udev_list_entry *list_entry, int num);
 #define udev_list_entry_foreach_safe(entry, tmp, first) \
        for (entry = first, tmp = udev_list_entry_get_next(entry); \
             entry != NULL; \

diff --git a/libudev/libudev-queue.c b/libudev/libudev-queue.c
index 75c5b2425e29fe00ebba1dc99a800ddae8ab69b1..ead05c51841f7dbce3339663246b8ba7ff794e7f 100644 (file)
--- a/libudev/libudev-queue.c
+++ b/libudev/libudev-queue.c
@@ -454,7 +454,7 @@ struct udev_list_entry *udev_queue_get_queued_list_entry(struct udev_queue *udev
                        break;
 
                if (len > 0) {
-                       udev_list_entry_add(udev_queue->udev, &udev_queue->queue_list, syspath, seqnum_str, 0, 0);
+                       udev_list_entry_add(udev_queue->udev, &udev_queue->queue_list, syspath, seqnum_str, 0);
                } else {
                        udev_list_entry_foreach(list_entry, udev_list_get_entry(&udev_queue->queue_list)) {
                                if (strcmp(seqnum_str, udev_list_entry_get_value(list_entry)) == 0) {
@@ -508,7 +508,7 @@ struct udev_list_entry *udev_queue_get_failed_list_entry(struct udev_queue *udev
                util_strscpyl(filename, sizeof(filename), syspath, "/uevent", NULL);
                if (stat(filename, &statbuf) != 0)
                        continue;
-               udev_list_entry_add(udev_queue->udev, &udev_queue->failed_list, syspath, NULL, 0, 0);
+               udev_list_entry_add(udev_queue->udev, &udev_queue->failed_list, syspath, NULL, 0);
        }
        closedir(dir);
        return udev_list_get_entry(&udev_queue->failed_list);

diff --git a/libudev/libudev.c b/libudev/libudev.c
index edc24e2fcab42e3f1d5210f8e31d37c819b670d0..6b5c5e9f8481cbf15fd5a5114628dff1861db714 100644 (file)
--- a/libudev/libudev.c
+++ b/libudev/libudev.c
@@ -458,7 +458,7 @@ struct udev_list_entry *udev_add_property(struct udev *udev, const char *key, co
                        udev_list_entry_delete(list_entry);
                return NULL;
        }
-       return udev_list_entry_add(udev, &udev->properties_list, key, value, 1, 0);
+       return udev_list_entry_add(udev, &udev->properties_list, key, value, UDEV_LIST_UNIQUE);
 }
 
 struct udev_list_entry *udev_get_properties_list_entry(struct udev *udev)

diff --git a/udev/udev-event.c b/udev/udev-event.c
index 4af3e08f60e4c20727c7430b7e7cc18916a665ce..e5683cfc2a4ba91262fecdf495807c0fe8dc462e 100644 (file)
--- a/udev/udev-event.c
+++ b/udev/udev-event.c
@@ -1075,7 +1075,7 @@ int udev_event_execute_run(struct udev_event *event, const sigset_t *sigmask)
                        udev_event_apply_format(event, cmd, program, sizeof(program));
                        envp = udev_device_get_properties_envp(event->dev);
                        if (udev_event_spawn(event, program, envp, sigmask, NULL, 0) < 0) {
-                               if (udev_list_entry_get_flags(list_entry))
+                               if (udev_list_entry_get_num(list_entry))
                                        err = -1;
                        }
                }

diff --git a/udev/udev-node.c b/udev/udev-node.c
index 5e791ffb6c50753783018240f6d13866f845868d..dc7d9c365a64efaa6b53eff9b75d8b0077104f07 100644 (file)
--- a/udev/udev-node.c
+++ b/udev/udev-node.c
@@ -386,7 +386,7 @@ int udev_node_add(struct udev_device *dev, mode_t mode, uid_t uid, gid_t gid)
 
        /* create/update symlinks, add symlinks to name index */
        udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev)) {
-               if (udev_list_entry_get_flags(list_entry))
+               if (udev_list_entry_get_num(list_entry))
                        /* simple unmanaged link name */
                        node_symlink(udev, udev_device_get_devnode(dev), udev_list_entry_get_name(list_entry));
                else

diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index 2ae30d81f6c9567d1cfb8adabcb5994097a25b3c..892d8f27a76b0c07dfb9c1b1bde214b104393a4f 100644 (file)
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -731,7 +731,7 @@ static int import_property_from_string(struct udev_device *dev, char *line)
                entry = udev_device_add_property(dev, key, val);
                /* store in db, skip private keys */
                if (key[0] != '.')
-                       udev_list_entry_set_flags(entry, 1);
+                       udev_list_entry_set_num(entry, true);
        }
        return 0;
 }
@@ -800,7 +800,7 @@ static int import_parent_into_properties(struct udev_device *dev, const char *fi
                        entry = udev_device_add_property(dev, key, val);
                        /* store in db, skip private keys */
                        if (key[0] != '.')
-                               udev_list_entry_set_flags(entry, 1);
+                               udev_list_entry_set_num(entry, true);
                }
        }
        return 0;
@@ -1750,7 +1750,7 @@ static int add_matching_files(struct udev *udev, struct udev_list_node *file_lis
                 * identical basenames from different directories overwrite each other
                 * entries are sorted after basename
                 */
-               udev_list_entry_add(udev, file_list, dent->d_name, filename, 1, 1);
+               udev_list_entry_add(udev, file_list, dent->d_name, filename, UDEV_LIST_UNIQUE|UDEV_LIST_SORT);
        }
 
        closedir(dir);
@@ -1829,13 +1829,13 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
                filename_off = add_string(rules, filename);
                /* the offset in the rule is limited to unsigned short */
                if (filename_off < USHRT_MAX)
-                       udev_list_entry_set_flags(file_loop, filename_off);
+                       udev_list_entry_set_num(file_loop, filename_off);
        }
 
        /* parse all rules files */
        udev_list_entry_foreach(file_loop, udev_list_get_entry(&file_list)) {
                const char *filename = udev_list_entry_get_value(file_loop);
-               unsigned int filename_off = udev_list_entry_get_flags(file_loop);
+               unsigned int filename_off = udev_list_entry_get_num(file_loop);
                struct stat st;
 
                if (stat(filename, &st) != 0) {
@@ -2326,7 +2326,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                        struct udev_list_entry *entry;
 
                                        entry = udev_device_add_property(event->dev, key, value);
-                                       udev_list_entry_set_flags(entry, 1);
+                                       udev_list_entry_set_num(entry, true);
                                } else {
                                        if (cur->key.op != OP_NOMATCH)
                                                goto nomatch;
@@ -2354,7 +2354,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                                        if (pos[0] == '\0' || isspace(pos[0])) {
                                                                /* we import simple flags as 'FLAG=1' */
                                                                entry = udev_device_add_property(event->dev, key, "1");
-                                                               udev_list_entry_set_flags(entry, 1);
+                                                               udev_list_entry_set_num(entry, true);
                                                                imported = true;
                                                        } else if (pos[0] == '=') {
                                                                const char *value;
@@ -2365,7 +2365,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                                                        pos++;
                                                                pos[0] = '\0';
                                                                entry = udev_device_add_property(event->dev, key, value);
-                                                               udev_list_entry_set_flags(entry, 1);
+                                                               udev_list_entry_set_num(entry, true);
                                                                imported = true;
                                                        }
                                                }
@@ -2510,7 +2510,7 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                        entry = udev_device_add_property(event->dev, name, temp_value);
                                        /* store in db, skip private keys */
                                        if (name[0] != '.')
-                                               udev_list_entry_set_flags(entry, 1);
+                                               udev_list_entry_set_num(entry, true);
                                } else {
                                        udev_device_add_property(event->dev, name, NULL);
                                }
@@ -2629,9 +2629,9 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                                     &rules->buf[rule->rule.filename_off],
                                     rule->rule.filename_line);
                                list_entry = udev_list_entry_add(event->udev, &event->run_list,
-                                                                &rules->buf[cur->key.value_off], NULL, 1, 0);
+                                                                &rules->buf[cur->key.value_off], NULL, UDEV_LIST_UNIQUE);
                                if (cur->key.fail_on_error)
-                                       udev_list_entry_set_flags(list_entry, 1);
+                                       udev_list_entry_set_num(list_entry, true);
                                break;
                        }
                case TK_A_GOTO:

diff --git a/udev/udevadm-monitor.c b/udev/udevadm-monitor.c
index e1bb6fe18e7e00bc57bdabe6c0b45bd996ffd61f..f3a72cf17e3d283a4d2a5ced43d06934567a4995 100644 (file)
--- a/udev/udevadm-monitor.c
+++ b/udev/udevadm-monitor.c
@@ -122,11 +122,11 @@ int udevadm_monitor(struct udev *udev, int argc, char *argv[])
                                        devtype[0] = '\0';
                                        devtype++;
                                }
-                               udev_list_entry_add(udev, &subsystem_match_list, subsys, devtype, 0, 0);
+                               udev_list_entry_add(udev, &subsystem_match_list, subsys, devtype, 0);
                                break;
                        }
                case 't':
-                       udev_list_entry_add(udev, &tag_match_list, optarg, NULL, 0, 0);
+                       udev_list_entry_add(udev, &tag_match_list, optarg, NULL, 0);
                        break;
                case 'h':
                        printf("Usage: udevadm monitor [--property] [--kernel] [--udev] [--help]\n"