X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=namedev.c;h=6685596479ac14102246ab40c555b51886ceb303;hp=0271ba55a2ad4091f382c506c87a559aa456dd57;hb=d83a9b89e75aeb79856ddc4d95dc32a6bbd17f0e;hpb=469c7cff3b1432aa7a8786c08ee9a64caec2ba27 diff --git a/namedev.c b/namedev.c index 0271ba55a..668559647 100644 --- a/namedev.c +++ b/namedev.c @@ -29,93 +29,72 @@ #include #include #include +#include +#include +#include #include "list.h" #include "udev.h" #include "udev_version.h" +#include "logging.h" #include "namedev.h" +#include "libsysfs/libsysfs.h" +#include "klibc_fixups.h" -#define TYPE_LABEL "LABEL" -#define TYPE_NUMBER "NUMBER" -#define TYPE_TOPOLOGY "TOPOLOGY" -#define TYPE_REPLACE "REPLACE" - -enum config_type { - KERNEL_NAME = 0, /* must be 0 to let memset() default to this value */ - LABEL = 1, - NUMBER = 2, - TOPOLOGY = 3, - REPLACE = 4, -}; - -#define BUS_SIZE 30 -#define FILE_SIZE 50 -#define VALUE_SIZE 100 -#define ID_SIZE 50 -#define PLACE_SIZE 50 -#define NAME_SIZE 100 -#define OWNER_SIZE 30 -#define GROUP_SIZE 30 - - -struct config_device { - struct list_head node; - - enum config_type type; - - char bus[BUS_SIZE]; - char sysfs_file[FILE_SIZE]; - char sysfs_value[VALUE_SIZE]; - char id[ID_SIZE]; - char place[PLACE_SIZE]; - char kernel_name[NAME_SIZE]; - - /* what to set the device to */ - int mode; - char name[NAME_SIZE]; - char owner[OWNER_SIZE]; - char group[GROUP_SIZE]; -}; - +LIST_HEAD(config_device_list); +LIST_HEAD(perm_device_list); -static LIST_HEAD(config_device_list); - -static void dump_dev(struct config_device *dev) +/* compare string with pattern (supports * ? [0-9] [!A-Z]) */ +static int strcmp_pattern(const char *p, const char *s) { - switch (dev->type) { - case KERNEL_NAME: - dbg("KERNEL name ='%s'" - " owner = '%s', group = '%s', mode = '%d'", - dev->name, - dev->owner, dev->group, dev->mode); - break; - case LABEL: - dbg("LABEL name = '%s', bus = '%s', sysfs_file = '%s', sysfs_value = '%s'" - " owner = '%s', group = '%s', mode = '%d'", - dev->name, dev->bus, dev->sysfs_file, dev->sysfs_value, - dev->owner, dev->group, dev->mode); - break; - case NUMBER: - dbg("NUMBER name = '%s', bus = '%s', id = '%s'" - " owner = '%s', group = '%s', mode = '%d'", - dev->name, dev->bus, dev->id, - dev->owner, dev->group, dev->mode); - break; - case TOPOLOGY: - dbg("TOPOLOGY name = '%s', bus = '%s', place = '%s'" - " owner = '%s', group = '%s', mode = '%d'", - dev->name, dev->bus, dev->place, - dev->owner, dev->group, dev->mode); + if (s[0] == '\0') { + while (p[0] == '*') + p++; + return (p[0] != '\0'); + } + switch (p[0]) { + case '[': + { + int not = 0; + p++; + if (p[0] == '!') { + not = 1; + p++; + } + while ((p[0] != '\0') && (p[0] != ']')) { + int match = 0; + if (p[1] == '-') { + if ((s[0] >= p[0]) && (s[0] <= p[2])) + match = 1; + p += 3; + } else { + match = (p[0] == s[0]); + p++; + } + if (match ^ not) { + while ((p[0] != '\0') && (p[0] != ']')) + p++; + if (p[0] == ']') + return strcmp_pattern(p+1, s+1); + } + } + } break; - case REPLACE: - dbg("REPLACE name = %s, kernel_name = %s" - " owner = '%s', group = '%s', mode = '%d'", - dev->name, dev->kernel_name, - dev->owner, dev->group, dev->mode); + case '*': + if (strcmp_pattern(p, s+1)) + return strcmp_pattern(p+1, s); + return 0; + case '\0': + if (s[0] == '\0') { + return 0; + } break; default: - dbg("Unknown type of device!"); + if ((p[0] == s[0]) || (p[0] == '?')) + return strcmp_pattern(p+1, s+1); + break; } + return 1; } #define copy_var(a, b, var) \ @@ -126,332 +105,666 @@ static void dump_dev(struct config_device *dev) if (strlen(b->var)) \ strcpy(a->var, b->var); -static int add_dev(struct config_device *new_dev) +int add_perm_dev(struct perm_device *new_dev) { - struct list_head *tmp; - struct config_device *tmp_dev; - - /* loop through the whole list of devices to see if we already have - * this one... */ - list_for_each(tmp, &config_device_list) { - struct config_device *dev = list_entry(tmp, struct config_device, node); - if (strcmp(dev->name, new_dev->name) == 0) { - /* the same, copy the new info into this structure */ - copy_var(dev, new_dev, type); - copy_var(dev, new_dev, mode); - copy_string(dev, new_dev, bus); - copy_string(dev, new_dev, sysfs_file); - copy_string(dev, new_dev, sysfs_value); - copy_string(dev, new_dev, id); - copy_string(dev, new_dev, place); - copy_string(dev, new_dev, kernel_name); - copy_string(dev, new_dev, owner); - copy_string(dev, new_dev, group); - return 0; - } + struct perm_device *dev; + struct perm_device *tmp_dev; + + /* update the values if we already have the device */ + list_for_each_entry(dev, &perm_device_list, node) { + if (strcmp_pattern(new_dev->name, dev->name)) + continue; + copy_var(dev, new_dev, mode); + copy_string(dev, new_dev, owner); + copy_string(dev, new_dev, group); + return 0; } - /* not found, lets create a new structure, and add it to the list */ + /* not found, add new structure to the perm list */ tmp_dev = malloc(sizeof(*tmp_dev)); if (!tmp_dev) return -ENOMEM; memcpy(tmp_dev, new_dev, sizeof(*tmp_dev)); - list_add(&tmp_dev->node, &config_device_list); - //dump_dev(tmp_dev); + list_add_tail(&tmp_dev->node, &perm_device_list); + //dump_perm_dev(tmp_dev); return 0; } -static void dump_dev_list(void) +static struct perm_device *find_perm(char *name) { - struct list_head *tmp; + struct perm_device *perm; - list_for_each(tmp, &config_device_list) { - struct config_device *dev = list_entry(tmp, struct config_device, node); - dump_dev(dev); + list_for_each_entry(perm, &perm_device_list, node) { + if (strcmp_pattern(perm->name, name)) + continue; + return perm; } + return NULL; } -static int get_value(const char *left, char **orig_string, char **ret_string) +static mode_t get_default_mode(void) { - char *temp; - char *string = *orig_string; - - /* eat any whitespace */ - while (isspace(*string)) - ++string; - - /* split based on '=' */ - temp = strsep(&string, "="); - if (strcasecmp(temp, left) == 0) { - /* got it, now strip off the '"' */ - while (isspace(*string)) - ++string; - if (*string == '"') - ++string; - temp = strsep(&string, "\""); - *ret_string = temp; - *orig_string = string; - return 0; - } - return -ENODEV; + mode_t mode = 0600; /* default to owner rw only */ + + if (strlen(default_mode_str) != 0) + mode = strtol(default_mode_str, NULL, 8); + + return mode; } - -static int get_pair(char **orig_string, char **left, char **right) + +static char *get_default_owner(void) { - char *temp; - char *string = *orig_string; - - /* eat any whitespace */ - while (isspace(*string)) - ++string; - - /* split based on '=' */ - temp = strsep(&string, "="); - *left = temp; - - /* take the right side and strip off the '"' */ - while (isspace(*string)) - ++string; - if (*string == '"') - ++string; - temp = strsep(&string, "\""); - *right = temp; - *orig_string = string; - - return 0; + if (strlen(default_owner_str) == 0) + strncpy(default_owner_str, "root", OWNER_SIZE); + + return default_owner_str; } -static int namedev_init_config(void) +static char *get_default_group(void) { - char filename[255]; - char line[255]; - char *temp; - char *temp2; - char *temp3; - FILE *fd; - int retval = 0; - struct config_device dev; - - strcpy(filename, NAMEDEV_CONFIG_ROOT NAMEDEV_CONFIG_FILE); - dbg("opening %s to read as permissions config", filename); - fd = fopen(filename, "r"); - if (fd == NULL) { - dbg("Can't open %s", filename); - return -ENODEV; - } + if (strlen(default_group_str) == 0) + strncpy(default_group_str, "root", GROUP_SIZE); + + return default_group_str; +} - /* loop through the whole file */ +static void apply_format(struct udevice *udev, unsigned char *string) +{ + char temp[NAME_SIZE]; + char temp1[NAME_SIZE]; + char *tail; + char *pos; + char *pos2; + char *pos3; + int num; + + pos = string; while (1) { - /* get a line */ - temp = fgets(line, sizeof(line), fd); - if (temp == NULL) + num = 0; + pos = strchr(pos, '%'); + + if (pos) { + pos[0] = '\0'; + tail = pos+1; + if (isdigit(tail[0])) { + num = (int) strtoul(&pos[1], &tail, 10); + if (tail == NULL) { + dbg("format parsing error '%s'", pos+1); + break; + } + } + strfieldcpy(temp, tail+1); + + switch (tail[0]) { + case 'b': + if (strlen(udev->bus_id) == 0) + break; + strcat(pos, udev->bus_id); + dbg("substitute bus_id '%s'", udev->bus_id); + break; + case 'k': + if (strlen(udev->kernel_name) == 0) + break; + strcat(pos, udev->kernel_name); + dbg("substitute kernel name '%s'", udev->kernel_name); + break; + case 'n': + if (strlen(udev->kernel_number) == 0) + break; + strcat(pos, udev->kernel_number); + dbg("substitute kernel number '%s'", udev->kernel_number); + break; + case 'm': + sprintf(pos, "%u", udev->minor); + dbg("substitute minor number '%u'", udev->minor); + break; + case 'M': + sprintf(pos, "%u", udev->major); + dbg("substitute major number '%u'", udev->major); + break; + case 'c': + if (strlen(udev->program_result) == 0) + break; + if (num) { + /* get part of return string */ + strncpy(temp1, udev->program_result, sizeof(temp1)); + pos2 = temp1; + while (num) { + num--; + pos3 = strsep(&pos2, " "); + if (pos3 == NULL) { + dbg("requested part of result string not found"); + break; + } + } + if (pos3) { + strcat(pos, pos3); + dbg("substitute part of result string '%s'", pos3); + } + } else { + strcat(pos, udev->program_result); + dbg("substitute result string '%s'", udev->program_result); + } + break; + case '%': + strcat(pos, "%"); + pos++; + break; + default: + dbg("unknown substitution type '%%%c'", pos[1]); + break; + } + strcat(string, temp); + } else break; + } +} - dbg("read %s", temp); - - /* eat the whitespace at the beginning of the line */ - while (isspace(*temp)) - ++temp; - - /* no more line? */ - if (*temp == 0x00) - continue; +static struct bus_file { + char *bus; + char *file; +} bus_files[] = { + { .bus = "scsi", .file = "vendor" }, + { .bus = "usb", .file = "idVendor" }, + { .bus = "usb-serial", .file = "detach_state" }, + { .bus = "ide", .file = "detach_state" }, + { .bus = "pci", .file = "vendor" }, + {} +}; - /* see if this is a comment */ - if (*temp == COMMENT_CHARACTER) - continue; +#define SECONDS_TO_WAIT_FOR_FILE 10 +static void wait_for_device_to_initialize(struct sysfs_device *sysfs_device) +{ + /* sleep until we see the file for this specific bus type show up this + * is needed because we can easily out-run the kernel in looking for + * these files before the paticular subsystem has created them in the + * sysfs tree properly. + * + * And people thought that the /sbin/hotplug event system was going to + * be slow, poo on you for arguing that before even testing it... + */ + struct bus_file *b = &bus_files[0]; + struct sysfs_attribute *tmpattr; + int loop; - memset(&dev, 0x00, sizeof(struct config_device)); - - /* parse the line */ - temp2 = strsep(&temp, ","); - if (strcasecmp(temp2, TYPE_LABEL) == 0) { - /* label type */ - dev.type = LABEL; - - /* BUS="bus" */ - retval = get_value("BUS", &temp, &temp3); - if (retval) - continue; - strcpy(dev.bus, temp3); - - /* file="value" */ - temp2 = strsep(&temp, ","); - retval = get_pair(&temp, &temp2, &temp3); - if (retval) - continue; - strcpy(dev.sysfs_file, temp2); - strcpy(dev.sysfs_value, temp3); - - /* NAME="new_name" */ - temp2 = strsep(&temp, ","); - retval = get_value("NAME", &temp, &temp3); - if (retval) - continue; - strcpy(dev.name, temp3); - - dbg("LABEL name = '%s', bus = '%s', sysfs_file = '%s', sysfs_value = '%s'", dev.name, dev.bus, dev.sysfs_file, dev.sysfs_value); + while (1) { + if (b->bus == NULL) + break; + if (strcmp(sysfs_device->bus, b->bus) == 0) { + tmpattr = NULL; + loop = SECONDS_TO_WAIT_FOR_FILE; + while (loop--) { + dbg("looking for file '%s' on bus '%s'", b->file, b->bus); + tmpattr = sysfs_get_device_attr(sysfs_device, b->file); + if (tmpattr) { + /* found it! */ + goto exit; + } + /* sleep to give the kernel a chance to create the file */ + sleep(1); + } + dbg("timed out waiting for '%s' file, continuing on anyway...", b->file); + goto exit; } + b++; + } + dbg("did not find bus type '%s' on list of bus_id_files, contact greg@kroah.com", sysfs_device->bus); +exit: + return; /* here to prevent compiler warning... */ +} - if (strcasecmp(temp2, TYPE_NUMBER) == 0) { - /* number type */ - dev.type = NUMBER; - - /* BUS="bus" */ - retval = get_value("BUS", &temp, &temp3); - if (retval) - continue; - strcpy(dev.bus, temp3); - - /* ID="id" */ - temp2 = strsep(&temp, ","); - retval = get_value("id", &temp, &temp3); - if (retval) - continue; - strcpy(dev.id, temp3); - - /* NAME="new_name" */ - temp2 = strsep(&temp, ","); - retval = get_value("NAME", &temp, &temp3); - if (retval) - continue; - strcpy(dev.name, temp3); - - dbg("NUMBER name = '%s', bus = '%s', id = '%s'", dev.name, dev.bus, dev.id); +static int execute_program(char *path, char *value, int len) +{ + int retval; + int res; + int status; + int fds[2]; + pid_t pid; + int value_set = 0; + char buffer[256]; + char *pos; + char *args[PROGRAM_MAXARG]; + int i; + + dbg("executing '%s'", path); + retval = pipe(fds); + if (retval != 0) { + dbg("pipe failed"); + return -1; + } + pid = fork(); + switch(pid) { + case 0: + /* child */ + close(STDOUT_FILENO); + dup(fds[1]); /* dup write side of pipe to STDOUT */ + if (strchr(path, ' ')) { + /* exec with arguments */ + pos = path; + for (i=0; i < PROGRAM_MAXARG-1; i++) { + args[i] = strsep(&pos, " "); + if (args[i] == NULL) + break; + } + if (args[i]) { + dbg("too many args - %d", i); + args[i] = NULL; + } + retval = execv(args[0], args); + } else { + retval = execv(path, main_argv); } - - if (strcasecmp(temp2, TYPE_TOPOLOGY) == 0) { - /* number type */ - dev.type = TOPOLOGY; - - /* BUS="bus" */ - retval = get_value("BUS", &temp, &temp3); - if (retval) - continue; - strcpy(dev.bus, temp3); - - /* PLACE="place" */ - temp2 = strsep(&temp, ","); - retval = get_value("place", &temp, &temp3); - if (retval) - continue; - strcpy(dev.place, temp3); - - /* NAME="new_name" */ - temp2 = strsep(&temp, ","); - retval = get_value("NAME", &temp, &temp3); - if (retval) - continue; - strcpy(dev.name, temp3); - - dbg("TOPOLOGY name = '%s', bus = '%s', place = '%s'", dev.name, dev.bus, dev.place); + dbg("child execve failed"); + exit(1); + case -1: + dbg("fork failed"); + return -1; + default: + /* parent reads from fds[0] */ + close(fds[1]); + retval = 0; + while (1) { + res = read(fds[0], buffer, sizeof(buffer) - 1); + if (res <= 0) + break; + buffer[res] = '\0'; + if (res > len) { + dbg("result len %d too short", len); + retval = -1; + } + if (value_set) { + dbg("result value already set"); + retval = -1; + } else { + value_set = 1; + strncpy(value, buffer, len); + pos = value + strlen(value)-1; + if (pos[0] == '\n') + pos[0] = '\0'; + dbg("result is '%s'", value); + } + } + close(fds[0]); + res = wait(&status); + if (res < 0) { + dbg("wait failed result %d", res); + retval = -1; } - if (strcasecmp(temp2, TYPE_REPLACE) == 0) { - /* number type */ - dev.type = REPLACE; - - /* KERNEL="kernel_name" */ - retval = get_value("KERNEL", &temp, &temp3); - if (retval) - continue; - strcpy(dev.kernel_name, temp3); - - /* NAME="new_name" */ - temp2 = strsep(&temp, ","); - retval = get_value("NAME", &temp, &temp3); - if (retval) - continue; - strcpy(dev.name, temp3); - dbg("REPLACE name = %s, kernel_name = %s", dev.name, dev.kernel_name); + if (!WIFEXITED(status) || (WEXITSTATUS(status) != 0)) { + dbg("exec program status 0x%x", status); + retval = -1; } + } + return retval; +} - retval = add_dev(&dev); - if (retval) { - dbg("add_dev returned with error %d", retval); - goto exit; +static int compare_sysfs_attribute(struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device, struct sysfs_pair *pair) +{ + struct sysfs_attribute *tmpattr = NULL; + char *c; + + if ((pair == NULL) || (pair->file[0] == '\0') || (pair->value == '\0')) + return -ENODEV; + + dbg("look for device attribute '%s'", pair->file); + /* try to find the attribute in the class device directory */ + tmpattr = sysfs_get_classdev_attr(class_dev, pair->file); + if (tmpattr) + goto label_found; + + /* look in the class device directory if present */ + if (sysfs_device) { + tmpattr = sysfs_get_device_attr(sysfs_device, pair->file); + if (tmpattr) + goto label_found; + } + return -ENODEV; + +label_found: + c = tmpattr->value + strlen(tmpattr->value)-1; + if (*c == '\n') + *c = 0x00; + dbg("compare attribute '%s' value '%s' with '%s'", + pair->file, tmpattr->value, pair->value); + if (strcmp_pattern(pair->value, tmpattr->value) != 0) + return -ENODEV; + + dbg("found matching attribute '%s' with value '%s'", + pair->file, pair->value); + return 0; +} + +static int match_sysfs_pairs(struct config_device *dev, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device) +{ + struct sysfs_pair *pair; + int i; + + for (i = 0; i < MAX_SYSFS_PAIRS; ++i) { + pair = &dev->sysfs_pair[i]; + if ((pair->file[0] == '\0') || (pair->value[0] == '\0')) + break; + if (compare_sysfs_attribute(class_dev, sysfs_device, pair) != 0) { + dbg("sysfs attribute doesn't match"); + return -ENODEV; } } -exit: - fclose(fd); - return retval; -} + return 0; +} + +static int match_id(struct config_device *dev, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device) +{ + char path[SYSFS_PATH_MAX]; + int found; + char *temp = NULL; + /* we have to have a sysfs device for ID to work */ + if (!sysfs_device) + return -ENODEV; + + found = 0; + strfieldcpy(path, sysfs_device->path); + temp = strrchr(path, '/'); + dbg("search '%s' in '%s', path='%s'", dev->id, temp, path); + if (strstr(temp, dev->id) != NULL) { + found = 1; + } else { + *temp = 0x00; + temp = strrchr(path, '/'); + dbg("search '%s' in '%s', path='%s'", dev->id, temp, path); + if (strstr(temp, dev->id) != NULL) + found = 1; + } + if (!found) { + dbg("id doesn't match"); + return -ENODEV; + } -static int namedev_init_permissions(void) + return 0; +} + +static int match_place(struct config_device *dev, struct sysfs_class_device *class_dev, struct sysfs_device *sysfs_device) { - char filename[255]; - char line[255]; - char *temp; - char *temp2; - FILE *fd; - int retval = 0; - struct config_device dev; - - strcpy(filename, NAMEDEV_CONFIG_ROOT NAMEDEV_CONFIG_PERMISSION_FILE); - dbg("opening %s to read as permissions config", filename); - fd = fopen(filename, "r"); - if (fd == NULL) { - dbg("Can't open %s", filename); + char path[SYSFS_PATH_MAX]; + int found; + char *temp = NULL; + + /* we have to have a sysfs device for PLACE to work */ + if (!sysfs_device) + return -ENODEV; + + found = 0; + strfieldcpy(path, sysfs_device->path); + temp = strrchr(path, '/'); + dbg("search '%s' in '%s', path='%s'", dev->place, temp, path); + if (strstr(temp, dev->place) != NULL) { + found = 1; + } else { + *temp = 0x00; + temp = strrchr(path, '/'); + dbg("search '%s' in '%s', path='%s'", dev->place, temp, path); + if (strstr(temp, dev->place) != NULL) + found = 1; + } + if (!found) { + dbg("place doesn't match"); return -ENODEV; } - /* loop through the whole file */ + return 0; +} + +static struct sysfs_device *get_sysfs_device(struct sysfs_class_device *class_dev) +{ + struct sysfs_device *sysfs_device; + struct sysfs_class_device *class_dev_parent; + struct timespec tspec; + int loop; + + /* Figure out where the device symlink is at. For char devices this will + * always be in the class_dev->path. But for block devices, it's different. + * The main block device will have the device symlink in it's path, but + * all partitions have the symlink in its parent directory. + * But we need to watch out for block devices that do not have parents, yet + * look like a partition (fd0, loop0, etc.) They all do not have a device + * symlink yet. We do sit and spin on waiting for them right now, we should + * possibly have a whitelist for these devices here... + */ + class_dev_parent = sysfs_get_classdev_parent(class_dev); + if (class_dev_parent) + dbg("Really a partition"); + + tspec.tv_sec = 0; + tspec.tv_nsec = 10000000; /* sleep 10 millisec */ + loop = 10; + while (loop--) { + nanosleep(&tspec, NULL); + if (class_dev_parent) + sysfs_device = sysfs_get_classdev_device(class_dev_parent); + else + sysfs_device = sysfs_get_classdev_device(class_dev); + + if (sysfs_device != NULL) + goto device_found; + } + dbg("timed out waiting for device symlink, continuing on anyway..."); + +device_found: + /* We have another issue with just the wait above - the sysfs part of + * the kernel may not be quick enough to have created the link to the + * device under the "bus" subsystem. Due to this, the sysfs_device->bus + * will not contain the actual bus name :( + * + * Libsysfs now provides a new API sysfs_get_device_bus(), so use it + * if needed + */ + if (sysfs_device) { + if (sysfs_device->bus[0] != '\0') + goto bus_found; + + loop = 10; + tspec.tv_nsec = 10000000; + while (loop--) { + nanosleep(&tspec, NULL); + sysfs_get_device_bus(sysfs_device); + + if (sysfs_device->bus[0] != '\0') + goto bus_found; + } + dbg("timed out waiting to find the device bus, continuing on anyway"); + goto exit; +bus_found: + dbg("device %s is registered with bus '%s'", + sysfs_device->name, sysfs_device->bus); + } +exit: + return sysfs_device; +} + +static int match_rule(struct config_device *dev, struct sysfs_class_device *class_dev, struct udevice *udev, struct sysfs_device *sysfs_device) +{ while (1) { - /* get a line */ - temp = fgets(line, sizeof(line), fd); - if (temp == NULL) - break; + /* check for matching bus value */ + if (dev->bus[0] != '\0') { + if (sysfs_device == NULL) { + dbg("device has no bus"); + goto no_good; + } + dbg("check for " FIELD_BUS " dev->bus='%s' sysfs_device->bus='%s'", dev->bus, sysfs_device->bus); + if (strcmp_pattern(dev->bus, sysfs_device->bus) != 0) { + dbg(FIELD_BUS " is not matching"); + goto no_good; + } else { + dbg(FIELD_BUS " matches"); + } + } - dbg("read %s", temp); + /* check for matching kernel name*/ + if (dev->kernel[0] != '\0') { + dbg("check for " FIELD_KERNEL " dev->kernel='%s' class_dev->name='%s'", dev->kernel, class_dev->name); + if (strcmp_pattern(dev->kernel, class_dev->name) != 0) { + dbg(FIELD_KERNEL " is not matching"); + goto no_good; + } else { + dbg(FIELD_KERNEL " matches"); + } + } - /* eat the whitespace at the beginning of the line */ - while (isspace(*temp)) - ++temp; + /* check for matching bus id */ + if (dev->id[0] != '\0') { + dbg("check " FIELD_ID); + if (match_id(dev, class_dev, sysfs_device) != 0) { + dbg(FIELD_ID " is not matching"); + goto no_good; + } else { + dbg(FIELD_ID " matches"); + } + } - /* no more line? */ - if (*temp == 0x00) - continue; + /* check for matching place of device */ + if (dev->place[0] != '\0') { + dbg("check " FIELD_PLACE); + if (match_place(dev, class_dev, sysfs_device) != 0) { + dbg(FIELD_PLACE " is not matching"); + goto no_good; + } else { + dbg(FIELD_PLACE " matches"); + } + } - /* see if this is a comment */ - if (*temp == COMMENT_CHARACTER) - continue; + /* check for matching sysfs pairs */ + if (dev->sysfs_pair[0].file[0] != '\0') { + dbg("check " FIELD_SYSFS " pairs"); + if (match_sysfs_pairs(dev, class_dev, sysfs_device) != 0) { + dbg(FIELD_SYSFS " is not matching"); + goto no_good; + } else { + dbg(FIELD_SYSFS " matches"); + } + } - memset(&dev, 0x00, sizeof(dev)); + /* execute external program */ + if (dev->program[0] != '\0') { + dbg("check " FIELD_PROGRAM); + apply_format(udev, dev->program); + if (execute_program(dev->program, udev->program_result, NAME_SIZE) != 0) { + dbg(FIELD_PROGRAM " returned nozero"); + goto no_good; + } else { + dbg(FIELD_PROGRAM " returned successful"); + } + } - /* parse the line */ - temp2 = strsep(&temp, ":"); - strncpy(dev.name, temp2, sizeof(dev.name)); + /* check for matching result of external program */ + if (dev->result[0] != '\0') { + dbg("check for " FIELD_RESULT + " dev->result='%s', udev->program_result='%s'", + dev->result, udev->program_result); + if (strcmp_pattern(dev->result, udev->program_result) != 0) { + dbg(FIELD_RESULT " is not matching"); + goto no_good; + } else { + dbg(FIELD_RESULT " matches"); + } + } - temp2 = strsep(&temp, ":"); - strncpy(dev.owner, temp2, sizeof(dev.owner)); + /* check if we are instructed to ignore this device */ + if (dev->name[0] == '\0') { + dbg("instructed to ignore this device"); + return -1; + } - temp2 = strsep(&temp, ":"); - strncpy(dev.group, temp2, sizeof(dev.owner)); + /* Yeah, we matched! */ + return 0; - dev.mode = strtol(temp, NULL, 8); +no_good: + sysfs_device = sysfs_get_device_parent(sysfs_device); + if (sysfs_device == NULL) + return -ENODEV; + dbg("sysfs_device->path='%s'", sysfs_device->path); + dbg("sysfs_device->bus_id='%s'", sysfs_device->bus_id); + dbg("sysfs_device->bus='%s'", sysfs_device->bus); + } - dbg("name = %s, owner = %s, group = %s, mode = %x", dev.name, dev.owner, dev.group, dev.mode); - retval = add_dev(&dev); - if (retval) { - dbg("add_dev returned with error %d", retval); - goto exit; - } +} + +int namedev_name_device(struct sysfs_class_device *class_dev, struct udevice *udev) +{ + struct sysfs_device *sysfs_device = NULL; + struct config_device *dev; + struct perm_device *perm; + char *pos; + + udev->mode = 0; + + /* find the sysfs_device associated with this class device */ + sysfs_device = get_sysfs_device(class_dev); + if (sysfs_device) { + dbg("sysfs_device->path='%s'", sysfs_device->path); + dbg("sysfs_device->bus_id='%s'", sysfs_device->bus_id); + dbg("sysfs_device->bus='%s'", sysfs_device->bus); + strfieldcpy(udev->bus_id, sysfs_device->bus_id); + wait_for_device_to_initialize(sysfs_device); + } else { + dbg("class_dev->name = '%s'", class_dev->name); } -exit: - fclose(fd); - return retval; -} + strfieldcpy(udev->kernel_name, class_dev->name); + + /* get kernel number */ + pos = class_dev->name + strlen(class_dev->name); + while (isdigit(*(pos-1))) + pos--; + strfieldcpy(udev->kernel_number, pos); + dbg("kernel_number='%s'", udev->kernel_number); + + /* look for a matching rule to apply */ + list_for_each_entry(dev, &config_device_list, node) { + dbg("process rule"); + + if (match_rule(dev, class_dev, udev, sysfs_device) == 0) { + /* Yup, this rule belongs to us! */ + info("configured rule in '%s' at line %i applied, '%s' becomes '%s'", + udev_rules_filename, dev->config_line, udev->kernel_name, dev->name); + strfieldcpy(udev->name, dev->name); + strfieldcpy(udev->symlink, dev->symlink); + goto found; + } + } + /* no rule was found so we use the kernel name */ + strfieldcpy(udev->name, class_dev->name); + goto done; + +found: + /* substitute placeholder */ + apply_format(udev, udev->name); + apply_format(udev, udev->symlink); + +done: + perm = find_perm(udev->name); + if (perm) { + udev->mode = perm->mode; + strfieldcpy(udev->owner, perm->owner); + strfieldcpy(udev->group, perm->group); + } else { + /* no matching perms found :( */ + udev->mode = get_default_mode(); + strncpy(udev->owner, get_default_owner(), OWNER_SIZE); + strncpy(udev->group, get_default_group(), GROUP_SIZE); + } + dbg("name, '%s' is going to have owner='%s', group='%s', mode = %#o", + udev->name, udev->owner, udev->group, udev->mode); + return 0; +} int namedev_init(void) { int retval; - retval = namedev_init_config(); + retval = namedev_init_rules(); if (retval) return retval; @@ -459,7 +772,7 @@ int namedev_init(void) if (retval) return retval; - dump_dev_list(); + dump_config_dev_list(); + dump_perm_dev_list(); return retval; } -