libudev: list - use binary search for list lookup

[elogind.git] / udev / udev-rules.c

diff --git a/udev/udev-rules.c b/udev/udev-rules.c
index 48395e788738ee2028b0c17c09dda302d11a211c..f345e8977d7186f25f0e4569a50d797bd10bde14 100644 (file)
--- a/udev/udev-rules.c
+++ b/udev/udev-rules.c
@@ -1385,6 +1385,26 @@ static int add_rule(struct udev_rules *rules, char *line,
                                if (rule_add_key(&rule_tmp, TK_M_ENV, op, value, attr) != 0)
                                        goto invalid;
                        } else {
+                               static const char *blacklist[] = {
+                                       "ACTION",
+                                       "SUBSYSTEM",
+                                       "DEVTYPE",
+                                       "MAJOR",
+                                       "MINOR",
+                                       "DRIVER",
+                                       "IFINDEX",
+                                       "DEVNAME",
+                                       "DEVLINKS",
+                                       "DEVPATH",
+                                       "TAGS",
+                               };
+                               unsigned int i;
+
+                               for (i = 0; i < ARRAY_SIZE(blacklist); i++)
+                                       if (strcmp(attr, blacklist[i]) == 0) {
+                                               err(rules->udev, "invalid ENV attribute, '%s' can not be set %s:%u\n", attr, filename, lineno);
+                                               continue;
+                                       }
                                if (rule_add_key(&rule_tmp, TK_A_ENV, op, value, attr) != 0)
                                        goto invalid;
                        }
@@ -1729,7 +1749,7 @@ static int parse_file(struct udev_rules *rules, const char *filename, unsigned s
        return 0;
 }
 
-static int add_matching_files(struct udev *udev, struct udev_list_node *file_list, const char *dirname, const char *suffix)
+static int add_matching_files(struct udev *udev, struct udev_list *file_list, const char *dirname, const char *suffix)
 {
        DIR *dir;
        struct dirent *dent;
@@ -1763,7 +1783,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, UDEV_LIST_UNIQUE|UDEV_LIST_SORT);
+               udev_list_entry_add(file_list, dent->d_name, filename);
        }
 
        closedir(dir);
@@ -1773,7 +1793,7 @@ static int add_matching_files(struct udev *udev, struct udev_list_node *file_lis
 struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
 {
        struct udev_rules *rules;
-       struct udev_list_node file_list;
+       struct udev_list file_list;
        struct udev_list_entry *file_loop;
        struct token end_token;
 
@@ -1782,7 +1802,7 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
                return NULL;
        rules->udev = udev;
        rules->resolve_names = resolve_names;
-       udev_list_init(&file_list);
+       udev_list_init(udev, &file_list, true);
 
        /* init token array and string buffer */
        rules->tokens = malloc(PREALLOC_TOKEN * sizeof(struct token));
@@ -1865,7 +1885,7 @@ struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
                }
                parse_file(rules, filename, filename_off);
        }
-       udev_list_cleanup_entries(udev, &file_list);
+       udev_list_cleanup(&file_list);
 
        memset(&end_token, 0x00, sizeof(struct token));
        end_token.type = TK_END;
@@ -2528,10 +2548,20 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                }
                case TK_A_TAG: {
                        char tag[UTIL_PATH_SIZE];
+                       const char *p;
 
                        udev_event_apply_format(event, &rules->buf[cur->key.value_off], tag, sizeof(tag));
                        if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
                                udev_device_cleanup_tags_list(event->dev);
+                       for (p = tag; *p != '\0'; p++) {
+                               if ((*p >= 'a' && *p <= 'z') ||
+                                   (*p >= 'A' && *p <= 'Z') ||
+                                   (*p >= '0' && *p <= '9') ||
+                                   *p == '-' || *p == '_')
+                                       continue;
+                               err(event->udev, "ignoring invalid tag name '%s'\n", tag);
+                               break;
+                       }
                        udev_device_add_tag(event->dev, tag);
                        break;
                }
@@ -2633,13 +2663,12 @@ int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event
                        struct udev_list_entry *list_entry;
 
                        if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
-                               udev_list_cleanup_entries(event->udev, &event->run_list);
+                               udev_list_cleanup(&event->run_list);
                        info(event->udev, "RUN '%s' %s:%u\n",
                             &rules->buf[cur->key.value_off],
                             &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, UDEV_LIST_UNIQUE);
+                       list_entry = udev_list_entry_add(&event->run_list, &rules->buf[cur->key.value_off], NULL);
                        if (cur->key.fail_on_error)
                                udev_list_entry_set_num(list_entry, true);
                        break;
@@ -2709,6 +2738,7 @@ void udev_rules_apply_static_dev_perms(struct udev_rules *rules)
                case TK_A_STATIC_NODE: {
                        char filename[UTIL_PATH_SIZE];
                        struct stat stats;
+
                        /* we assure, that the permissions tokens are sorted before the static token */
                        if (mode == 0 && uid == 0 && gid == 0)
                                goto next;
@@ -2718,14 +2748,19 @@ void udev_rules_apply_static_dev_perms(struct udev_rules *rules)
                                goto next;
                        if (!S_ISBLK(stats.st_mode) && !S_ISCHR(stats.st_mode))
                                goto next;
-                       if (mode != 0 && mode != (stats.st_mode & 0777)) {
+
+                       if (mode == 0 && gid > 0)
+                               mode = 0660;
+                       if (mode != (stats.st_mode & 0777)) {
                                chmod(filename, mode);
                                info(rules->udev, "chmod '%s' %#o\n", filename, mode);
                        }
+
                        if ((uid != 0 && uid != stats.st_uid) || (gid != 0 && gid != stats.st_gid)) {
                                chown(filename, uid, gid);
                                info(rules->udev, "chown '%s' %u %u\n", filename, uid, gid);
                        }
+
                        utimensat(AT_FDCWD, filename, NULL, 0);
                        break;
                }