chiark / gitweb /
persistent rules: fix typo in dm rule
[elogind.git] / udev_rules_parse.c
index 1212368..6bb83ae 100644 (file)
@@ -1,12 +1,9 @@
 /*
  * udev_rules_parse.c
  *
- * Userspace devfs
- *
  * Copyright (C) 2003,2004 Greg Kroah-Hartman <greg@kroah.com>
  * Copyright (C) 2003-2005 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 version 2 of the License.
 #include <sys/stat.h>
 #include <errno.h>
 
-#include "udev_libc_wrapper.h"
 #include "udev.h"
-#include "udev_utils.h"
-#include "logging.h"
 #include "udev_rules.h"
 
-/* rules parsed from .rules files*/
-static LIST_HEAD(rules_list);
-static struct list_head *rules_list_current;
-
-/* mapped compiled rules stored on disk */
-static struct udev_rule *rules_array = NULL;
-static size_t rules_array_current;
-static size_t rules_array_size = 0;
-
-static size_t rules_count = 0;
 
-int udev_rules_iter_init(void)
+void udev_rules_iter_init(struct udev_rules *rules)
 {
-       rules_list_current = rules_list.next;
-       rules_array_current = 0;
-
-       return 0;
+       dbg("bufsize=%zi", rules->bufsize);
+       rules->current = 0;
 }
 
-struct udev_rule *udev_rules_iter_next(void)
+struct udev_rule *udev_rules_iter_next(struct udev_rules *rules)
 {
        static struct udev_rule *rule;
 
-       if (rules_array) {
-               if (rules_array_current >= rules_count)
-                       return NULL;
-               rule = &rules_array[rules_array_current];
-               rules_array_current++;
-       } else {
-               dbg("head=%p current=%p next=%p", &rules_list, rules_list_current, rules_list_current->next);
-               if (rules_list_current == &rules_list)
-                       return NULL;
-               rule = list_entry(rules_list_current, struct udev_rule, node);
-               rules_list_current = rules_list_current->next;
+       if (!rules)
+               return NULL;
+
+       dbg("current=%zi", rules->current);
+       if (rules->current >= rules->bufsize) {
+               dbg("no more rules");
+               return NULL;
        }
+
+       /* get next rule */
+       rule = (struct udev_rule *) (rules->buf + rules->current);
+       rules->current += sizeof(struct udev_rule) + rule->bufsize;
+
        return rule;
 }
 
-static int add_rule_to_list(struct udev_rule *rule)
+struct udev_rule *udev_rules_iter_label(struct udev_rules *rules, const char *label)
 {
-       struct udev_rule *tmp_rule;
-
-       tmp_rule = malloc(sizeof(*tmp_rule));
-       if (tmp_rule == NULL)
-               return -ENOMEM;
-       memcpy(tmp_rule, rule, sizeof(struct udev_rule));
-       list_add_tail(&tmp_rule->node, &rules_list);
-
-       dbg("name='%s', symlink='%s', bus='%s', id='%s', "
-           "sysfs_file[0]='%s', sysfs_value[0]='%s', "
-           "kernel='%s', program='%s', result='%s', "
-           "owner='%s', group='%s', mode=%#o, "
-           "all_partions=%u, ignore_remove=%u, ignore_device=%u, last_rule=%u",
-           rule->name, rule->symlink, rule->bus, rule->id,
-           rule->sysfs_pair[0].name, rule->sysfs_pair[0].value,
-           rule->kernel, rule->program, rule->result, rule->owner, rule->group, rule->mode,
-           rule->partitions, rule->ignore_remove, rule->ignore_device, rule->last_rule);
+       static struct udev_rule *rule;
 
-       return 0;
+next:
+       dbg("current=%zi", rules->current);
+       if (rules->current >= rules->bufsize) {
+               dbg("no more rules");
+               return NULL;
+       }
+       rule = (struct udev_rule *) (rules->buf + rules->current);
+
+       if (strcmp(&rule->buf[rule->label.val_off], label) != 0) {
+               dbg("moving forward, looking for label '%s'", label);
+               rules->current += sizeof(struct udev_rule) + rule->bufsize;
+               goto next;
+       }
+
+       dbg("found label '%s'", label);
+       return rule;
 }
 
 static int get_key(char **line, char **key, enum key_operation *operation, char **value)
@@ -104,7 +86,7 @@ static int get_key(char **line, char **key, enum key_operation *operation, char
        char *temp;
 
        linepos = *line;
-       if (!linepos)
+       if (linepos == NULL && linepos[0] == '\0')
                return -1;
 
        /* skip whitespace */
@@ -112,7 +94,10 @@ static int get_key(char **line, char **key, enum key_operation *operation, char
                linepos++;
 
        /* get the key */
+       if (linepos[0] == '\0')
+               return -1;
        *key = linepos;
+
        while (1) {
                linepos++;
                if (linepos[0] == '\0')
@@ -135,6 +120,8 @@ static int get_key(char **line, char **key, enum key_operation *operation, char
        /* skip whitespace after key */
        while (isspace(linepos[0]))
                linepos++;
+       if (linepos[0] == '\0')
+               return -1;
 
        /* get operation type */
        if (linepos[0] == '=' && linepos[1] == '=') {
@@ -167,6 +154,8 @@ static int get_key(char **line, char **key, enum key_operation *operation, char
        /* skip whitespace after operator */
        while (isspace(linepos[0]))
                linepos++;
+       if (linepos[0] == '\0')
+               return -1;
 
        /* get the value*/
        if (linepos[0] == '"')
@@ -210,340 +199,417 @@ static char *get_key_attribute(char *str)
        return NULL;
 }
 
-static int rules_parse(const char *filename)
+static int add_rule_key(struct udev_rule *rule, struct key *key,
+                       enum key_operation operation, const char *value)
 {
-       char line[LINE_SIZE];
-       char *bufline;
-       int lineno;
+       size_t val_len = strnlen(value, PATH_SIZE);
+
+       key->operation = operation;
+
+       key->val_off = rule->bufsize;
+       strlcpy(rule->buf + rule->bufsize, value, val_len+1);
+       rule->bufsize += val_len+1;
+
+       return 0;
+}
+
+static int add_rule_key_pair(struct udev_rule *rule, struct key_pairs *pairs,
+                            enum key_operation operation, const char *key, const char *value)
+{
+       size_t key_len = strnlen(key, PATH_SIZE);
+
+       if (pairs->count >= PAIRS_MAX) {
+               err("skip, too many keys in a single rule");
+               return -1;
+       }
+
+       add_rule_key(rule, &pairs->keys[pairs->count].key, operation, value);
+
+       /* 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);
+       rule->bufsize += key_len+1;
+
+       pairs->count++;
+
+       return 0;
+}
+
+static int add_to_rules(struct udev_rules *rules, char *line)
+{
+       struct udev_rule *rule;
+       size_t rule_size;
+       int valid;
        char *linepos;
        char *attr;
-       char *buf;
-       size_t bufsize;
-       size_t cur;
-       size_t count;
-       int program_given = 0;
-       int valid;
-       int retval = 0;
-       struct udev_rule rule;
+       size_t padding;
+       int retval;
 
-       if (file_map(filename, &buf, &bufsize) != 0) {
-               err("can't open '%s' as rules file", filename);
+       /* get all the keys */
+       rule = calloc(1, sizeof (struct udev_rule) + LINE_SIZE);
+       if (!rule) {
+               err("malloc failed");
                return -1;
        }
-       dbg("reading '%s' as rules file", filename);
+       linepos = line;
+       valid = 0;
 
-       /* loop through the whole file */
-       cur = 0;
-       lineno = 0;
-       while (cur < bufsize) {
-               unsigned int i, j;
+       while (1) {
+               char *key;
+               char *value;
+               enum key_operation operation = KEY_OP_UNSET;
 
-               count = buf_get_line(buf, bufsize, cur);
-               bufline = &buf[cur];
-               cur += count+1;
-               lineno++;
+               retval = get_key(&linepos, &key, &operation, &value);
+               if (retval)
+                       break;
 
-               if (count >= sizeof(line)) {
-                       info("line too long, rule skipped %s, line %d", filename, lineno);
+               if (strcasecmp(key, "LABEL") == 0) {
+                       add_rule_key(rule, &rule->label, operation, value);
+                       valid = 1;
                        continue;
                }
 
-               /* eat the whitespace */
-               while ((count > 0) && isspace(bufline[0])) {
-                       bufline++;
-                       count--;
-               }
-               if (count == 0)
+               if (strcasecmp(key, "GOTO") == 0) {
+                       add_rule_key(rule, &rule->goto_label, operation, value);
+                       valid = 1;
                        continue;
+               }
 
-               /* see if this is a comment */
-               if (bufline[0] == COMMENT_CHARACTER)
+               if (strcasecmp(key, "KERNEL") == 0) {
+                       add_rule_key(rule, &rule->kernel_name, operation, value);
+                       valid = 1;
                        continue;
+               }
 
-               /* skip backslash and newline from multi line rules */
-               for (i = j = 0; i < count; i++) {
-                       if (bufline[i] == '\\' && bufline[i+1] == '\n')
-                               continue;
+               if (strcasecmp(key, "SUBSYSTEM") == 0) {
+                       add_rule_key(rule, &rule->subsystem, operation, value);
+                       valid = 1;
+                       continue;
+               }
 
-                       line[j++] = bufline[i];
+               if (strcasecmp(key, "ACTION") == 0) {
+                       add_rule_key(rule, &rule->action, operation, value);
+                       valid = 1;
+                       continue;
                }
-               line[j] = '\0';
-               dbg("read '%s'", line);
 
-               /* get all known keys */
-               memset(&rule, 0x00, sizeof(struct udev_rule));
-               linepos = line;
-               valid = 0;
+               if (strcasecmp(key, "DEVPATH") == 0) {
+                       add_rule_key(rule, &rule->devpath, operation, value);
+                       valid = 1;
+                       continue;
+               }
 
-               while (1) {
-                       char *key;
-                       char *value;
-                       enum key_operation operation = KEY_OP_UNSET;
+               if (strcasecmp(key, "BUS") == 0) {
+                       add_rule_key(rule, &rule->bus, operation, value);
+                       valid = 1;
+                       continue;
+               }
 
-                       retval = get_key(&linepos, &key, &operation, &value);
-                       if (retval)
-                               break;
+               if (strcasecmp(key, "ID") == 0) {
+                       add_rule_key(rule, &rule->id, operation, value);
+                       valid = 1;
+                       continue;
+               }
 
-                       if (strcasecmp(key, KEY_KERNEL) == 0) {
-                               strlcpy(rule.kernel, value, sizeof(rule.kernel));
-                               rule.kernel_operation = operation;
-                               valid = 1;
+               if (strncasecmp(key, "SYSFS", sizeof("SYSFS")-1) == 0) {
+                       attr = get_key_attribute(key + sizeof("SYSFS")-1);
+                       if (attr == NULL) {
+                               err("error parsing SYSFS attribute in '%s'", line);
                                continue;
                        }
+                       add_rule_key_pair(rule, &rule->sysfs, operation, attr, value);
+                       valid = 1;
+                       continue;
+               }
 
-                       if (strcasecmp(key, KEY_SUBSYSTEM) == 0) {
-                               strlcpy(rule.subsystem, value, sizeof(rule.subsystem));
-                               rule.subsystem_operation = operation;
-                               valid = 1;
-                               continue;
-                       }
+               if (strcasecmp(key, "WAIT_FOR_SYSFS") == 0) {
+                       add_rule_key(rule, &rule->wait_for_sysfs, operation, value);
+                       valid = 1;
+                       continue;
+               }
 
-                       if (strcasecmp(key, KEY_ACTION) == 0) {
-                               strlcpy(rule.action, value, sizeof(rule.action));
-                               rule.action_operation = operation;
-                               valid = 1;
+               if (strncasecmp(key, "ENV", sizeof("ENV")-1) == 0) {
+                       attr = get_key_attribute(key + sizeof("ENV")-1);
+                       if (attr == NULL) {
+                               err("error parsing ENV attribute");
                                continue;
                        }
+                       add_rule_key_pair(rule, &rule->env, operation, attr, value);
+                       valid = 1;
+                       continue;
+               }
 
-                       if (strcasecmp(key, KEY_DEVPATH) == 0) {
-                               strlcpy(rule.devpath, value, sizeof(rule.devpath));
-                               rule.devpath_operation = operation;
-                               valid = 1;
-                               continue;
-                       }
+               if (strcasecmp(key, "MODALIAS") == 0) {
+                       add_rule_key(rule, &rule->modalias, operation, value);
+                       valid = 1;
+                       continue;
+               }
 
-                       if (strcasecmp(key, KEY_BUS) == 0) {
-                               strlcpy(rule.bus, value, sizeof(rule.bus));
-                               rule.bus_operation = operation;
-                               valid = 1;
-                               continue;
-                       }
+               if (strncasecmp(key, "IMPORT", sizeof("IMPORT")-1) == 0) {
+                       attr = get_key_attribute(key + sizeof("IMPORT")-1);
+                       if (attr && strstr(attr, "program")) {
+                               dbg("IMPORT will be executed");
+                               rule->import_type  = IMPORT_PROGRAM;
+                       } else if (attr && strstr(attr, "file")) {
+                               dbg("IMPORT will be included as file");
+                               rule->import_type  = IMPORT_FILE;
+                       } else if (attr && strstr(attr, "parent")) {
+                               dbg("IMPORT will include the parent values");
+                               rule->import_type = IMPORT_PARENT;
+                       } else {
+                               /* figure it out if it is executable */
+                               char file[PATH_SIZE];
+                               char *pos;
+                               struct stat stats;
+
+                               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, "/lib/udev/", sizeof(file));
+                                       strlcat(file, value, sizeof(file));
+                                       pos = strchr(file, ' ');
+                                       if (pos)
+                                               pos[0] = '\0';
+                               }
 
-                       if (strcasecmp(key, KEY_ID) == 0) {
-                               strlcpy(rule.id, value, sizeof(rule.id));
-                               rule.id_operation = operation;
-                               valid = 1;
-                               continue;
+                               dbg("IMPORT auto mode for '%s'", file);
+                               if (!lstat(file, &stats) && (stats.st_mode & S_IXUSR)) {
+                                       dbg("IMPORT is executable, will be executed (autotype)");
+                                       rule->import_type  = IMPORT_PROGRAM;
+                               } else {
+                                       dbg("IMPORT is not executable, will be included as file (autotype)");
+                                       rule->import_type  = IMPORT_FILE;
+                               }
                        }
+                       add_rule_key(rule, &rule->import, operation, value);
+                       valid = 1;
+                       continue;
+               }
 
-                       if (strncasecmp(key, KEY_SYSFS, sizeof(KEY_SYSFS)-1) == 0) {
-                               struct key_pair *pair;
+               if (strcasecmp(key, "DRIVER") == 0) {
+                       add_rule_key(rule, &rule->driver, operation, value);
+                       valid = 1;
+                       continue;
+               }
 
-                               if (rule.sysfs_pair_count >= KEY_SYSFS_PAIRS_MAX) {
-                                       err("skip rule, to many " KEY_SYSFS " keys in a single rule");
-                                       goto error;
+               if (strcasecmp(key, "RESULT") == 0) {
+                       add_rule_key(rule, &rule->result, operation, value);
+                       valid = 1;
+                       continue;
+               }
+
+               if (strcasecmp(key, "PROGRAM") == 0) {
+                       add_rule_key(rule, &rule->program, operation, value);
+                       valid = 1;
+                       continue;
+               }
+
+               if (strncasecmp(key, "NAME", sizeof("NAME")-1) == 0) {
+                       attr = get_key_attribute(key + sizeof("NAME")-1);
+                       if (attr != NULL) {
+                               if (strstr(attr, "all_partitions") != NULL) {
+                                       dbg("creation of partition nodes requested");
+                                       rule->partitions = DEFAULT_PARTITIONS_COUNT;
                                }
-                               pair = &rule.sysfs_pair[rule.sysfs_pair_count];
-                               attr = get_key_attribute(key + sizeof(KEY_SYSFS)-1);
-                               if (attr == NULL) {
-                                       err("error parsing " KEY_SYSFS " attribute");
-                                       goto error;
+                               if (strstr(attr, "ignore_remove") != NULL) {
+                                       dbg("remove event should be ignored");
+                                       rule->ignore_remove = 1;
                                }
-                               strlcpy(pair->name, attr, sizeof(pair->name));
-                               strlcpy(pair->value, value, sizeof(pair->value));
-                               pair->operation = operation;
-                               rule.sysfs_pair_count++;
-                               valid = 1;
-                               continue;
                        }
+                       if (value[0] == '\0')
+                               dbg("name empty, node creation supressed");
+                       add_rule_key(rule, &rule->name, operation, value);
+                       continue;
+               }
 
-                       if (strncasecmp(key, KEY_ENV, sizeof(KEY_ENV)-1) == 0) {
-                               struct key_pair *pair;
+               if (strcasecmp(key, "SYMLINK") == 0) {
+                       add_rule_key(rule, &rule->symlink, operation, value);
+                       valid = 1;
+                       continue;
+               }
 
-                               if (rule.env_pair_count >= KEY_ENV_PAIRS_MAX) {
-                                       err("skip rule, to many " KEY_ENV " keys in a single rule");
-                                       goto error;
-                               }
-                               pair = &rule.env_pair[rule.env_pair_count];
-                               attr = get_key_attribute(key + sizeof(KEY_ENV)-1);
-                               if (attr == NULL) {
-                                       err("error parsing " KEY_ENV " attribute");
+               if (strcasecmp(key, "OWNER") == 0) {
+                       valid = 1;
+                       if (rules->resolve_names && (!strchr(value, '$') && !strchr(value, '%'))) {
+                               char *endptr;
+                               strtoul(value, &endptr, 10);
+                               if (endptr[0] != '\0') {
+                                       char owner[32];
+                                       uid_t uid = lookup_user(value);
+                                       dbg("replacing username='%s' by id=%i", value, uid);
+                                       sprintf(owner, "%u", (unsigned int) uid);
+                                       add_rule_key(rule, &rule->owner, operation, owner);
                                        continue;
                                }
-                               strlcpy(pair->name, attr, sizeof(pair->name));
-                               strlcpy(pair->value, value, sizeof(pair->value));
-                               pair->operation = operation;
-                               rule.env_pair_count++;
-                               valid = 1;
-                               continue;
                        }
 
-                       if (strcasecmp(key, KEY_MODALIAS) == 0) {
-                               strlcpy(rule.modalias, value, sizeof(rule.modalias));
-                               rule.modalias_operation = operation;
-                               valid = 1;
-                               continue;
-                       }
+                       add_rule_key(rule, &rule->owner, operation, value);
+                       continue;
+               }
 
-                       if (strcasecmp(key, KEY_IMPORT) == 0) {
-                               strlcpy(rule.import, value, sizeof(rule.import));
-                               rule.import_operation = operation;
-                               valid = 1;
-                               continue;
+               if (strcasecmp(key, "GROUP") == 0) {
+                       valid = 1;
+                       if (rules->resolve_names && (!strchr(value, '$') && !strchr(value, '%'))) {
+                               char *endptr;
+                               strtoul(value, &endptr, 10);
+                               if (endptr[0] != '\0') {
+                                       char group[32];
+                                       gid_t gid = lookup_group(value);
+                                       dbg("replacing groupname='%s' by id=%i", value, gid);
+                                       sprintf(group, "%u", (unsigned int) gid);
+                                       add_rule_key(rule, &rule->group, operation, group);
+                                       continue;
+                               }
                        }
 
-                       if (strcasecmp(key, KEY_DRIVER) == 0) {
-                               strlcpy(rule.driver, value, sizeof(rule.driver));
-                               rule.driver_operation = operation;
-                               valid = 1;
-                               continue;
-                       }
+                       add_rule_key(rule, &rule->group, operation, value);
+                       continue;
+               }
 
-                       if (strcasecmp(key, KEY_RESULT) == 0) {
-                               strlcpy(rule.result, value, sizeof(rule.result));
-                               rule.result_operation = operation;
-                               valid = 1;
-                               continue;
-                       }
+               if (strcasecmp(key, "MODE") == 0) {
+                       rule->mode = strtol(value, NULL, 8);
+                       rule->mode_operation = operation;
+                       valid = 1;
+                       continue;
+               }
 
-                       if (strcasecmp(key, KEY_PROGRAM) == 0) {
-                               strlcpy(rule.program, value, sizeof(rule.program));
-                               rule.program_operation = operation;
-                               program_given = 1;
-                               valid = 1;
-                               continue;
-                       }
+               if (strcasecmp(key, "RUN") == 0) {
+                       add_rule_key(rule, &rule->run, operation, value);
+                       valid = 1;
+                       continue;
+               }
 
-                       if (strncasecmp(key, KEY_NAME, sizeof(KEY_NAME)-1) == 0) {
-                               attr = get_key_attribute(key + sizeof(KEY_NAME)-1);
-                               if (attr != NULL) {
-                                       if (strstr(attr, OPTION_PARTITIONS) != NULL) {
-                                               dbg("creation of partition nodes requested");
-                                               rule.partitions = DEFAULT_PARTITIONS_COUNT;
-                                       }
-                                       /* FIXME: remove old style option and make OPTIONS= mandatory */
-                                       if (strstr(attr, OPTION_IGNORE_REMOVE) != NULL) {
-                                               dbg("remove event should be ignored");
-                                               rule.ignore_remove = 1;
-                                       }
-                               }
-                               rule.name_operation = operation;
-                               strlcpy(rule.name, value, sizeof(rule.name));
-                               valid = 1;
-                               continue;
+               if (strcasecmp(key, "OPTIONS") == 0) {
+                       if (strstr(value, "last_rule") != NULL) {
+                               dbg("last rule to be applied");
+                               rule->last_rule = 1;
                        }
-
-                       if (strcasecmp(key, KEY_SYMLINK) == 0) {
-                               strlcpy(rule.symlink, value, sizeof(rule.symlink));
-                               rule.symlink_operation = operation;
-                               valid = 1;
-                               continue;
+                       if (strstr(value, "ignore_device") != NULL) {
+                               dbg("device should be ignored");
+                               rule->ignore_device = 1;
                        }
-
-                       if (strcasecmp(key, KEY_OWNER) == 0) {
-                               strlcpy(rule.owner, value, sizeof(rule.owner));
-                               rule.owner_operation = operation;
-                               valid = 1;
-                               continue;
+                       if (strstr(value, "ignore_remove") != NULL) {
+                               dbg("remove event should be ignored");
+                               rule->ignore_remove = 1;
                        }
-
-                       if (strcasecmp(key, KEY_GROUP) == 0) {
-                               strlcpy(rule.group, value, sizeof(rule.group));
-                               rule.group_operation = operation;
-                               valid = 1;
-                               continue;
+                       if (strstr(value, "all_partitions") != NULL) {
+                               dbg("creation of partition nodes requested");
+                               rule->partitions = DEFAULT_PARTITIONS_COUNT;
                        }
+                       valid = 1;
+                       continue;
+               }
 
-                       if (strcasecmp(key, KEY_MODE) == 0) {
-                               rule.mode = strtol(value, NULL, 8);
-                               rule.mode_operation = operation;
-                               valid = 1;
-                               continue;
-                       }
+               err("unknown key '%s', in '%s'", key, line);
+       }
 
-                       if (strcasecmp(key, KEY_RUN) == 0) {
-                               strlcpy(rule.run, value, sizeof(rule.run));
-                               rule.run_operation = operation;
-                               valid = 1;
-                               continue;
-                       }
+       /* skip line if not any valid key was found */
+       if (!valid) {
+               err("invalid rule '%s'", line);
+               goto exit;
+       }
 
-                       if (strcasecmp(key, KEY_OPTIONS) == 0) {
-                               if (strstr(value, OPTION_LAST_RULE) != NULL) {
-                                       dbg("last rule to be applied");
-                                       rule.last_rule = 1;
-                               }
-                               if (strstr(value, OPTION_IGNORE_DEVICE) != NULL) {
-                                       dbg("device should be ignored");
-                                       rule.ignore_device = 1;
-                               }
-                               if (strstr(value, OPTION_IGNORE_REMOVE) != NULL) {
-                                       dbg("remove event should be ignored");
-                                       rule.ignore_remove = 1;
-                               }
-                               if (strstr(value, OPTION_PARTITIONS) != NULL) {
-                                       dbg("creation of partition nodes requested");
-                                       rule.partitions = DEFAULT_PARTITIONS_COUNT;
-                               }
-                               valid = 1;
-                               continue;
-                       }
+       /* grow buffer and add rule */
+       rule_size = sizeof(struct udev_rule) + rule->bufsize;
+       padding = (sizeof(size_t) - rule_size % sizeof(size_t)) % sizeof(size_t);
+       dbg("add %zi padding bytes", padding);
+       rule_size += padding;
+       rule->bufsize += padding;
+
+       rules->buf = realloc(rules->buf, rules->bufsize + rule_size);
+       if (!rules->buf) {
+               err("realloc failed");
+               goto exit;
+       }
+       dbg("adding rule to offset %zi", rules->bufsize);
+       memcpy(rules->buf + rules->bufsize, rule, rule_size);
+       rules->bufsize += rule_size;
+exit:
+       free(rule);
+       return 0;
+}
 
-                       err("unknown key '%s'", key);
-                       goto error;
-               }
+static int parse_file(struct udev_rules *rules, const char *filename)
+{
+       char line[LINE_SIZE];
+       char *bufline;
+       int lineno;
+       char *buf;
+       size_t bufsize;
+       size_t cur;
+       size_t count;
+       int retval = 0;
+
+       if (file_map(filename, &buf, &bufsize) != 0) {
+               err("can't open '%s' as rules file: %s", filename, strerror(errno));
+               return -1;
+       }
+       dbg("reading '%s' as rules file", filename);
+
+       /* loop through the whole file */
+       cur = 0;
+       lineno = 0;
+       while (cur < bufsize) {
+               unsigned int i, j;
 
-               /* skip line if not any valid key was found */
-               if (!valid)
-                       goto error;
+               count = buf_get_line(buf, bufsize, cur);
+               bufline = &buf[cur];
+               cur += count+1;
+               lineno++;
 
-               if ((rule.result[0] != '\0') && (program_given == 0)) {
-                       info(KEY_RESULT " is only useful when " KEY_PROGRAM " is called in any rule before");
-                       goto error;
+               if (count >= sizeof(line)) {
+                       info("line too long, rule skipped %s, line %d", filename, lineno);
+                       continue;
                }
 
-               rule.config_line = lineno;
-               strlcpy(rule.config_file, filename, sizeof(rule.config_file));
-               retval = add_rule_to_list(&rule);
-               if (retval) {
-                       dbg("add_rule_to_list returned with error %d", retval);
+               /* eat the whitespace */
+               while ((count > 0) && isspace(bufline[0])) {
+                       bufline++;
+                       count--;
+               }
+               if (count == 0)
                        continue;
-error:
-                       err("parse error %s, line %d:%d, rule skipped",
-                            filename, lineno, (int) (linepos - line));
+
+               /* see if this is a comment */
+               if (bufline[0] == COMMENT_CHARACTER)
+                       continue;
+
+               /* skip backslash and newline from multi line rules */
+               for (i = j = 0; i < count; i++) {
+                       if (bufline[i] == '\\' && bufline[i+1] == '\n')
+                               continue;
+
+                       line[j++] = bufline[i];
                }
+               line[j] = '\0';
+
+               dbg("read '%s'", line);
+               add_to_rules(rules, line);
        }
 
        file_unmap(buf, bufsize);
        return retval;
 }
 
-static int rules_map(const char *filename)
+int udev_rules_init(struct udev_rules *rules, int resolve_names)
 {
-       char *buf;
-       size_t size;
-
-       if (file_map(filename, &buf, &size))
-               return -1;
-       if (size == 0)
-               return -1;
-       rules_array = (struct udev_rule *) buf;
-       rules_array_size = size;
-       rules_count = size / sizeof(struct udev_rule);
-       dbg("found %zi compiled rules", rules_count);
-
-       return 0;
-}
-
-int udev_rules_init(void)
-{
-       char comp[PATH_SIZE];
        struct stat stats;
        int retval;
 
-       strlcpy(comp, udev_rules_filename, sizeof(comp));
-       strlcat(comp, ".compiled", sizeof(comp));
-       if (stat(comp, &stats) == 0) {
-               dbg("parse compiled rules '%s'", comp);
-               return rules_map(comp);
-       }
+       memset(rules, 0x00, sizeof(struct udev_rules));
+       rules->resolve_names = resolve_names;
 
+       /* parse rules file or all matching files in directory */
        if (stat(udev_rules_filename, &stats) != 0)
                return -1;
 
        if ((stats.st_mode & S_IFMT) != S_IFDIR) {
                dbg("parse single rules file '%s'", udev_rules_filename);
-               retval = rules_parse(udev_rules_filename);
+               retval = parse_file(rules, udev_rules_filename);
        } else {
                struct name_entry *name_loop, *name_tmp;
                LIST_HEAD(name_list);
@@ -552,24 +618,25 @@ int udev_rules_init(void)
                retval = add_matching_files(&name_list, udev_rules_filename, RULEFILE_SUFFIX);
 
                list_for_each_entry_safe(name_loop, name_tmp, &name_list, node) {
-                       rules_parse(name_loop->name);
+                       if (stat(name_loop->name, &stats) == 0) {
+                               if (stats.st_size)
+                                       parse_file(rules, name_loop->name);
+                               else
+                                       dbg("empty rules file '%s'", name_loop->name);
+                       } else
+                               err("could not read '%s': %s", name_loop->name, strerror(errno));
                        list_del(&name_loop->node);
+                       free(name_loop);
                }
        }
 
        return retval;
 }
 
-void udev_rules_close(void)
+void udev_rules_cleanup(struct udev_rules *rules)
 {
-       struct udev_rule *rule;
-       struct udev_rule *temp_rule;
-
-       if (rules_array)
-               file_unmap(rules_array, rules_array_size);
-       else
-               list_for_each_entry_safe(rule, temp_rule, &rules_list, node) {
-                       list_del(&rule->node);
-                       free(rule);
-               }
+       if (rules->buf) {
+               free(rules->buf);
+               rules->buf = NULL;
+       }
 }