Lines Matching refs:rules
52 UDEV_CONF_DIR "/rules.d",
54 UDEV_ROOT_RUN "/udev/rules.d",
55 UDEV_LIBEXEC_DIR "/rules.d",
57 "/lib/udev/rules.d",
58 "/usr/lib/udev/rules.d",
67 /* every key in the rules file becomes a token */
84 static char *rules_str(struct udev_rules *rules, unsigned int off) {
85 return rules->strbuf->buf + off;
88 static unsigned int rules_add_string(struct udev_rules *rules, const char *s) {
89 return strbuf_add_string(rules->strbuf, s, strlen(s));
222 struct udev_rules *rules;
324 static void dump_token(struct udev_rules *rules, struct token *token) {
328 const char *value = str(rules, token->key.value_off);
329 const char *attr = &rules->buf[token->key.attr_off];
334 const char *tks_ptr = (char *)rules->tokens;
339 &rules->buf[token->rule.filename_off], token->rule.filename_line,
341 &rules->buf[token->rule.label_off]);
435 static void dump_rules(struct udev_rules *rules) {
439 rules->token_cur,
440 rules->token_cur * sizeof(struct token),
441 rules->buf_count,
442 rules->buf_cur);
443 for (i = 0; i < rules->token_cur; i++)
444 dump_token(rules, &rules->tokens[i]);
447 static inline void dump_token(struct udev_rules *rules, struct token *token) {}
448 static inline void dump_rules(struct udev_rules *rules) {}
451 static int add_token(struct udev_rules *rules, struct token *token) {
453 if (rules->token_cur+1 >= rules->token_max) {
458 add = rules->token_max;
462 tokens = realloc(rules->tokens, (rules->token_max + add ) * sizeof(struct token));
465 rules->tokens = tokens;
466 rules->token_max += add;
468 memcpy(&rules->tokens[rules->token_cur], token, sizeof(struct token));
469 rules->token_cur++;
473 static uid_t add_uid(struct udev_rules *rules, const char *owner) {
480 for (i = 0; i < rules->uids_cur; i++) {
481 off = rules->uids[i].name_off;
482 if (streq(rules_str(rules, off), owner)) {
483 uid = rules->uids[i].uid;
496 if (rules->uids_cur+1 >= rules->uids_max) {
501 add = rules->uids_max;
505 uids = realloc(rules->uids, (rules->uids_max + add ) * sizeof(struct uid_gid));
508 rules->uids = uids;
509 rules->uids_max += add;
511 rules->uids[rules->uids_cur].uid = uid;
512 off = rules_add_string(rules, owner);
515 rules->uids[rules->uids_cur].name_off = off;
516 rules->uids_cur++;
520 static gid_t add_gid(struct udev_rules *rules, const char *group) {
527 for (i = 0; i < rules->gids_cur; i++) {
528 off = rules->gids[i].name_off;
529 if (streq(rules_str(rules, off), group)) {
530 gid = rules->gids[i].gid;
543 if (rules->gids_cur+1 >= rules->gids_max) {
548 add = rules->gids_max;
552 gids = realloc(rules->gids, (rules->gids_max + add ) * sizeof(struct uid_gid));
555 rules->gids = gids;
556 rules->gids_max += add;
558 rules->gids[rules->gids_cur].gid = gid;
559 off = rules_add_string(rules, group);
562 rules->gids[rules->gids_cur].name_off = off;
563 rules->gids_cur++;
905 token->key.value_off = rules_add_string(rule_tmp->rules, value);
908 token->key.value_off = rules_add_string(rule_tmp->rules, value);
920 token->key.value_off = rules_add_string(rule_tmp->rules, value);
921 token->key.attr_off = rules_add_string(rule_tmp->rules, attr);
924 token->key.value_off = rules_add_string(rule_tmp->rules, value);
935 token->key.value_off = rules_add_string(rule_tmp->rules, value);
961 /* check if we need to split or call fnmatch() while matching rules */
1013 static int sort_token(struct udev_rules *rules, struct rule_tmp *rule_tmp) {
1034 if (add_token(rules, &rule_tmp->token[next_idx]) != 0)
1047 static int add_rule(struct udev_rules *rules, char *line,
1054 rule_tmp.rules = rules;
1067 if (get_key(rules->udev, &linepos, &key, &op, &value) != 0) {
1144 attr = get_key_attribute(rules->udev, key + strlen("ATTR"));
1161 attr = get_key_attribute(rules->udev, key + strlen("SYSCTL"));
1178 attr = get_key_attribute(rules->udev, key + strlen("SECLABEL"));
1224 attr = get_key_attribute(rules->udev, key + strlen("ATTRS"));
1249 attr = get_key_attribute(rules->udev, key + strlen("ENV"));
1316 attr = get_key_attribute(rules->udev, key + strlen("IMPORT"));
1366 attr = get_key_attribute(rules->udev, key + strlen("TEST"));
1377 attr = get_key_attribute(rules->udev, key + strlen("RUN"));
1417 rule_tmp.rule.rule.label_off = rules_add_string(rules, value);
1479 } else if ((rules->resolve_names > 0) && strchr("$%", value[0]) == NULL) {
1480 uid = add_uid(rules, value);
1482 } else if (rules->resolve_names >= 0) {
1501 } else if ((rules->resolve_names > 0) && strchr("$%", value[0]) == NULL) {
1502 gid = add_gid(rules, value);
1504 } else if (rules->resolve_names >= 0) {
1586 if (add_token(rules, &rule_tmp.rule) != 0)
1590 if (sort_token(rules, &rule_tmp) != 0)
1599 static int parse_file(struct udev_rules *rules, const char *filename) {
1619 log_debug("Reading rules file: %s", filename);
1621 first_token = rules->token_cur;
1622 filename_off = rules_add_string(rules, filename);
1656 add_rule(rules, key, filename, filename_off, line_nr);
1659 /* link GOTOs to LABEL rules in this file to be able to fast-forward */
1660 for (i = first_token+1; i < rules->token_cur; i++) {
1661 if (rules->tokens[i].type == TK_A_GOTO) {
1662 char *label = rules_str(rules, rules->tokens[i].key.value_off);
1665 for (j = i+1; j < rules->token_cur; j++) {
1666 if (rules->tokens[j].type != TK_RULE)
1668 if (rules->tokens[j].rule.label_off == 0)
1670 if (!streq(label, rules_str(rules, rules->tokens[j].rule.label_off)))
1672 rules->tokens[i].key.rule_goto = j;
1675 if (rules->tokens[i].key.rule_goto == 0)
1683 struct udev_rules *rules;
1689 rules = new0(struct udev_rules, 1);
1690 if (rules == NULL)
1692 rules->udev = udev;
1693 rules->resolve_names = resolve_names;
1697 rules->tokens = malloc(PREALLOC_TOKEN * sizeof(struct token));
1698 if (rules->tokens == NULL)
1699 return udev_rules_unref(rules);
1700 rules->token_max = PREALLOC_TOKEN;
1702 rules->strbuf = strbuf_new();
1703 if (!rules->strbuf)
1704 return udev_rules_unref(rules);
1706 udev_rules_check_timestamp(rules);
1708 r = conf_files_list_strv(&files, ".rules", NULL, rules_dirs);
1710 log_error_errno(r, "failed to enumerate rules files: %m");
1711 return udev_rules_unref(rules);
1715 * The offset value in the rules strct is limited; add all
1716 * rules file names to the beginning of the string buffer.
1719 rules_add_string(rules, *f);
1722 parse_file(rules, *f);
1728 add_token(rules, &end_token);
1729 log_debug("rules contain %zu bytes tokens (%u * %zu bytes), %zu bytes strings",
1730 rules->token_max * sizeof(struct token), rules->token_max, sizeof(struct token), rules->strbuf->len);
1734 rules->strbuf->in_count, rules->strbuf->in_len,
1735 rules->strbuf->dedup_count, rules->strbuf->dedup_len, rules->strbuf->nodes_count);
1736 strbuf_complete(rules->strbuf);
1739 free(rules->uids);
1740 rules->uids = NULL;
1741 rules->uids_cur = 0;
1742 rules->uids_max = 0;
1743 free(rules->gids);
1744 rules->gids = NULL;
1745 rules->gids_cur = 0;
1746 rules->gids_max = 0;
1748 dump_rules(rules);
1749 return rules;
1752 struct udev_rules *udev_rules_unref(struct udev_rules *rules) {
1753 if (rules == NULL)
1755 free(rules->tokens);
1756 strbuf_cleanup(rules->strbuf);
1757 free(rules->uids);
1758 free(rules->gids);
1759 free(rules);
1763 bool udev_rules_check_timestamp(struct udev_rules *rules) {
1764 if (!rules)
1767 return paths_check_timestamp(rules_dirs, &rules->dirs_ts_usec, true);
1770 static int match_key(struct udev_rules *rules, struct token *token, const char *val) {
1771 char *key_value = rules_str(rules, token->key.value_off);
1790 s = rules_str(rules, token->key.value_off);
1814 strscpy(value, sizeof(value), rules_str(rules, token->key.value_off));
1843 static int match_attr(struct udev_rules *rules, struct udev_device *dev, struct udev_event *event, struct token *cur) {
1850 name = rules_str(rules, cur->key.attr_off);
1876 key_value = rules_str(rules, cur->key.value_off);
1888 return match_key(rules, cur, value);
1897 int udev_rules_apply_to_event(struct udev_rules *rules,
1908 if (rules->tokens == NULL)
1916 cur = &rules->tokens[0];
1919 dump_token(rules, cur);
1924 /* possibly skip rules which want to set NAME, SYMLINK, OWNER, GROUP, MODE */
1930 if (match_key(rules, cur, udev_device_get_action(event->dev)) != 0)
1934 if (match_key(rules, cur, udev_device_get_devpath(event->dev)) != 0)
1938 if (match_key(rules, cur, udev_device_get_sysname(event->dev)) != 0)
1949 if (match_key(rules, cur, devlink) == 0) {
1959 if (match_key(rules, cur, event->name) != 0)
1963 const char *key_name = rules_str(rules, cur->key.attr_off);
1980 if (match_key(rules, cur, value))
1989 if (streq(rules_str(rules, cur->key.value_off), udev_list_entry_get_name(list_entry))) {
1999 if (match_key(rules, cur, udev_device_get_subsystem(event->dev)) != 0)
2003 if (match_key(rules, cur, udev_device_get_driver(event->dev)) != 0)
2010 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), filename, sizeof(filename), false);
2017 if (match_attr(rules, event->dev, event, cur) != 0)
2025 udev_event_apply_format(event, rules_str(rules, cur->key.attr_off), filename, sizeof(filename), false);
2033 if (match_key(rules, cur, value) != 0)
2056 dump_token(rules, key);
2059 if (match_key(rules, key, udev_device_get_sysname(event->dev_parent)) != 0)
2063 if (match_key(rules, key, udev_device_get_subsystem(event->dev_parent)) != 0)
2067 if (match_key(rules, key, udev_device_get_driver(event->dev_parent)) != 0)
2071 if (match_attr(rules, event->dev_parent, event, key) != 0)
2075 bool match = udev_device_has_tag(event->dev_parent, rules_str(rules, cur->key.value_off));
2103 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), filename, sizeof(filename), false);
2131 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), program, sizeof(program), false);
2135 rules_str(rules, rule->rule.filename_off),
2159 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), import, sizeof(import), false);
2168 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), import, sizeof(import), false);
2171 rules_str(rules, rule->rule.filename_off),
2187 rules_str(rules, rule->rule.filename_off),
2199 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), command, sizeof(command), false);
2202 rules_str(rules, rule->rule.filename_off),
2216 const char *key = rules_str(rules, cur->key.value_off);
2237 const char *key = rules_str(rules, cur->key.value_off);
2269 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), import, sizeof(import), false);
2276 if (match_key(rules, cur, event->program_result) != 0)
2307 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), owner, sizeof(owner), false);
2320 rules_str(rules, rule->rule.filename_off),
2333 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), group, sizeof(group), false);
2346 rules_str(rules, rule->rule.filename_off),
2357 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), mode_str, sizeof(mode_str), false);
2369 rules_str(rules, rule->rule.filename_off),
2382 rules_str(rules, rule->rule.filename_off),
2394 rules_str(rules, rule->rule.filename_off),
2406 rules_str(rules, rule->rule.filename_off),
2412 name = rules_str(rules, cur->key.attr_off);
2413 label = rules_str(rules, cur->key.value_off);
2419 rules_str(rules, rule->rule.filename_off),
2424 const char *name = rules_str(rules, cur->key.attr_off);
2425 char *value = rules_str(rules, cur->key.value_off);
2454 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), tag, sizeof(tag), false);
2473 const char *name = rules_str(rules, cur->key.value_off);
2492 rules_str(rules, rule->rule.filename_off), rule->rule.filename_line);
2499 rules_str(rules, rule->rule.filename_off),
2519 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), temp, sizeof(temp), esc != ESCAPE_NONE);
2533 rules_str(rules, rule->rule.filename_off), rule->rule.filename_line);
2543 rules_str(rules, rule->rule.filename_off), rule->rule.filename_line);
2550 const char *key_name = rules_str(rules, cur->key.attr_off);
2559 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), value, sizeof(value), false);
2561 rules_str(rules, rule->rule.filename_off),
2578 udev_event_apply_format(event, rules_str(rules, cur->key.attr_off), filename, sizeof(filename), false);
2580 udev_event_apply_format(event, rules_str(rules, cur->key.value_off), value, sizeof(value), false);
2582 rules_str(rules, rule->rule.filename_off), rule->rule.filename_line);
2595 rules_str(rules, cur->key.value_off),
2596 rules_str(rules, rule->rule.filename_off),
2598 entry = udev_list_entry_add(&event->run_list, rules_str(rules, cur->key.value_off), NULL);
2605 cur = &rules->tokens[cur->key.rule_goto];
2626 int udev_rules_apply_static_dev_perms(struct udev_rules *rules) {
2638 if (rules->tokens == NULL)
2641 cur = &rules->tokens[0];
2649 /* skip rules without a static_node tag */
2669 r = strv_extend(&tags, rules_str(rules, cur->key.value_off));
2685 strscpyl(device_node, sizeof(device_node), "/dev/", rules_str(rules, cur->key.value_off), NULL);
2701 unescaped_filename = xescape(rules_str(rules, cur->key.value_off), "/.");
2772 /* function to return the count of rules that assign NAME= to a value matching arg#2 - returns 0,1 */
2773 int udev_rules_assigning_name_to(struct udev_rules *rules, const char *match_name)
2780 if (rules->tokens == NULL)
2784 cur = &rules->tokens[0];
2787 dump_token(rules, cur);
2796 if (match_key(rules, cur, "net") != 0)
2800 if (match_key(rules, cur, "add") != 0)
2804 const char *name = rules_str(rules, cur->key.value_off);
2815 rules_str(rules, rule->rule.filename_off),