]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/udev/udev-rules.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
build-sys: add $(AM_CFLAGS) where needed
[thirdparty/systemd.git] / src / udev / udev-rules.c
CommitLineData
2232cac8 1/*
5539f624 2 * Copyright (C) 2003-2010 Kay Sievers <kay.sievers@vrfy.org>
023ed7b0 3 * Copyright (C) 2008 Alan Jenkins <alan-jenkins@tuffmail.co.uk>
2232cac8 4 *
55e9959b
KS		 5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 2 of the License, or
8 * (at your option) any later version.
3d6d12c6 9 *
55e9959b
KS		 10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
2232cac8 14 *
55e9959b
KS		 15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
2232cac8
GKH		 17 */
18
19#include <stddef.h>
1449a55d 20#include <limits.h>
2232cac8 21#include <stdlib.h>
6d87ee2e 22#include <stdbool.h>
2232cac8
GKH		 23#include <string.h>
24#include <stdio.h>
25#include <fcntl.h>
26#include <ctype.h>
27#include <unistd.h>
28#include <errno.h>
5ee7ecfb 29#include <dirent.h>
cea61f5c 30#include <fnmatch.h>
959e8b5d 31#include <time.h>
2232cac8 32
2232cac8 33#include "udev.h"
2232cac8 34
a1525d17
KS		 35#define PREALLOC_TOKEN 2048
36#define PREALLOC_STRBUF 32 * 1024
37#define PREALLOC_TRIE 256
c7521974 38
4052400f 39struct uid_gid {
912541b0
KS		 40 unsigned int name_off;
41 union {
a1525d17
KS		 42 uid_t uid;
43 gid_t gid;
912541b0 44 };
4052400f
KS		 45};
46
1449a55d 47struct trie_node {
912541b0
KS		 48 /* this node's first child */
49 unsigned int child_idx;
50 /* the next child of our parent node's child list */
51 unsigned int next_child_idx;
52 /* this node's last child (shortcut for append) */
53 unsigned int last_child_idx;
54 unsigned int value_off;
55 unsigned short value_len;
56 unsigned char key;
1449a55d
AJ		 57};
58
4052400f 59struct udev_rules {
912541b0
KS		 60 struct udev *udev;
61 int resolve_names;
62
63 /* every key in the rules file becomes a token */
64 struct token *tokens;
65 unsigned int token_cur;
66 unsigned int token_max;
67
68 /* all key strings are copied to a single string buffer */
69 char *buf;
70 size_t buf_cur;
71 size_t buf_max;
72 unsigned int buf_count;
73
74 /* during rule parsing, strings are indexed to find duplicates */
75 struct trie_node *trie_nodes;
76 unsigned int trie_nodes_cur;
77 unsigned int trie_nodes_max;
78
79 /* during rule parsing, uid/gid lookup results are cached */
80 struct uid_gid *uids;
81 unsigned int uids_cur;
82 unsigned int uids_max;
83 struct uid_gid *gids;
84 unsigned int gids_cur;
85 unsigned int gids_max;
4052400f
KS		 86};
87
1449a55d 88/* KEY=="", KEY!="", KEY+="", KEY="", KEY:="" */
b0f7409f 89enum operation_type {
912541b0 90 OP_UNSET,
b0f7409f 91
912541b0
KS		 92 OP_MATCH,
93 OP_NOMATCH,
94 OP_MATCH_MAX,
b0f7409f 95
912541b0
KS		 96 OP_ADD,
97 OP_ASSIGN,
98 OP_ASSIGN_FINAL,
c7521974
KS		 99};
100
ac218d9c 101enum string_glob_type {
912541b0 102 GL_UNSET,
a1525d17 103 GL_PLAIN, /* no special chars */
912541b0 104 GL_GLOB, /* shell globs ?,*,[] */
a1525d17
KS		 105 GL_SPLIT, /* multi-value A|B */
106 GL_SPLIT_GLOB, /* multi-value with glob A*|B* */
107 GL_SOMETHING, /* commonly used "?*" */
ac218d9c
KS		 108};
109
32028733 110enum string_subst_type {
912541b0
KS		 111 SB_UNSET,
112 SB_NONE,
113 SB_FORMAT,
114 SB_SUBSYS,
32028733
KS		 115};
116
154a7b84 117/* tokens of a rule are sorted/handled in this order */
6880b25d 118enum token_type {
912541b0
KS		 119 TK_UNSET,
120 TK_RULE,
121
a1525d17
KS		 122 TK_M_ACTION, /* val */
123 TK_M_DEVPATH, /* val */
124 TK_M_KERNEL, /* val */
125 TK_M_DEVLINK, /* val */
126 TK_M_NAME, /* val */
127 TK_M_ENV, /* val, attr */
128 TK_M_TAG, /* val */
129 TK_M_SUBSYSTEM, /* val */
130 TK_M_DRIVER, /* val */
131 TK_M_WAITFOR, /* val */
132 TK_M_ATTR, /* val, attr */
912541b0
KS		 133
134 TK_M_PARENTS_MIN,
a1525d17 135 TK_M_KERNELS, /* val */
912541b0 136 TK_M_SUBSYSTEMS, /* val */
a1525d17
KS		 137 TK_M_DRIVERS, /* val */
138 TK_M_ATTRS, /* val, attr */
139 TK_M_TAGS, /* val */
912541b0
KS		 140 TK_M_PARENTS_MAX,
141
a1525d17
KS		 142 TK_M_TEST, /* val, mode_t */
143 TK_M_EVENT_TIMEOUT, /* int */
144 TK_M_PROGRAM, /* val */
145 TK_M_IMPORT_FILE, /* val */
146 TK_M_IMPORT_PROG, /* val */
147 TK_M_IMPORT_BUILTIN, /* val */
148 TK_M_IMPORT_DB, /* val */
149 TK_M_IMPORT_CMDLINE, /* val */
150 TK_M_IMPORT_PARENT, /* val */
151 TK_M_RESULT, /* val */
912541b0
KS		 152 TK_M_MAX,
153
154 TK_A_STRING_ESCAPE_NONE,
155 TK_A_STRING_ESCAPE_REPLACE,
156 TK_A_DB_PERSIST,
a1525d17
KS		 157 TK_A_INOTIFY_WATCH, /* int */
158 TK_A_DEVLINK_PRIO, /* int */
159 TK_A_OWNER, /* val */
160 TK_A_GROUP, /* val */
161 TK_A_MODE, /* val */
162 TK_A_OWNER_ID, /* uid_t */
163 TK_A_GROUP_ID, /* gid_t */
164 TK_A_MODE_ID, /* mode_t */
165 TK_A_STATIC_NODE, /* val */
166 TK_A_ENV, /* val, attr */
167 TK_A_TAG, /* val */
168 TK_A_NAME, /* val */
169 TK_A_DEVLINK, /* val */
170 TK_A_ATTR, /* val, attr */
83cd6b75
KS		 171 TK_A_RUN_BUILTIN, /* val, bool */
172 TK_A_RUN_PROGRAM, /* val, bool */
a1525d17 173 TK_A_GOTO, /* size_t */
912541b0
KS		 174
175 TK_END,
c7521974
KS		 176};
177
3f3aa9f5 178/* we try to pack stuff in a way that we take only 12 bytes per token */
4052400f 179struct token {
912541b0
KS		 180 union {
181 unsigned char type; /* same in rule and key */
182 struct {
183 enum token_type type:8;
184 bool can_set_name:1;
185 bool has_static_node:1;
186 unsigned int unused:6;
187 unsigned short token_count;
188 unsigned int label_off;
189 unsigned short filename_off;
190 unsigned short filename_line;
191 } rule;
192 struct {
193 enum token_type type:8;
194 enum operation_type op:8;
195 enum string_glob_type glob:8;
196 enum string_subst_type subst:4;
197 enum string_subst_type attrsubst:4;
198 unsigned int value_off;
199 union {
200 unsigned int attr_off;
201 int devlink_unique;
202 unsigned int rule_goto;
203 mode_t mode;
204 uid_t uid;
205 gid_t gid;
206 int devlink_prio;
207 int event_timeout;
208 int watch;
209 enum udev_builtin_cmd builtin_cmd;
210 };
211 } key;
212 };
4052400f
KS		 213};
214
912541b0 215#define MAX_TK 64
4052400f 216struct rule_tmp {
912541b0
KS		 217 struct udev_rules *rules;
218 struct token rule;
219 struct token token[MAX_TK];
220 unsigned int token_cur;
4052400f
KS		 221};
222
baa30fbc 223#ifdef DEBUG
5d6a1fa6
KS		 224static const char *operation_str(enum operation_type type)
225{
912541b0 226 static const char *operation_strs[] = {
a1525d17
KS		 227 [OP_UNSET] = "UNSET",
228 [OP_MATCH] = "match",
229 [OP_NOMATCH] = "nomatch",
912541b0
KS		 230 [OP_MATCH_MAX] = "MATCH_MAX",
231
a1525d17
KS		 232 [OP_ADD] = "add",
233 [OP_ASSIGN] = "assign",
234 [OP_ASSIGN_FINAL] = "assign-final",
912541b0
KS		 235} ;
236
237 return operation_strs[type];
5d6a1fa6 238}
4052400f 239
5d6a1fa6
KS		 240static const char *string_glob_str(enum string_glob_type type)
241{
912541b0 242 static const char *string_glob_strs[] = {
a1525d17
KS		 243 [GL_UNSET] = "UNSET",
244 [GL_PLAIN] = "plain",
245 [GL_GLOB] = "glob",
246 [GL_SPLIT] = "split",
247 [GL_SPLIT_GLOB] = "split-glob",
248 [GL_SOMETHING] = "split-glob",
912541b0
KS		 249 };
250
251 return string_glob_strs[type];
5d6a1fa6
KS		 252}
253
254static const char *token_str(enum token_type type)
255{
912541b0 256 static const char *token_strs[] = {
a1525d17
KS		 257 [TK_UNSET] = "UNSET",
258 [TK_RULE] = "RULE",
912541b0 259
a1525d17 260 [TK_M_ACTION] = "M ACTION",
912541b0 261 [TK_M_DEVPATH] = "M DEVPATH",
a1525d17 262 [TK_M_KERNEL] = "M KERNEL",
912541b0 263 [TK_M_DEVLINK] = "M DEVLINK",
a1525d17
KS		 264 [TK_M_NAME] = "M NAME",
265 [TK_M_ENV] = "M ENV",
266 [TK_M_TAG] = "M TAG",
267 [TK_M_SUBSYSTEM] = "M SUBSYSTEM",
268 [TK_M_DRIVER] = "M DRIVER",
912541b0 269 [TK_M_WAITFOR] = "M WAITFOR",
a1525d17 270 [TK_M_ATTR] = "M ATTR",
912541b0 271
a1525d17 272 [TK_M_PARENTS_MIN] = "M PARENTS_MIN",
912541b0 273 [TK_M_KERNELS] = "M KERNELS",
a1525d17 274 [TK_M_SUBSYSTEMS] = "M SUBSYSTEMS",
912541b0 275 [TK_M_DRIVERS] = "M DRIVERS",
a1525d17
KS		 276 [TK_M_ATTRS] = "M ATTRS",
277 [TK_M_TAGS] = "M TAGS",
278 [TK_M_PARENTS_MAX] = "M PARENTS_MAX",
912541b0 279
a1525d17
KS		 280 [TK_M_TEST] = "M TEST",
281 [TK_M_EVENT_TIMEOUT] = "M EVENT_TIMEOUT",
912541b0 282 [TK_M_PROGRAM] = "M PROGRAM",
a1525d17
KS		 283 [TK_M_IMPORT_FILE] = "M IMPORT_FILE",
284 [TK_M_IMPORT_PROG] = "M IMPORT_PROG",
285 [TK_M_IMPORT_BUILTIN] = "M IMPORT_BUILTIN",
286 [TK_M_IMPORT_DB] = "M IMPORT_DB",
287 [TK_M_IMPORT_CMDLINE] = "M IMPORT_CMDLINE",
288 [TK_M_IMPORT_PARENT] = "M IMPORT_PARENT",
289 [TK_M_RESULT] = "M RESULT",
290 [TK_M_MAX] = "M MAX",
291
292 [TK_A_STRING_ESCAPE_NONE] = "A STRING_ESCAPE_NONE",
293 [TK_A_STRING_ESCAPE_REPLACE] = "A STRING_ESCAPE_REPLACE",
294 [TK_A_DB_PERSIST] = "A DB_PERSIST",
295 [TK_A_INOTIFY_WATCH] = "A INOTIFY_WATCH",
296 [TK_A_DEVLINK_PRIO] = "A DEVLINK_PRIO",
297 [TK_A_OWNER] = "A OWNER",
298 [TK_A_GROUP] = "A GROUP",
299 [TK_A_MODE] = "A MODE",
300 [TK_A_OWNER_ID] = "A OWNER_ID",
301 [TK_A_GROUP_ID] = "A GROUP_ID",
302 [TK_A_STATIC_NODE] = "A STATIC_NODE",
912541b0 303 [TK_A_MODE_ID] = "A MODE_ID",
a1525d17
KS		 304 [TK_A_ENV] = "A ENV",
305 [TK_A_TAG] = "A ENV",
306 [TK_A_NAME] = "A NAME",
912541b0 307 [TK_A_DEVLINK] = "A DEVLINK",
a1525d17 308 [TK_A_ATTR] = "A ATTR",
83cd6b75
KS		 309 [TK_A_RUN_BUILTIN] = "A RUN_BUILTIN",
310 [TK_A_RUN_PROGRAM] = "A RUN_PROGRAM",
a1525d17 311 [TK_A_GOTO] = "A GOTO",
912541b0 312
a1525d17 313 [TK_END] = "END",
912541b0
KS		 314 };
315
316 return token_strs[type];
5d6a1fa6 317}
c7521974 318
4052400f
KS		 319static void dump_token(struct udev_rules *rules, struct token *token)
320{
912541b0
KS		 321 enum token_type type = token->type;
322 enum operation_type op = token->key.op;
323 enum string_glob_type glob = token->key.glob;
324 const char *value = &rules->buf[token->key.value_off];
325 const char *attr = &rules->buf[token->key.attr_off];
326
327 switch (type) {
328 case TK_RULE:
329 {
330 const char *tks_ptr = (char *)rules->tokens;
331 const char *tk_ptr = (char *)token;
332 unsigned int idx = (tk_ptr - tks_ptr) / sizeof(struct token);
333
baa30fbc
KS		 334 log_debug("* RULE %s:%u, token: %u, count: %u, label: '%s'\n",
335 &rules->buf[token->rule.filename_off], token->rule.filename_line,
336 idx, token->rule.token_count,
337 &rules->buf[token->rule.label_off]);
912541b0
KS		 338 break;
339 }
340 case TK_M_ACTION:
341 case TK_M_DEVPATH:
342 case TK_M_KERNEL:
343 case TK_M_SUBSYSTEM:
344 case TK_M_DRIVER:
345 case TK_M_WAITFOR:
346 case TK_M_DEVLINK:
347 case TK_M_NAME:
348 case TK_M_KERNELS:
349 case TK_M_SUBSYSTEMS:
350 case TK_M_DRIVERS:
351 case TK_M_TAGS:
352 case TK_M_PROGRAM:
353 case TK_M_IMPORT_FILE:
354 case TK_M_IMPORT_PROG:
355 case TK_M_IMPORT_DB:
356 case TK_M_IMPORT_CMDLINE:
357 case TK_M_IMPORT_PARENT:
358 case TK_M_RESULT:
359 case TK_A_NAME:
360 case TK_A_DEVLINK:
361 case TK_A_OWNER:
362 case TK_A_GROUP:
363 case TK_A_MODE:
83cd6b75
KS		 364 case TK_A_RUN_BUILTIN:
365 case TK_A_RUN_PROGRAM:
baa30fbc
KS		 366 log_debug("%s %s '%s'(%s)\n",
367 token_str(type), operation_str(op), value, string_glob_str(glob));
912541b0
KS		 368 break;
369 case TK_M_IMPORT_BUILTIN:
baa30fbc 370 log_debug("%s %i '%s'\n", token_str(type), token->key.builtin_cmd, value);
912541b0
KS		 371 break;
372 case TK_M_ATTR:
373 case TK_M_ATTRS:
374 case TK_M_ENV:
375 case TK_A_ATTR:
376 case TK_A_ENV:
baa30fbc
KS		 377 log_debug("%s %s '%s' '%s'(%s)\n",
378 token_str(type), operation_str(op), attr, value, string_glob_str(glob));
912541b0
KS		 379 break;
380 case TK_M_TAG:
381 case TK_A_TAG:
baa30fbc 382 log_debug("%s %s '%s'\n", token_str(type), operation_str(op), value);
912541b0
KS		 383 break;
384 case TK_A_STRING_ESCAPE_NONE:
385 case TK_A_STRING_ESCAPE_REPLACE:
386 case TK_A_DB_PERSIST:
baa30fbc 387 log_debug("%s\n", token_str(type));
912541b0
KS		 388 break;
389 case TK_M_TEST:
baa30fbc
KS		 390 log_debug("%s %s '%s'(%s) %#o\n",
391 token_str(type), operation_str(op), value, string_glob_str(glob), token->key.mode);
912541b0
KS		 392 break;
393 case TK_A_INOTIFY_WATCH:
baa30fbc 394 log_debug("%s %u\n", token_str(type), token->key.watch);
912541b0
KS		 395 break;
396 case TK_A_DEVLINK_PRIO:
baa30fbc 397 log_debug("%s %u\n", token_str(type), token->key.devlink_prio);
912541b0
KS		 398 break;
399 case TK_A_OWNER_ID:
baa30fbc 400 log_debug("%s %s %u\n", token_str(type), operation_str(op), token->key.uid);
912541b0
KS		 401 break;
402 case TK_A_GROUP_ID:
baa30fbc 403 log_debug("%s %s %u\n", token_str(type), operation_str(op), token->key.gid);
912541b0
KS		 404 break;
405 case TK_A_MODE_ID:
baa30fbc 406 log_debug("%s %s %#o\n", token_str(type), operation_str(op), token->key.mode);
912541b0
KS		 407 break;
408 case TK_A_STATIC_NODE:
baa30fbc 409 log_debug("%s '%s'\n", token_str(type), value);
912541b0
KS		 410 break;
411 case TK_M_EVENT_TIMEOUT:
baa30fbc 412 log_debug("%s %u\n", token_str(type), token->key.event_timeout);
912541b0
KS		 413 break;
414 case TK_A_GOTO:
baa30fbc 415 log_debug("%s '%s' %u\n", token_str(type), value, token->key.rule_goto);
912541b0
KS		 416 break;
417 case TK_END:
baa30fbc 418 log_debug("* %s\n", token_str(type));
912541b0
KS		 419 break;
420 case TK_M_PARENTS_MIN:
421 case TK_M_PARENTS_MAX:
422 case TK_M_MAX:
423 case TK_UNSET:
baa30fbc 424 log_debug("unknown type %u\n", type);
912541b0
KS		 425 break;
426 }
4052400f 427}
154a7b84 428
4052400f
KS		 429static void dump_rules(struct udev_rules *rules)
430{
912541b0
KS		 431 unsigned int i;
432
baa30fbc
KS		 433 log_debug("dumping %u (%zu bytes) tokens, %u (%zu bytes) strings\n",
434 rules->token_cur,
435 rules->token_cur * sizeof(struct token),
436 rules->buf_count,
437 rules->buf_cur);
912541b0
KS		 438 for(i = 0; i < rules->token_cur; i++)
439 dump_token(rules, &rules->tokens[i]);
4052400f
KS		 440}
441#else
5d6a1fa6
KS		 442static inline const char *operation_str(enum operation_type type) { return NULL; }
443static inline const char *token_str(enum token_type type) { return NULL; }
4052400f
KS		 444static inline void dump_token(struct udev_rules *rules, struct token *token) {}
445static inline void dump_rules(struct udev_rules *rules) {}
baa30fbc 446#endif /* DEBUG */
c7521974 447
1449a55d 448static int add_new_string(struct udev_rules *rules, const char *str, size_t bytes)
c7521974 449{
912541b0
KS		 450 int off;
451
452 /* grow buffer if needed */
453 if (rules->buf_cur + bytes+1 >= rules->buf_max) {
454 char *buf;
455 unsigned int add;
456
457 /* double the buffer size */
458 add = rules->buf_max;
459 if (add < bytes * 8)
460 add = bytes * 8;
461
462 buf = realloc(rules->buf, rules->buf_max + add);
463 if (buf == NULL)
464 return -1;
912541b0
KS		 465 rules->buf = buf;
466 rules->buf_max += add;
467 }
468 off = rules->buf_cur;
469 memcpy(&rules->buf[rules->buf_cur], str, bytes);
470 rules->buf_cur += bytes;
471 rules->buf_count++;
472 return off;
c7521974
KS		 473}
474
1449a55d 475static int add_string(struct udev_rules *rules, const char *str)
c7521974 476{
912541b0
KS		 477 unsigned int node_idx;
478 struct trie_node *new_node;
479 unsigned int new_node_idx;
480 unsigned char key;
481 unsigned short len;
482 unsigned int depth;
483 unsigned int off;
484 struct trie_node *parent;
485
486 /* walk trie, start from last character of str to find matching tails */
487 len = strlen(str);
488 key = str[len-1];
489 node_idx = 0;
490 for (depth = 0; depth <= len; depth++) {
491 struct trie_node *node;
492 unsigned int child_idx;
493
494 node = &rules->trie_nodes[node_idx];
495 off = node->value_off + node->value_len - len;
496
497 /* match against current node */
498 if (depth == len || (node->value_len >= len && memcmp(&rules->buf[off], str, len) == 0))
499 return off;
500
501 /* lookup child node */
502 key = str[len - 1 - depth];
503 child_idx = node->child_idx;
504 while (child_idx > 0) {
505 struct trie_node *child;
506
507 child = &rules->trie_nodes[child_idx];
508 if (child->key == key)
509 break;
510 child_idx = child->next_child_idx;
511 }
512 if (child_idx == 0)
513 break;
514 node_idx = child_idx;
515 }
516
517 /* string not found, add it */
518 off = add_new_string(rules, str, len + 1);
519
520 /* grow trie nodes if needed */
521 if (rules->trie_nodes_cur >= rules->trie_nodes_max) {
522 struct trie_node *nodes;
523 unsigned int add;
524
525 /* double the buffer size */
526 add = rules->trie_nodes_max;
527 if (add < 8)
528 add = 8;
529
530 nodes = realloc(rules->trie_nodes, (rules->trie_nodes_max + add) * sizeof(struct trie_node));
531 if (nodes == NULL)
532 return -1;
912541b0
KS		 533 rules->trie_nodes = nodes;
534 rules->trie_nodes_max += add;
535 }
536
537 /* get a new node */
538 new_node_idx = rules->trie_nodes_cur;
539 rules->trie_nodes_cur++;
540 new_node = &rules->trie_nodes[new_node_idx];
541 memset(new_node, 0x00, sizeof(struct trie_node));
542 new_node->value_off = off;
543 new_node->value_len = len;
544 new_node->key = key;
545
546 /* join the parent's child list */
547 parent = &rules->trie_nodes[node_idx];
548 if (parent->child_idx == 0) {
549 parent->child_idx = new_node_idx;
550 } else {
551 struct trie_node *last_child;
552
553 last_child = &rules->trie_nodes[parent->last_child_idx];
554 last_child->next_child_idx = new_node_idx;
555 }
556 parent->last_child_idx = new_node_idx;
557 return off;
1449a55d
AJ		 558}
559
560static int add_token(struct udev_rules *rules, struct token *token)
561{
912541b0
KS		 562 /* grow buffer if needed */
563 if (rules->token_cur+1 >= rules->token_max) {
564 struct token *tokens;
565 unsigned int add;
566
567 /* double the buffer size */
568 add = rules->token_max;
569 if (add < 8)
570 add = 8;
571
572 tokens = realloc(rules->tokens, (rules->token_max + add ) * sizeof(struct token));
573 if (tokens == NULL)
574 return -1;
912541b0
KS		 575 rules->tokens = tokens;
576 rules->token_max += add;
577 }
578 memcpy(&rules->tokens[rules->token_cur], token, sizeof(struct token));
579 rules->token_cur++;
580 return 0;
c7521974 581}
a27cd06c 582
154a7b84
KS		 583static uid_t add_uid(struct udev_rules *rules, const char *owner)
584{
912541b0
KS		 585 unsigned int i;
586 uid_t uid;
587 unsigned int off;
588
589 /* lookup, if we know it already */
590 for (i = 0; i < rules->uids_cur; i++) {
591 off = rules->uids[i].name_off;
592 if (strcmp(&rules->buf[off], owner) == 0) {
593 uid = rules->uids[i].uid;
912541b0
KS		 594 return uid;
595 }
596 }
597 uid = util_lookup_user(rules->udev, owner);
598
599 /* grow buffer if needed */
600 if (rules->uids_cur+1 >= rules->uids_max) {
601 struct uid_gid *uids;
602 unsigned int add;
603
604 /* double the buffer size */
605 add = rules->uids_max;
606 if (add < 1)
607 add = 8;
608
609 uids = realloc(rules->uids, (rules->uids_max + add ) * sizeof(struct uid_gid));
610 if (uids == NULL)
611 return uid;
912541b0
KS		 612 rules->uids = uids;
613 rules->uids_max += add;
614 }
615 rules->uids[rules->uids_cur].uid = uid;
616 off = add_string(rules, owner);
617 if (off <= 0)
618 return uid;
619 rules->uids[rules->uids_cur].name_off = off;
620 rules->uids_cur++;
621 return uid;
154a7b84
KS		 622}
623
624static gid_t add_gid(struct udev_rules *rules, const char *group)
625{
912541b0
KS		 626 unsigned int i;
627 gid_t gid;
628 unsigned int off;
629
630 /* lookup, if we know it already */
631 for (i = 0; i < rules->gids_cur; i++) {
632 off = rules->gids[i].name_off;
633 if (strcmp(&rules->buf[off], group) == 0) {
634 gid = rules->gids[i].gid;
912541b0
KS		 635 return gid;
636 }
637 }
638 gid = util_lookup_group(rules->udev, group);
639
640 /* grow buffer if needed */
641 if (rules->gids_cur+1 >= rules->gids_max) {
642 struct uid_gid *gids;
643 unsigned int add;
644
645 /* double the buffer size */
646 add = rules->gids_max;
647 if (add < 1)
648 add = 8;
649
650 gids = realloc(rules->gids, (rules->gids_max + add ) * sizeof(struct uid_gid));
651 if (gids == NULL)
652 return gid;
912541b0
KS		 653 rules->gids = gids;
654 rules->gids_max += add;
655 }
656 rules->gids[rules->gids_cur].gid = gid;
657 off = add_string(rules, group);
658 if (off <= 0)
659 return gid;
660 rules->gids[rules->gids_cur].name_off = off;
661 rules->gids_cur++;
662 return gid;
154a7b84
KS		 663}
664
bb144ed1 665static int import_property_from_string(struct udev_device *dev, char *line)
bd0ed2ff 666{
912541b0
KS		 667 struct udev *udev = udev_device_get_udev(dev);
668 char *key;
669 char *val;
670 size_t len;
671
672 /* find key */
673 key = line;
674 while (isspace(key[0]))
675 key++;
676
677 /* comment or empty line */
678 if (key[0] == '#' || key[0] == '\0')
679 return -1;
680
681 /* split key/value */
682 val = strchr(key, '=');
683 if (val == NULL)
684 return -1;
685 val[0] = '\0';
686 val++;
687
688 /* find value */
689 while (isspace(val[0]))
690 val++;
691
692 /* terminate key */
693 len = strlen(key);
694 if (len == 0)
695 return -1;
696 while (isspace(key[len-1]))
697 len--;
698 key[len] = '\0';
699
700 /* terminate value */
701 len = strlen(val);
702 if (len == 0)
703 return -1;
704 while (isspace(val[len-1]))
705 len--;
706 val[len] = '\0';
707
708 if (len == 0)
709 return -1;
710
711 /* unquote */
712 if (val[0] == '"' || val[0] == '\'') {
713 if (val[len-1] != val[0]) {
baa30fbc 714 log_debug("inconsistent quoting: '%s', skip\n", line);
912541b0
KS		 715 return -1;
716 }
717 val[len-1] = '\0';
718 val++;
719 }
720
912541b0
KS		 721 /* handle device, renamed by external tool, returning new path */
722 if (strcmp(key, "DEVPATH") == 0) {
723 char syspath[UTIL_PATH_SIZE];
724
baa30fbc
KS		 725 log_debug("updating devpath from '%s' to '%s'\n",
726 udev_device_get_devpath(dev), val);
912541b0
KS		 727 util_strscpyl(syspath, sizeof(syspath), udev_get_sys_path(udev), val, NULL);
728 udev_device_set_syspath(dev, syspath);
729 } else {
730 struct udev_list_entry *entry;
731
732 entry = udev_device_add_property(dev, key, val);
733 /* store in db, skip private keys */
734 if (key[0] != '.')
735 udev_list_entry_set_num(entry, true);
736 }
737 return 0;
be4bedd1
KS		 738}
739
6880b25d 740static int import_file_into_properties(struct udev_device *dev, const char *filename)
be4bedd1 741{
912541b0
KS		 742 FILE *f;
743 char line[UTIL_LINE_SIZE];
744
745 f = fopen(filename, "r");
746 if (f == NULL)
747 return -1;
748 while (fgets(line, sizeof(line), f) != NULL)
749 import_property_from_string(dev, line);
750 fclose(f);
751 return 0;
bd0ed2ff
KS		 752}
753
2181d30a 754static int import_program_into_properties(struct udev_event *event, const char *program, const sigset_t *sigmask)
319c6700 755{
912541b0
KS		 756 struct udev_device *dev = event->dev;
757 char **envp;
758 char result[UTIL_LINE_SIZE];
759 char *line;
760 int err;
761
762 envp = udev_device_get_properties_envp(dev);
763 err = udev_event_spawn(event, program, envp, sigmask, result, sizeof(result));
764 if (err < 0)
765 return err;
766
767 line = result;
768 while (line != NULL) {
769 char *pos;
770
771 pos = strchr(line, '\n');
772 if (pos != NULL) {
773 pos[0] = '\0';
774 pos = &pos[1];
775 }
776 import_property_from_string(dev, line);
777 line = pos;
778 }
779 return 0;
319c6700
KS		 780}
781
6880b25d 782static int import_parent_into_properties(struct udev_device *dev, const char *filter)
0bfb84e1 783{
912541b0
KS		 784 struct udev *udev = udev_device_get_udev(dev);
785 struct udev_device *dev_parent;
786 struct udev_list_entry *list_entry;
787
788 dev_parent = udev_device_get_parent(dev);
789 if (dev_parent == NULL)
790 return -1;
791
912541b0
KS		 792 udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(dev_parent)) {
793 const char *key = udev_list_entry_get_name(list_entry);
794 const char *val = udev_list_entry_get_value(list_entry);
795
796 if (fnmatch(filter, key, 0) == 0) {
797 struct udev_list_entry *entry;
798
912541b0
KS		 799 entry = udev_device_add_property(dev, key, val);
800 /* store in db, skip private keys */
801 if (key[0] != '.')
802 udev_list_entry_set_num(entry, true);
803 }
804 }
805 return 0;
e2ecb34f
KS		 806}
807
912541b0 808#define WAIT_LOOP_PER_SECOND 50
6880b25d 809static int wait_for_file(struct udev_device *dev, const char *file, int timeout)
b2fe4b9a 810{
912541b0
KS		 811 struct udev *udev = udev_device_get_udev(dev);
812 char filepath[UTIL_PATH_SIZE];
813 char devicepath[UTIL_PATH_SIZE];
814 struct stat stats;
815 int loop = timeout * WAIT_LOOP_PER_SECOND;
816
817 /* a relative path is a device attribute */
818 devicepath[0] = '\0';
819 if (file[0] != '/') {
820 util_strscpyl(devicepath, sizeof(devicepath),
821 udev_get_sys_path(udev), udev_device_get_devpath(dev), NULL);
822 util_strscpyl(filepath, sizeof(filepath), devicepath, "/", file, NULL);
823 file = filepath;
824 }
825
912541b0
KS		 826 while (--loop) {
827 const struct timespec duration = { 0, 1000 * 1000 * 1000 / WAIT_LOOP_PER_SECOND };
828
829 /* lookup file */
830 if (stat(file, &stats) == 0) {
baa30fbc 831 log_debug("file '%s' appeared after %i loops\n", file, (timeout * WAIT_LOOP_PER_SECOND) - loop-1);
912541b0
KS		 832 return 0;
833 }
834 /* make sure, the device did not disappear in the meantime */
835 if (devicepath[0] != '\0' && stat(devicepath, &stats) != 0) {
baa30fbc 836 log_debug("device disappeared while waiting for '%s'\n", file);
912541b0
KS		 837 return -2;
838 }
baa30fbc 839 log_debug("wait for '%s' for %i mseconds\n", file, 1000 / WAIT_LOOP_PER_SECOND);
912541b0
KS		 840 nanosleep(&duration, NULL);
841 }
baa30fbc 842 log_debug("waiting for '%s' failed\n", file);
912541b0 843 return -1;
b2fe4b9a
KS		 844}
845
0ea5e96e
KS		 846static int attr_subst_subdir(char *attr, size_t len)
847{
912541b0
KS		 848 bool found = false;
849
850 if (strstr(attr, "/*/")) {
851 char *pos;
852 char dirname[UTIL_PATH_SIZE];
853 const char *tail;
854 DIR *dir;
855
856 util_strscpy(dirname, sizeof(dirname), attr);
857 pos = strstr(dirname, "/*/");
858 if (pos == NULL)
859 return -1;
860 pos[0] = '\0';
861 tail = &pos[2];
862 dir = opendir(dirname);
863 if (dir != NULL) {
864 struct dirent *dent;
865
866 for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
867 struct stat stats;
868
869 if (dent->d_name[0] == '.')
870 continue;
871 util_strscpyl(attr, len, dirname, "/", dent->d_name, tail, NULL);
872 if (stat(attr, &stats) == 0) {
873 found = true;
874 break;
875 }
876 }
877 closedir(dir);
878 }
879 }
880
881 return found;
0ea5e96e
KS		 882}
883
b0f7409f 884static int get_key(struct udev *udev, char **line, char **key, enum operation_type *op, char **value)
a0e5382d 885{
912541b0
KS		 886 char *linepos;
887 char *temp;
888
889 linepos = *line;
890 if (linepos == NULL || linepos[0] == '\0')
891 return -1;
892
893 /* skip whitespace */
894 while (isspace(linepos[0]) || linepos[0] == ',')
895 linepos++;
896
897 /* get the key */
898 if (linepos[0] == '\0')
899 return -1;
900 *key = linepos;
901
902 for (;;) {
903 linepos++;
904 if (linepos[0] == '\0')
905 return -1;
906 if (isspace(linepos[0]))
907 break;
908 if (linepos[0] == '=')
909 break;
910 if ((linepos[0] == '+') || (linepos[0] == '!') || (linepos[0] == ':'))
911 if (linepos[1] == '=')
912 break;
913 }
914
915 /* remember end of key */
916 temp = linepos;
917
918 /* skip whitespace after key */
919 while (isspace(linepos[0]))
920 linepos++;
921 if (linepos[0] == '\0')
922 return -1;
923
924 /* get operation type */
925 if (linepos[0] == '=' && linepos[1] == '=') {
926 *op = OP_MATCH;
927 linepos += 2;
928 } else if (linepos[0] == '!' && linepos[1] == '=') {
929 *op = OP_NOMATCH;
930 linepos += 2;
931 } else if (linepos[0] == '+' && linepos[1] == '=') {
932 *op = OP_ADD;
933 linepos += 2;
934 } else if (linepos[0] == '=') {
935 *op = OP_ASSIGN;
936 linepos++;
937 } else if (linepos[0] == ':' && linepos[1] == '=') {
938 *op = OP_ASSIGN_FINAL;
939 linepos += 2;
940 } else
941 return -1;
942
943 /* terminate key */
944 temp[0] = '\0';
945
946 /* skip whitespace after operator */
947 while (isspace(linepos[0]))
948 linepos++;
949 if (linepos[0] == '\0')
950 return -1;
951
952 /* get the value */
953 if (linepos[0] == '"')
954 linepos++;
955 else
956 return -1;
957 *value = linepos;
958
959 /* terminate */
960 temp = strchr(linepos, '"');
961 if (!temp)
962 return -1;
963 temp[0] = '\0';
964 temp++;
912541b0
KS		 965
966 /* move line to next key */
967 *line = temp;
968 return 0;
6880b25d 969}
95776dc6 970
6880b25d
KS		 971/* extract possible KEY{attr} */
972static char *get_key_attribute(struct udev *udev, char *str)
973{
912541b0
KS		 974 char *pos;
975 char *attr;
976
977 attr = strchr(str, '{');
978 if (attr != NULL) {
979 attr++;
980 pos = strchr(attr, '}');
981 if (pos == NULL) {
baa30fbc 982 log_error("missing closing brace for format\n");
912541b0
KS		 983 return NULL;
984 }
985 pos[0] = '\0';
912541b0
KS		 986 return attr;
987 }
988 return NULL;
6880b25d 989}
95776dc6 990
0ef254d5 991static int rule_add_key(struct rule_tmp *rule_tmp, enum token_type type,
912541b0
KS		 992 enum operation_type op,
993 const char *value, const void *data)
6880b25d 994{
912541b0
KS		 995 struct token *token = &rule_tmp->token[rule_tmp->token_cur];
996 const char *attr = NULL;
997
998 memset(token, 0x00, sizeof(struct token));
999
1000 switch (type) {
1001 case TK_M_ACTION:
1002 case TK_M_DEVPATH:
1003 case TK_M_KERNEL:
1004 case TK_M_SUBSYSTEM:
1005 case TK_M_DRIVER:
1006 case TK_M_WAITFOR:
1007 case TK_M_DEVLINK:
1008 case TK_M_NAME:
1009 case TK_M_KERNELS:
1010 case TK_M_SUBSYSTEMS:
1011 case TK_M_DRIVERS:
1012 case TK_M_TAGS:
1013 case TK_M_PROGRAM:
1014 case TK_M_IMPORT_FILE:
1015 case TK_M_IMPORT_PROG:
1016 case TK_M_IMPORT_DB:
1017 case TK_M_IMPORT_CMDLINE:
1018 case TK_M_IMPORT_PARENT:
1019 case TK_M_RESULT:
1020 case TK_A_OWNER:
1021 case TK_A_GROUP:
1022 case TK_A_MODE:
1023 case TK_A_NAME:
1024 case TK_A_GOTO:
1025 case TK_M_TAG:
1026 case TK_A_TAG:
1027 token->key.value_off = add_string(rule_tmp->rules, value);
1028 break;
1029 case TK_M_IMPORT_BUILTIN:
1030 token->key.value_off = add_string(rule_tmp->rules, value);
1031 token->key.builtin_cmd = *(enum udev_builtin_cmd *)data;
1032 break;
1033 case TK_M_ENV:
1034 case TK_M_ATTR:
1035 case TK_M_ATTRS:
1036 case TK_A_ATTR:
1037 case TK_A_ENV:
1038 attr = data;
1039 token->key.value_off = add_string(rule_tmp->rules, value);
1040 token->key.attr_off = add_string(rule_tmp->rules, attr);
1041 break;
1042 case TK_A_DEVLINK:
1043 token->key.value_off = add_string(rule_tmp->rules, value);
1044 token->key.devlink_unique = *(int *)data;
1045 break;
1046 case TK_M_TEST:
1047 token->key.value_off = add_string(rule_tmp->rules, value);
1048 if (data != NULL)
1049 token->key.mode = *(mode_t *)data;
1050 break;
1051 case TK_A_STRING_ESCAPE_NONE:
1052 case TK_A_STRING_ESCAPE_REPLACE:
1053 case TK_A_DB_PERSIST:
1054 break;
83cd6b75
KS		 1055 case TK_A_RUN_BUILTIN:
1056 token->key.builtin_cmd = *(enum udev_builtin_cmd *)data;
1057 case TK_A_RUN_PROGRAM:
912541b0
KS		 1058 token->key.value_off = add_string(rule_tmp->rules, value);
1059 break;
1060 case TK_A_INOTIFY_WATCH:
1061 case TK_A_DEVLINK_PRIO:
1062 token->key.devlink_prio = *(int *)data;
1063 break;
1064 case TK_A_OWNER_ID:
1065 token->key.uid = *(uid_t *)data;
1066 break;
1067 case TK_A_GROUP_ID:
1068 token->key.gid = *(gid_t *)data;
1069 break;
1070 case TK_A_MODE_ID:
1071 token->key.mode = *(mode_t *)data;
1072 break;
1073 case TK_A_STATIC_NODE:
1074 token->key.value_off = add_string(rule_tmp->rules, value);
1075 break;
1076 case TK_M_EVENT_TIMEOUT:
1077 token->key.event_timeout = *(int *)data;
1078 break;
1079 case TK_RULE:
1080 case TK_M_PARENTS_MIN:
1081 case TK_M_PARENTS_MAX:
1082 case TK_M_MAX:
1083 case TK_END:
1084 case TK_UNSET:
baa30fbc 1085 log_error("wrong type %u\n", type);
912541b0
KS		 1086 return -1;
1087 }
1088
1089 if (value != NULL && type < TK_M_MAX) {
1090 /* check if we need to split or call fnmatch() while matching rules */
1091 enum string_glob_type glob;
1092 int has_split;
1093 int has_glob;
1094
1095 has_split = (strchr(value, '|') != NULL);
1096 has_glob = (strchr(value, '*') != NULL || strchr(value, '?') != NULL || strchr(value, '[') != NULL);
1097 if (has_split && has_glob) {
1098 glob = GL_SPLIT_GLOB;
1099 } else if (has_split) {
1100 glob = GL_SPLIT;
1101 } else if (has_glob) {
1102 if (strcmp(value, "?*") == 0)
1103 glob = GL_SOMETHING;
1104 else
1105 glob = GL_GLOB;
1106 } else {
1107 glob = GL_PLAIN;
1108 }
1109 token->key.glob = glob;
1110 }
1111
1112 if (value != NULL && type > TK_M_MAX) {
1113 /* check if assigned value has substitution chars */
1114 if (value[0] == '[')
1115 token->key.subst = SB_SUBSYS;
1116 else if (strchr(value, '%') != NULL || strchr(value, '$') != NULL)
1117 token->key.subst = SB_FORMAT;
1118 else
1119 token->key.subst = SB_NONE;
1120 }
1121
1122 if (attr != NULL) {
1123 /* check if property/attribut name has substitution chars */
1124 if (attr[0] == '[')
1125 token->key.attrsubst = SB_SUBSYS;
1126 else if (strchr(attr, '%') != NULL || strchr(attr, '$') != NULL)
1127 token->key.attrsubst = SB_FORMAT;
1128 else
1129 token->key.attrsubst = SB_NONE;
1130 }
1131
1132 token->key.type = type;
1133 token->key.op = op;
1134 rule_tmp->token_cur++;
1135 if (rule_tmp->token_cur >= ARRAY_SIZE(rule_tmp->token)) {
baa30fbc 1136 log_error("temporary rule array too small\n");
912541b0
KS		 1137 return -1;
1138 }
1139 return 0;
6880b25d 1140}
e57e7bc1 1141
6880b25d
KS		 1142static int sort_token(struct udev_rules *rules, struct rule_tmp *rule_tmp)
1143{
912541b0
KS		 1144 unsigned int i;
1145 unsigned int start = 0;
1146 unsigned int end = rule_tmp->token_cur;
1147
1148 for (i = 0; i < rule_tmp->token_cur; i++) {
1149 enum token_type next_val = TK_UNSET;
1150 unsigned int next_idx = 0;
1151 unsigned int j;
1152
1153 /* find smallest value */
1154 for (j = start; j < end; j++) {
1155 if (rule_tmp->token[j].type == TK_UNSET)
1156 continue;
1157 if (next_val == TK_UNSET || rule_tmp->token[j].type < next_val) {
1158 next_val = rule_tmp->token[j].type;
1159 next_idx = j;
1160 }
1161 }
1162
1163 /* add token and mark done */
1164 if (add_token(rules, &rule_tmp->token[next_idx]) != 0)
1165 return -1;
1166 rule_tmp->token[next_idx].type = TK_UNSET;
1167
1168 /* shrink range */
1169 if (next_idx == start)
1170 start++;
1171 if (next_idx+1 == end)
1172 end--;
1173 }
1174 return 0;
724257d9
GKH		 1175}
1176
6880b25d 1177static int add_rule(struct udev_rules *rules, char *line,
912541b0 1178 const char *filename, unsigned int filename_off, unsigned int lineno)
724257d9 1179{
912541b0
KS		 1180 char *linepos;
1181 char *attr;
1182 struct rule_tmp rule_tmp;
1183
1184 memset(&rule_tmp, 0x00, sizeof(struct rule_tmp));
1185 rule_tmp.rules = rules;
1186 rule_tmp.rule.type = TK_RULE;
1187 rule_tmp.rule.rule.filename_off = filename_off;
1188 rule_tmp.rule.rule.filename_line = lineno;
1189
1190 linepos = line;
1191 for (;;) {
1192 char *key;
1193 char *value;
1194 enum operation_type op;
1195
1196 if (get_key(rules->udev, &linepos, &key, &op, &value) != 0)
1197 break;
1198
1199 if (strcmp(key, "ACTION") == 0) {
1200 if (op > OP_MATCH_MAX) {
baa30fbc 1201 log_error("invalid ACTION operation\n");
912541b0
KS		 1202 goto invalid;
1203 }
1204 rule_add_key(&rule_tmp, TK_M_ACTION, op, value, NULL);
1205 continue;
1206 }
1207
1208 if (strcmp(key, "DEVPATH") == 0) {
1209 if (op > OP_MATCH_MAX) {
baa30fbc 1210 log_error("invalid DEVPATH operation\n");
912541b0
KS		 1211 goto invalid;
1212 }
1213 rule_add_key(&rule_tmp, TK_M_DEVPATH, op, value, NULL);
1214 continue;
1215 }
1216
1217 if (strcmp(key, "KERNEL") == 0) {
1218 if (op > OP_MATCH_MAX) {
baa30fbc 1219 log_error("invalid KERNEL operation\n");
912541b0
KS		 1220 goto invalid;
1221 }
1222 rule_add_key(&rule_tmp, TK_M_KERNEL, op, value, NULL);
1223 continue;
1224 }
1225
1226 if (strcmp(key, "SUBSYSTEM") == 0) {
1227 if (op > OP_MATCH_MAX) {
baa30fbc 1228 log_error("invalid SUBSYSTEM operation\n");
912541b0
KS		 1229 goto invalid;
1230 }
1231 /* bus, class, subsystem events should all be the same */
1232 if (strcmp(value, "subsystem") == 0 ||
1233 strcmp(value, "bus") == 0 ||
1234 strcmp(value, "class") == 0) {
1235 if (strcmp(value, "bus") == 0 || strcmp(value, "class") == 0)
baa30fbc 1236 log_error("'%s' must be specified as 'subsystem' \n"
912541b0
KS		 1237 "please fix it in %s:%u", value, filename, lineno);
1238 rule_add_key(&rule_tmp, TK_M_SUBSYSTEM, op, "subsystem|class|bus", NULL);
1239 } else
1240 rule_add_key(&rule_tmp, TK_M_SUBSYSTEM, op, value, NULL);
1241 continue;
1242 }
1243
1244 if (strcmp(key, "DRIVER") == 0) {
1245 if (op > OP_MATCH_MAX) {
baa30fbc 1246 log_error("invalid DRIVER operation\n");
912541b0
KS		 1247 goto invalid;
1248 }
1249 rule_add_key(&rule_tmp, TK_M_DRIVER, op, value, NULL);
1250 continue;
1251 }
1252
1253 if (strncmp(key, "ATTR{", sizeof("ATTR{")-1) == 0) {
1254 attr = get_key_attribute(rules->udev, key + sizeof("ATTR")-1);
1255 if (attr == NULL) {
baa30fbc 1256 log_error("error parsing ATTR attribute\n");
912541b0
KS		 1257 goto invalid;
1258 }
1259 if (op < OP_MATCH_MAX) {
1260 rule_add_key(&rule_tmp, TK_M_ATTR, op, value, attr);
1261 } else {
1262 rule_add_key(&rule_tmp, TK_A_ATTR, op, value, attr);
1263 }
1264 continue;
1265 }
1266
1267 if (strcmp(key, "KERNELS") == 0) {
1268 if (op > OP_MATCH_MAX) {
baa30fbc 1269 log_error("invalid KERNELS operation\n");
912541b0
KS		 1270 goto invalid;
1271 }
1272 rule_add_key(&rule_tmp, TK_M_KERNELS, op, value, NULL);
1273 continue;
1274 }
1275
1276 if (strcmp(key, "SUBSYSTEMS") == 0) {
1277 if (op > OP_MATCH_MAX) {
baa30fbc 1278 log_error("invalid SUBSYSTEMS operation\n");
912541b0
KS		 1279 goto invalid;
1280 }
1281 rule_add_key(&rule_tmp, TK_M_SUBSYSTEMS, op, value, NULL);
1282 continue;
1283 }
1284
1285 if (strcmp(key, "DRIVERS") == 0) {
1286 if (op > OP_MATCH_MAX) {
baa30fbc 1287 log_error("invalid DRIVERS operation\n");
912541b0
KS		 1288 goto invalid;
1289 }
1290 rule_add_key(&rule_tmp, TK_M_DRIVERS, op, value, NULL);
1291 continue;
1292 }
1293
1294 if (strncmp(key, "ATTRS{", sizeof("ATTRS{")-1) == 0) {
1295 if (op > OP_MATCH_MAX) {
baa30fbc 1296 log_error("invalid ATTRS operation\n");
912541b0
KS		 1297 goto invalid;
1298 }
1299 attr = get_key_attribute(rules->udev, key + sizeof("ATTRS")-1);
1300 if (attr == NULL) {
baa30fbc 1301 log_error("error parsing ATTRS attribute\n");
912541b0
KS		 1302 goto invalid;
1303 }
1304 if (strncmp(attr, "device/", 7) == 0)
baa30fbc 1305 log_error("the 'device' link may not be available in a future kernel, "
912541b0
KS		 1306 "please fix it in %s:%u", filename, lineno);
1307 else if (strstr(attr, "../") != NULL)
baa30fbc 1308 log_error("do not reference parent sysfs directories directly, "
912541b0
KS		 1309 "it may break with a future kernel, please fix it in %s:%u", filename, lineno);
1310 rule_add_key(&rule_tmp, TK_M_ATTRS, op, value, attr);
1311 continue;
1312 }
1313
1314 if (strcmp(key, "TAGS") == 0) {
1315 if (op > OP_MATCH_MAX) {
baa30fbc 1316 log_error("invalid TAGS operation\n");
912541b0
KS		 1317 goto invalid;
1318 }
1319 rule_add_key(&rule_tmp, TK_M_TAGS, op, value, NULL);
1320 continue;
1321 }
1322
1323 if (strncmp(key, "ENV{", sizeof("ENV{")-1) == 0) {
1324 attr = get_key_attribute(rules->udev, key + sizeof("ENV")-1);
1325 if (attr == NULL) {
baa30fbc 1326 log_error("error parsing ENV attribute\n");
912541b0
KS		 1327 goto invalid;
1328 }
1329 if (op < OP_MATCH_MAX) {
1330 if (rule_add_key(&rule_tmp, TK_M_ENV, op, value, attr) != 0)
1331 goto invalid;
1332 } else {
1333 static const char *blacklist[] = {
1334 "ACTION",
1335 "SUBSYSTEM",
1336 "DEVTYPE",
1337 "MAJOR",
1338 "MINOR",
1339 "DRIVER",
1340 "IFINDEX",
1341 "DEVNAME",
1342 "DEVLINKS",
1343 "DEVPATH",
1344 "TAGS",
1345 };
1346 unsigned int i;
1347
1348 for (i = 0; i < ARRAY_SIZE(blacklist); i++)
1349 if (strcmp(attr, blacklist[i]) == 0) {
baa30fbc 1350 log_error("invalid ENV attribute, '%s' can not be set %s:%u\n", attr, filename, lineno);
912541b0
KS		 1351 continue;
1352 }
1353 if (rule_add_key(&rule_tmp, TK_A_ENV, op, value, attr) != 0)
1354 goto invalid;
1355 }
1356 continue;
1357 }
1358
1359 if (strcmp(key, "TAG") == 0) {
1360 if (op < OP_MATCH_MAX)
1361 rule_add_key(&rule_tmp, TK_M_TAG, op, value, NULL);
1362 else
1363 rule_add_key(&rule_tmp, TK_A_TAG, op, value, NULL);
1364 continue;
1365 }
1366
1367 if (strcmp(key, "PROGRAM") == 0) {
1368 rule_add_key(&rule_tmp, TK_M_PROGRAM, op, value, NULL);
1369 continue;
1370 }
1371
1372 if (strcmp(key, "RESULT") == 0) {
1373 if (op > OP_MATCH_MAX) {
baa30fbc 1374 log_error("invalid RESULT operation\n");
912541b0
KS		 1375 goto invalid;
1376 }
1377 rule_add_key(&rule_tmp, TK_M_RESULT, op, value, NULL);
1378 continue;
1379 }
1380
1381 if (strncmp(key, "IMPORT", sizeof("IMPORT")-1) == 0) {
1382 attr = get_key_attribute(rules->udev, key + sizeof("IMPORT")-1);
1383 if (attr == NULL) {
baa30fbc 1384 log_error("IMPORT{} type missing, ignoring IMPORT %s:%u\n", filename, lineno);
912541b0
KS		 1385 continue;
1386 }
83cd6b75 1387 if (strcmp(attr, "program") == 0) {
912541b0
KS		 1388 /* find known built-in command */
1389 if (value[0] != '/') {
1390 enum udev_builtin_cmd cmd;
1391
1392 cmd = udev_builtin_lookup(value);
1393 if (cmd < UDEV_BUILTIN_MAX) {
baa30fbc
KS		 1394 log_debug("IMPORT found builtin '%s', replacing %s:%u\n",
1395 value, filename, lineno);
912541b0
KS		 1396 rule_add_key(&rule_tmp, TK_M_IMPORT_BUILTIN, op, value, &cmd);
1397 continue;
1398 }
1399 }
912541b0 1400 rule_add_key(&rule_tmp, TK_M_IMPORT_PROG, op, value, NULL);
83cd6b75 1401 } else if (strcmp(attr, "builtin") == 0) {
912541b0
KS		 1402 enum udev_builtin_cmd cmd = udev_builtin_lookup(value);
1403
912541b0
KS		 1404 if (cmd < UDEV_BUILTIN_MAX)
1405 rule_add_key(&rule_tmp, TK_M_IMPORT_BUILTIN, op, value, &cmd);
1406 else
baa30fbc 1407 log_error("IMPORT{builtin}: '%s' unknown %s:%u\n", value, filename, lineno);
83cd6b75 1408 } else if (strcmp(attr, "file") == 0) {
912541b0 1409 rule_add_key(&rule_tmp, TK_M_IMPORT_FILE, op, value, NULL);
83cd6b75 1410 } else if (strcmp(attr, "db") == 0) {
912541b0 1411 rule_add_key(&rule_tmp, TK_M_IMPORT_DB, op, value, NULL);
83cd6b75 1412 } else if (strcmp(attr, "cmdline") == 0) {
912541b0 1413 rule_add_key(&rule_tmp, TK_M_IMPORT_CMDLINE, op, value, NULL);
83cd6b75 1414 } else if (strcmp(attr, "parent") == 0) {
912541b0 1415 rule_add_key(&rule_tmp, TK_M_IMPORT_PARENT, op, value, NULL);
83cd6b75
KS		 1416 } else
1417 log_error("IMPORT{} unknown type, ignoring IMPORT %s:%u\n", filename, lineno);
912541b0
KS		 1418 continue;
1419 }
1420
1421 if (strncmp(key, "TEST", sizeof("TEST")-1) == 0) {
1422 mode_t mode = 0;
1423
1424 if (op > OP_MATCH_MAX) {
baa30fbc 1425 log_error("invalid TEST operation\n");
912541b0
KS		 1426 goto invalid;
1427 }
1428 attr = get_key_attribute(rules->udev, key + sizeof("TEST")-1);
1429 if (attr != NULL) {
1430 mode = strtol(attr, NULL, 8);
1431 rule_add_key(&rule_tmp, TK_M_TEST, op, value, &mode);
1432 } else {
1433 rule_add_key(&rule_tmp, TK_M_TEST, op, value, NULL);
1434 }
1435 continue;
1436 }
1437
83cd6b75
KS		 1438 if (strncmp(key, "RUN", sizeof("RUN")-1) == 0) {
1439 attr = get_key_attribute(rules->udev, key + sizeof("RUN")-1);
1440 if (attr == NULL)
1441 attr = "program";
1442
1443 if (strcmp(attr, "builtin") == 0) {
1444 enum udev_builtin_cmd cmd = udev_builtin_lookup(value);
1445
1446 if (cmd < UDEV_BUILTIN_MAX)
1447 rule_add_key(&rule_tmp, TK_A_RUN_BUILTIN, op, value, &cmd);
1448 else
1449 log_error("IMPORT{builtin}: '%s' unknown %s:%u\n", value, filename, lineno);
1450 } else if (strcmp(attr, "program") == 0) {
1451 enum udev_builtin_cmd cmd = UDEV_BUILTIN_MAX;
1452
83cd6b75
KS		 1453 rule_add_key(&rule_tmp, TK_A_RUN_PROGRAM, op, value, &cmd);
1454 } else {
1455 log_error("RUN{} unknown type, ignoring RUN %s:%u\n", filename, lineno);
1456 }
1457
912541b0
KS		 1458 continue;
1459 }
1460
1461 if (strcmp(key, "WAIT_FOR") == 0 || strcmp(key, "WAIT_FOR_SYSFS") == 0) {
1462 rule_add_key(&rule_tmp, TK_M_WAITFOR, 0, value, NULL);
1463 continue;
1464 }
1465
1466 if (strcmp(key, "LABEL") == 0) {
1467 rule_tmp.rule.rule.label_off = add_string(rules, value);
1468 continue;
1469 }
1470
1471 if (strcmp(key, "GOTO") == 0) {
1472 rule_add_key(&rule_tmp, TK_A_GOTO, 0, value, NULL);
1473 continue;
1474 }
1475
1476 if (strncmp(key, "NAME", sizeof("NAME")-1) == 0) {
1477 if (op < OP_MATCH_MAX) {
1478 rule_add_key(&rule_tmp, TK_M_NAME, op, value, NULL);
1479 } else {
1480 if (strcmp(value, "%k") == 0) {
baa30fbc 1481 log_error("NAME=\"%%k\" is ignored, because it breaks kernel supplied names, "
912541b0
KS		 1482 "please remove it from %s:%u\n", filename, lineno);
1483 continue;
1484 }
1485 if (value[0] == '\0') {
baa30fbc
KS		 1486 log_debug("NAME=\"\" is ignored, because udev will not delete any device nodes, "
1487 "please remove it from %s:%u\n", filename, lineno);
912541b0
KS		 1488 continue;
1489 }
1490 rule_add_key(&rule_tmp, TK_A_NAME, op, value, NULL);
1491 }
1492 rule_tmp.rule.rule.can_set_name = true;
1493 continue;
1494 }
1495
1496 if (strncmp(key, "SYMLINK", sizeof("SYMLINK")-1) == 0) {
1497 if (op < OP_MATCH_MAX) {
1498 rule_add_key(&rule_tmp, TK_M_DEVLINK, op, value, NULL);
1499 } else {
1500 int flag = 0;
1501
1502 attr = get_key_attribute(rules->udev, key + sizeof("SYMLINK")-1);
1503 if (attr != NULL && strstr(attr, "unique") != NULL)
1504 flag = 1;
1505 rule_add_key(&rule_tmp, TK_A_DEVLINK, op, value, &flag);
1506 }
1507 rule_tmp.rule.rule.can_set_name = true;
1508 continue;
1509 }
1510
1511 if (strcmp(key, "OWNER") == 0) {
1512 uid_t uid;
1513 char *endptr;
1514
1515 uid = strtoul(value, &endptr, 10);
1516 if (endptr[0] == '\0') {
1517 rule_add_key(&rule_tmp, TK_A_OWNER_ID, op, NULL, &uid);
1518 } else if ((rules->resolve_names > 0) && strchr("$%", value[0]) == NULL) {
1519 uid = add_uid(rules, value);
1520 rule_add_key(&rule_tmp, TK_A_OWNER_ID, op, NULL, &uid);
1521 } else if (rules->resolve_names >= 0) {
1522 rule_add_key(&rule_tmp, TK_A_OWNER, op, value, NULL);
1523 }
1524 rule_tmp.rule.rule.can_set_name = true;
1525 continue;
1526 }
1527
1528 if (strcmp(key, "GROUP") == 0) {
1529 gid_t gid;
1530 char *endptr;
1531
1532 gid = strtoul(value, &endptr, 10);
1533 if (endptr[0] == '\0') {
1534 rule_add_key(&rule_tmp, TK_A_GROUP_ID, op, NULL, &gid);
1535 } else if ((rules->resolve_names > 0) && strchr("$%", value[0]) == NULL) {
1536 gid = add_gid(rules, value);
1537 rule_add_key(&rule_tmp, TK_A_GROUP_ID, op, NULL, &gid);
1538 } else if (rules->resolve_names >= 0) {
1539 rule_add_key(&rule_tmp, TK_A_GROUP, op, value, NULL);
1540 }
1541 rule_tmp.rule.rule.can_set_name = true;
1542 continue;
1543 }
1544
1545 if (strcmp(key, "MODE") == 0) {
1546 mode_t mode;
1547 char *endptr;
1548
1549 mode = strtol(value, &endptr, 8);
1550 if (endptr[0] == '\0')
1551 rule_add_key(&rule_tmp, TK_A_MODE_ID, op, NULL, &mode);
1552 else
1553 rule_add_key(&rule_tmp, TK_A_MODE, op, value, NULL);
1554 rule_tmp.rule.rule.can_set_name = true;
1555 continue;
1556 }
1557
1558 if (strcmp(key, "OPTIONS") == 0) {
1559 const char *pos;
1560
1561 pos = strstr(value, "link_priority=");
1562 if (pos != NULL) {
1563 int prio = atoi(&pos[strlen("link_priority=")]);
1564
1565 rule_add_key(&rule_tmp, TK_A_DEVLINK_PRIO, op, NULL, &prio);
912541b0
KS		 1566 }
1567
1568 pos = strstr(value, "event_timeout=");
1569 if (pos != NULL) {
1570 int tout = atoi(&pos[strlen("event_timeout=")]);
1571
1572 rule_add_key(&rule_tmp, TK_M_EVENT_TIMEOUT, op, NULL, &tout);
912541b0
KS		 1573 }
1574
1575 pos = strstr(value, "string_escape=");
1576 if (pos != NULL) {
1577 pos = &pos[strlen("string_escape=")];
1578 if (strncmp(pos, "none", strlen("none")) == 0)
1579 rule_add_key(&rule_tmp, TK_A_STRING_ESCAPE_NONE, op, NULL, NULL);
1580 else if (strncmp(pos, "replace", strlen("replace")) == 0)
1581 rule_add_key(&rule_tmp, TK_A_STRING_ESCAPE_REPLACE, op, NULL, NULL);
1582 }
1583
1584 pos = strstr(value, "db_persist");
1585 if (pos != NULL)
1586 rule_add_key(&rule_tmp, TK_A_DB_PERSIST, op, NULL, NULL);
1587
1588 pos = strstr(value, "nowatch");
1589 if (pos != NULL) {
1590 const int off = 0;
1591
1592 rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, op, NULL, &off);
912541b0
KS		 1593 } else {
1594 pos = strstr(value, "watch");
1595 if (pos != NULL) {
1596 const int on = 1;
1597
1598 rule_add_key(&rule_tmp, TK_A_INOTIFY_WATCH, op, NULL, &on);
912541b0
KS		 1599 }
1600 }
1601
1602 pos = strstr(value, "static_node=");
1603 if (pos != NULL) {
1604 rule_add_key(&rule_tmp, TK_A_STATIC_NODE, op, &pos[strlen("static_node=")], NULL);
1605 rule_tmp.rule.rule.has_static_node = true;
1606 }
1607
1608 continue;
1609 }
1610
baa30fbc 1611 log_error("unknown key '%s' in %s:%u\n", key, filename, lineno);
912541b0
KS		 1612 goto invalid;
1613 }
1614
1615 /* add rule token */
1616 rule_tmp.rule.rule.token_count = 1 + rule_tmp.token_cur;
1617 if (add_token(rules, &rule_tmp.rule) != 0)
1618 goto invalid;
1619
1620 /* add tokens to list, sorted by type */
1621 if (sort_token(rules, &rule_tmp) != 0)
1622 goto invalid;
1623
1624 return 0;
c7521974 1625invalid:
baa30fbc 1626 log_error("invalid rule '%s:%u'\n", filename, lineno);
912541b0 1627 return -1;
c7521974
KS		 1628}
1629
0ef254d5 1630static int parse_file(struct udev_rules *rules, const char *filename, unsigned short filename_off)
c7521974 1631{
912541b0
KS		 1632 FILE *f;
1633 unsigned int first_token;
1634 char line[UTIL_LINE_SIZE];
1635 int line_nr = 0;
1636 unsigned int i;
1637
baa30fbc 1638 log_debug("reading '%s' as rules file\n", filename);
912541b0
KS		 1639
1640 f = fopen(filename, "r");
1641 if (f == NULL)
1642 return -1;
1643
1644 first_token = rules->token_cur;
1645
1646 while (fgets(line, sizeof(line), f) != NULL) {
1647 char *key;
1648 size_t len;
1649
1650 /* skip whitespace */
1651 line_nr++;
1652 key = line;
1653 while (isspace(key[0]))
1654 key++;
1655
1656 /* comment */
1657 if (key[0] == '#')
1658 continue;
1659
1660 len = strlen(line);
1661 if (len < 3)
1662 continue;
1663
1664 /* continue reading if backslash+newline is found */
1665 while (line[len-2] == '\\') {
1666 if (fgets(&line[len-2], (sizeof(line)-len)+2, f) == NULL)
1667 break;
1668 if (strlen(&line[len-2]) < 2)
1669 break;
1670 line_nr++;
1671 len = strlen(line);
1672 }
1673
1674 if (len+1 >= sizeof(line)) {
baa30fbc 1675 log_error("line too long '%s':%u, ignored\n", filename, line_nr);
912541b0
KS		 1676 continue;
1677 }
1678 add_rule(rules, key, filename, filename_off, line_nr);
1679 }
1680 fclose(f);
1681
1682 /* link GOTOs to LABEL rules in this file to be able to fast-forward */
1683 for (i = first_token+1; i < rules->token_cur; i++) {
1684 if (rules->tokens[i].type == TK_A_GOTO) {
1685 char *label = &rules->buf[rules->tokens[i].key.value_off];
1686 unsigned int j;
1687
1688 for (j = i+1; j < rules->token_cur; j++) {
1689 if (rules->tokens[j].type != TK_RULE)
1690 continue;
1691 if (rules->tokens[j].rule.label_off == 0)
1692 continue;
1693 if (strcmp(label, &rules->buf[rules->tokens[j].rule.label_off]) != 0)
1694 continue;
1695 rules->tokens[i].key.rule_goto = j;
1696 break;
1697 }
1698 if (rules->tokens[i].key.rule_goto == 0)
baa30fbc 1699 log_error("GOTO '%s' has no matching label in: '%s'\n", label, filename);
912541b0
KS		 1700 }
1701 }
1702 return 0;
c7521974
KS		 1703}
1704
869c9031 1705static int add_matching_files(struct udev *udev, struct udev_list *file_list, const char *dirname, const char *suffix)
c7521974 1706{
912541b0
KS		 1707 DIR *dir;
1708 struct dirent *dent;
1709 char filename[UTIL_PATH_SIZE];
1710
912541b0
KS		 1711 dir = opendir(dirname);
1712 if (dir == NULL) {
baa30fbc 1713 log_debug("unable to open '%s': %m\n", dirname);
912541b0
KS		 1714 return -1;
1715 }
1716
1717 for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
1718 if (dent->d_name[0] == '.')
1719 continue;
1720
1721 /* look for file matching with specified suffix */
1722 if (suffix != NULL) {
1723 const char *ext;
1724
1725 ext = strrchr(dent->d_name, '.');
1726 if (ext == NULL)
1727 continue;
1728 if (strcmp(ext, suffix) != 0)
1729 continue;
1730 }
1731 util_strscpyl(filename, sizeof(filename), dirname, "/", dent->d_name, NULL);
912541b0
KS		 1732 /*
1733 * the basename is the key, the filename the value
91418155 1734 * identical basenames from different directories override each other
912541b0
KS		 1735 * entries are sorted after basename
1736 */
1737 udev_list_entry_add(file_list, dent->d_name, filename);
1738 }
1739
1740 closedir(dir);
1741 return 0;
c7521974
KS		 1742}
1743
d7ddce18 1744struct udev_rules *udev_rules_new(struct udev *udev, int resolve_names)
c7521974 1745{
912541b0
KS		 1746 struct udev_rules *rules;
1747 struct udev_list file_list;
1748 struct udev_list_entry *file_loop;
1749 struct token end_token;
1750 char **s;
1751
1752 rules = calloc(1, sizeof(struct udev_rules));
1753 if (rules == NULL)
1754 return NULL;
1755 rules->udev = udev;
1756 rules->resolve_names = resolve_names;
1757 udev_list_init(udev, &file_list, true);
1758
1759 /* init token array and string buffer */
1760 rules->tokens = malloc(PREALLOC_TOKEN * sizeof(struct token));
1761 if (rules->tokens == NULL) {
1762 free(rules);
1763 return NULL;
1764 }
1765 rules->token_max = PREALLOC_TOKEN;
1766
1767 rules->buf = malloc(PREALLOC_STRBUF);
1768 if (rules->buf == NULL) {
1769 free(rules->tokens);
1770 free(rules);
1771 return NULL;
1772 }
1773 rules->buf_max = PREALLOC_STRBUF;
1774 /* offset 0 is always '\0' */
1775 rules->buf[0] = '\0';
1776 rules->buf_cur = 1;
912541b0
KS		 1777
1778 rules->trie_nodes = malloc(PREALLOC_TRIE * sizeof(struct trie_node));
1779 if (rules->trie_nodes == NULL) {
1780 free(rules->buf);
1781 free(rules->tokens);
1782 free(rules);
1783 return NULL;
1784 }
1785 rules->trie_nodes_max = PREALLOC_TRIE;
1786 /* offset 0 is the trie root, with an empty string */
1787 memset(rules->trie_nodes, 0x00, sizeof(struct trie_node));
1788 rules->trie_nodes_cur = 1;
1789
1790 for (udev_get_rules_path(udev, &s, NULL); *s != NULL; s++)
1791 add_matching_files(udev, &file_list, *s, ".rules");
1792
1793 /* add all filenames to the string buffer */
1794 udev_list_entry_foreach(file_loop, udev_list_get_entry(&file_list)) {
1795 const char *filename = udev_list_entry_get_value(file_loop);
1796 unsigned int filename_off;
1797
1798 filename_off = add_string(rules, filename);
1799 /* the offset in the rule is limited to unsigned short */
1800 if (filename_off < USHRT_MAX)
1801 udev_list_entry_set_num(file_loop, filename_off);
1802 }
1803
1804 /* parse all rules files */
1805 udev_list_entry_foreach(file_loop, udev_list_get_entry(&file_list)) {
1806 const char *filename = udev_list_entry_get_value(file_loop);
1807 unsigned int filename_off = udev_list_entry_get_num(file_loop);
1808 struct stat st;
1809
1810 if (stat(filename, &st) != 0) {
baa30fbc 1811 log_error("can not find '%s': %m\n", filename);
912541b0
KS		 1812 continue;
1813 }
1814 if (S_ISREG(st.st_mode) && st.st_size <= 0) {
baa30fbc 1815 log_debug("ignore empty '%s'\n", filename);
912541b0
KS		 1816 continue;
1817 }
1818 if (S_ISCHR(st.st_mode)) {
baa30fbc 1819 log_debug("ignore masked '%s'\n", filename);
912541b0
KS		 1820 continue;
1821 }
1822 parse_file(rules, filename, filename_off);
1823 }
1824 udev_list_cleanup(&file_list);
1825
1826 memset(&end_token, 0x00, sizeof(struct token));
1827 end_token.type = TK_END;
1828 add_token(rules, &end_token);
1829
1830 /* shrink allocated token and string buffer */
1831 if (rules->token_cur < rules->token_max) {
1832 struct token *tokens;
1833
1834 tokens = realloc(rules->tokens, rules->token_cur * sizeof(struct token));
1835 if (tokens != NULL || rules->token_cur == 0) {
1836 rules->tokens = tokens;
1837 rules->token_max = rules->token_cur;
1838 }
1839 }
1840 if (rules->buf_cur < rules->buf_max) {
1841 char *buf;
1842
1843 buf = realloc(rules->buf, rules->buf_cur);
1844 if (buf != NULL || rules->buf_cur == 0) {
1845 rules->buf = buf;
1846 rules->buf_max = rules->buf_cur;
1847 }
1848 }
baa30fbc
KS		 1849 log_debug("rules use %zu bytes tokens (%u * %zu bytes), %zu bytes buffer\n",
1850 rules->token_max * sizeof(struct token), rules->token_max, sizeof(struct token), rules->buf_max);
1851 log_debug("temporary index used %zu bytes (%u * %zu bytes)\n",
1852 rules->trie_nodes_cur * sizeof(struct trie_node),
1853 rules->trie_nodes_cur, sizeof(struct trie_node));
912541b0
KS		 1854
1855 /* cleanup trie */
1856 free(rules->trie_nodes);
1857 rules->trie_nodes = NULL;
1858 rules->trie_nodes_cur = 0;
1859 rules->trie_nodes_max = 0;
1860
1861 /* cleanup uid/gid cache */
1862 free(rules->uids);
1863 rules->uids = NULL;
1864 rules->uids_cur = 0;
1865 rules->uids_max = 0;
1866 free(rules->gids);
1867 rules->gids = NULL;
1868 rules->gids_cur = 0;
1869 rules->gids_max = 0;
1870
1871 dump_rules(rules);
1872 return rules;
c7521974
KS		 1873}
1874
7c85d636 1875struct udev_rules *udev_rules_unref(struct udev_rules *rules)
c7521974 1876{
912541b0
KS		 1877 if (rules == NULL)
1878 return NULL;
1879 free(rules->tokens);
1880 free(rules->buf);
1881 free(rules->trie_nodes);
1882 free(rules->uids);
1883 free(rules->gids);
1884 free(rules);
1885 return NULL;
c7521974 1886}
6880b25d
KS		 1887
1888static int match_key(struct udev_rules *rules, struct token *token, const char *val)
1889{
912541b0
KS		 1890 char *key_value = &rules->buf[token->key.value_off];
1891 char *pos;
1892 bool match = false;
1893
1894 if (val == NULL)
1895 val = "";
1896
1897 switch (token->key.glob) {
1898 case GL_PLAIN:
1899 match = (strcmp(key_value, val) == 0);
1900 break;
1901 case GL_GLOB:
1902 match = (fnmatch(key_value, val, 0) == 0);
1903 break;
1904 case GL_SPLIT:
1905 {
1906 const char *split;
1907 size_t len;
1908
1909 split = &rules->buf[token->key.value_off];
1910 len = strlen(val);
1911 for (;;) {
1912 const char *next;
1913
1914 next = strchr(split, '|');
1915 if (next != NULL) {
1916 size_t matchlen = (size_t)(next - split);
1917
1918 match = (matchlen == len && strncmp(split, val, matchlen) == 0);
1919 if (match)
1920 break;
1921 } else {
1922 match = (strcmp(split, val) == 0);
1923 break;
1924 }
1925 split = &next[1];
1926 }
1927 break;
1928 }
1929 case GL_SPLIT_GLOB:
1930 {
1931 char value[UTIL_PATH_SIZE];
1932
1933 util_strscpy(value, sizeof(value), &rules->buf[token->key.value_off]);
1934 key_value = value;
1935 while (key_value != NULL) {
1936 pos = strchr(key_value, '|');
1937 if (pos != NULL) {
1938 pos[0] = '\0';
1939 pos = &pos[1];
1940 }
912541b0
KS		 1941 match = (fnmatch(key_value, val, 0) == 0);
1942 if (match)
1943 break;
1944 key_value = pos;
1945 }
1946 break;
1947 }
1948 case GL_SOMETHING:
1949 match = (val[0] != '\0');
1950 break;
1951 case GL_UNSET:
1952 return -1;
1953 }
1954
baa30fbc 1955 if (match && (token->key.op == OP_MATCH))
912541b0 1956 return 0;
baa30fbc 1957 if (!match && (token->key.op == OP_NOMATCH))
912541b0 1958 return 0;
912541b0 1959 return -1;
6880b25d
KS		 1960}
1961
1962static int match_attr(struct udev_rules *rules, struct udev_device *dev, struct udev_event *event, struct token *cur)
1963{
912541b0
KS		 1964 const char *name;
1965 char nbuf[UTIL_NAME_SIZE];
1966 const char *value;
1967 char vbuf[UTIL_NAME_SIZE];
1968 size_t len;
1969
1970 name = &rules->buf[cur->key.attr_off];
1971 switch (cur->key.attrsubst) {
1972 case SB_FORMAT:
1973 udev_event_apply_format(event, name, nbuf, sizeof(nbuf));
1974 name = nbuf;
1975 /* fall through */
1976 case SB_NONE:
1977 value = udev_device_get_sysattr_value(dev, name);
1978 if (value == NULL)
1979 return -1;
1980 break;
1981 case SB_SUBSYS:
1982 if (util_resolve_subsys_kernel(event->udev, name, vbuf, sizeof(vbuf), 1) != 0)
1983 return -1;
1984 value = vbuf;
1985 break;
1986 default:
1987 return -1;
1988 }
1989
1990 /* remove trailing whitespace, if not asked to match for it */
1991 len = strlen(value);
1992 if (len > 0 && isspace(value[len-1])) {
1993 const char *key_value;
1994 size_t klen;
1995
1996 key_value = &rules->buf[cur->key.value_off];
1997 klen = strlen(key_value);
1998 if (klen > 0 && !isspace(key_value[klen-1])) {
1999 if (value != vbuf) {
2000 util_strscpy(vbuf, sizeof(vbuf), value);
2001 value = vbuf;
2002 }
2003 while (len > 0 && isspace(vbuf[--len]))
2004 vbuf[len] = '\0';
912541b0
KS		 2005 }
2006 }
2007
2008 return match_key(rules, cur, value);
6880b25d
KS		 2009}
2010
2011enum escape_type {
912541b0
KS		 2012 ESCAPE_UNSET,
2013 ESCAPE_NONE,
2014 ESCAPE_REPLACE,
6880b25d
KS		 2015};
2016
2181d30a 2017int udev_rules_apply_to_event(struct udev_rules *rules, struct udev_event *event, const sigset_t *sigmask)
6880b25d 2018{
912541b0
KS		 2019 struct token *cur;
2020 struct token *rule;
2021 enum escape_type esc = ESCAPE_UNSET;
2022 bool can_set_name;
2023
2024 if (rules->tokens == NULL)
2025 return -1;
2026
2027 can_set_name = ((strcmp(udev_device_get_action(event->dev), "remove") != 0) &&
2028 (major(udev_device_get_devnum(event->dev)) > 0 ||
2029 udev_device_get_ifindex(event->dev) > 0));
2030
2031 /* loop through token list, match, run actions or forward to next rule */
2032 cur = &rules->tokens[0];
2033 rule = cur;
2034 for (;;) {
2035 dump_token(rules, cur);
2036 switch (cur->type) {
2037 case TK_RULE:
2038 /* current rule */
2039 rule = cur;
2040 /* possibly skip rules which want to set NAME, SYMLINK, OWNER, GROUP, MODE */
2041 if (!can_set_name && rule->rule.can_set_name)
2042 goto nomatch;
2043 esc = ESCAPE_UNSET;
2044 break;
2045 case TK_M_ACTION:
2046 if (match_key(rules, cur, udev_device_get_action(event->dev)) != 0)
2047 goto nomatch;
2048 break;
2049 case TK_M_DEVPATH:
2050 if (match_key(rules, cur, udev_device_get_devpath(event->dev)) != 0)
2051 goto nomatch;
2052 break;
2053 case TK_M_KERNEL:
2054 if (match_key(rules, cur, udev_device_get_sysname(event->dev)) != 0)
2055 goto nomatch;
2056 break;
2057 case TK_M_DEVLINK: {
2058 size_t devlen = strlen(udev_get_dev_path(event->udev))+1;
2059 struct udev_list_entry *list_entry;
2060 bool match = false;
2061
2062 udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(event->dev)) {
2063 const char *devlink;
2064
2065 devlink = &udev_list_entry_get_name(list_entry)[devlen];
2066 if (match_key(rules, cur, devlink) == 0) {
2067 match = true;
2068 break;
2069 }
2070 }
2071 if (!match)
2072 goto nomatch;
2073 break;
2074 }
2075 case TK_M_NAME:
2076 if (match_key(rules, cur, event->name) != 0)
2077 goto nomatch;
2078 break;
2079 case TK_M_ENV: {
2080 const char *key_name = &rules->buf[cur->key.attr_off];
2081 const char *value;
2082
2083 value = udev_device_get_property_value(event->dev, key_name);
baa30fbc 2084 if (value == NULL)
912541b0 2085 value = "";
912541b0
KS		 2086 if (match_key(rules, cur, value))
2087 goto nomatch;
2088 break;
2089 }
2090 case TK_M_TAG: {
2091 struct udev_list_entry *list_entry;
2092 bool match = false;
2093
2094 udev_list_entry_foreach(list_entry, udev_device_get_tags_list_entry(event->dev)) {
2095 if (strcmp(&rules->buf[cur->key.value_off], udev_list_entry_get_name(list_entry)) == 0) {
2096 match = true;
2097 break;
2098 }
2099 }
2100 if (!match && (cur->key.op != OP_NOMATCH))
2101 goto nomatch;
2102 break;
2103 }
2104 case TK_M_SUBSYSTEM:
2105 if (match_key(rules, cur, udev_device_get_subsystem(event->dev)) != 0)
2106 goto nomatch;
2107 break;
2108 case TK_M_DRIVER:
2109 if (match_key(rules, cur, udev_device_get_driver(event->dev)) != 0)
2110 goto nomatch;
2111 break;
2112 case TK_M_WAITFOR: {
2113 char filename[UTIL_PATH_SIZE];
2114 int found;
2115
2116 udev_event_apply_format(event, &rules->buf[cur->key.value_off], filename, sizeof(filename));
2117 found = (wait_for_file(event->dev, filename, 10) == 0);
2118 if (!found && (cur->key.op != OP_NOMATCH))
2119 goto nomatch;
2120 break;
2121 }
2122 case TK_M_ATTR:
2123 if (match_attr(rules, event->dev, event, cur) != 0)
2124 goto nomatch;
2125 break;
2126 case TK_M_KERNELS:
2127 case TK_M_SUBSYSTEMS:
2128 case TK_M_DRIVERS:
2129 case TK_M_ATTRS:
2130 case TK_M_TAGS: {
2131 struct token *next;
2132
2133 /* get whole sequence of parent matches */
2134 next = cur;
2135 while (next->type > TK_M_PARENTS_MIN && next->type < TK_M_PARENTS_MAX)
2136 next++;
2137
2138 /* loop over parents */
2139 event->dev_parent = event->dev;
2140 for (;;) {
2141 struct token *key;
2142
912541b0
KS		 2143 /* loop over sequence of parent match keys */
2144 for (key = cur; key < next; key++ ) {
2145 dump_token(rules, key);
2146 switch(key->type) {
2147 case TK_M_KERNELS:
2148 if (match_key(rules, key, udev_device_get_sysname(event->dev_parent)) != 0)
2149 goto try_parent;
2150 break;
2151 case TK_M_SUBSYSTEMS:
2152 if (match_key(rules, key, udev_device_get_subsystem(event->dev_parent)) != 0)
2153 goto try_parent;
2154 break;
2155 case TK_M_DRIVERS:
2156 if (match_key(rules, key, udev_device_get_driver(event->dev_parent)) != 0)
2157 goto try_parent;
2158 break;
2159 case TK_M_ATTRS:
2160 if (match_attr(rules, event->dev_parent, event, key) != 0)
2161 goto try_parent;
2162 break;
2163 case TK_M_TAGS: {
2164 bool match = udev_device_has_tag(event->dev_parent, &rules->buf[cur->key.value_off]);
2165
2166 if (match && key->key.op == OP_NOMATCH)
2167 goto try_parent;
2168 if (!match && key->key.op == OP_MATCH)
2169 goto try_parent;
2170 break;
2171 }
2172 default:
2173 goto nomatch;
2174 }
912541b0 2175 }
912541b0
KS		 2176 break;
2177
2178 try_parent:
2179 event->dev_parent = udev_device_get_parent(event->dev_parent);
2180 if (event->dev_parent == NULL)
2181 goto nomatch;
2182 }
2183 /* move behind our sequence of parent match keys */
2184 cur = next;
2185 continue;
2186 }
2187 case TK_M_TEST: {
2188 char filename[UTIL_PATH_SIZE];
2189 struct stat statbuf;
2190 int match;
2191
2192 udev_event_apply_format(event, &rules->buf[cur->key.value_off], filename, sizeof(filename));
2193 if (util_resolve_subsys_kernel(event->udev, filename, filename, sizeof(filename), 0) != 0) {
2194 if (filename[0] != '/') {
2195 char tmp[UTIL_PATH_SIZE];
2196
2197 util_strscpy(tmp, sizeof(tmp), filename);
2198 util_strscpyl(filename, sizeof(filename),
2199 udev_device_get_syspath(event->dev), "/", tmp, NULL);
2200 }
2201 }
2202 attr_subst_subdir(filename, sizeof(filename));
2203
2204 match = (stat(filename, &statbuf) == 0);
baa30fbc 2205 if (match && cur->key.mode > 0)
912541b0 2206 match = ((statbuf.st_mode & cur->key.mode) > 0);
912541b0
KS		 2207 if (match && cur->key.op == OP_NOMATCH)
2208 goto nomatch;
2209 if (!match && cur->key.op == OP_MATCH)
2210 goto nomatch;
2211 break;
2212 }
2213 case TK_M_EVENT_TIMEOUT:
baa30fbc 2214 log_debug("OPTIONS event_timeout=%u\n", cur->key.event_timeout);
912541b0
KS		 2215 event->timeout_usec = cur->key.event_timeout * 1000 * 1000;
2216 break;
2217 case TK_M_PROGRAM: {
2218 char program[UTIL_PATH_SIZE];
2219 char **envp;
2220 char result[UTIL_PATH_SIZE];
2221
2222 free(event->program_result);
2223 event->program_result = NULL;
2224 udev_event_apply_format(event, &rules->buf[cur->key.value_off], program, sizeof(program));
2225 envp = udev_device_get_properties_envp(event->dev);
baa30fbc
KS		 2226 log_debug("PROGRAM '%s' %s:%u\n",
2227 program,
2228 &rules->buf[rule->rule.filename_off],
2229 rule->rule.filename_line);
912541b0
KS		 2230
2231 if (udev_event_spawn(event, program, envp, sigmask, result, sizeof(result)) < 0) {
2232 if (cur->key.op != OP_NOMATCH)
2233 goto nomatch;
2234 } else {
2235 int count;
2236
2237 util_remove_trailing_chars(result, '\n');
2238 if (esc == ESCAPE_UNSET || esc == ESCAPE_REPLACE) {
2239 count = util_replace_chars(result, UDEV_ALLOWED_CHARS_INPUT);
2240 if (count > 0)
baa30fbc 2241 log_debug("%i character(s) replaced\n" , count);
912541b0
KS		 2242 }
2243 event->program_result = strdup(result);
912541b0
KS		 2244 if (cur->key.op == OP_NOMATCH)
2245 goto nomatch;
2246 }
2247 break;
2248 }
2249 case TK_M_IMPORT_FILE: {
2250 char import[UTIL_PATH_SIZE];
2251
2252 udev_event_apply_format(event, &rules->buf[cur->key.value_off], import, sizeof(import));
2253 if (import_file_into_properties(event->dev, import) != 0)
2254 if (cur->key.op != OP_NOMATCH)
2255 goto nomatch;
2256 break;
2257 }
2258 case TK_M_IMPORT_PROG: {
2259 char import[UTIL_PATH_SIZE];
2260
2261 udev_event_apply_format(event, &rules->buf[cur->key.value_off], import, sizeof(import));
baa30fbc
KS		 2262 log_debug("IMPORT '%s' %s:%u\n",
2263 import,
2264 &rules->buf[rule->rule.filename_off],
2265 rule->rule.filename_line);
912541b0
KS		 2266
2267 if (import_program_into_properties(event, import, sigmask) != 0)
2268 if (cur->key.op != OP_NOMATCH)
2269 goto nomatch;
2270 break;
2271 }
2272 case TK_M_IMPORT_BUILTIN: {
2273 char command[UTIL_PATH_SIZE];
2274
2275 if (udev_builtin_run_once(cur->key.builtin_cmd)) {
2276 /* check if we ran already */
2277 if (event->builtin_run & (1 << cur->key.builtin_cmd)) {
baa30fbc
KS		 2278 log_debug("IMPORT builtin skip '%s' %s:%u\n",
2279 udev_builtin_name(cur->key.builtin_cmd),
2280 &rules->buf[rule->rule.filename_off],
2281 rule->rule.filename_line);
912541b0
KS		 2282 /* return the result from earlier run */
2283 if (event->builtin_ret & (1 << cur->key.builtin_cmd))
2284 if (cur->key.op != OP_NOMATCH)
2285 goto nomatch;
2286 break;
2287 }
2288 /* mark as ran */
2289 event->builtin_run |= (1 << cur->key.builtin_cmd);
2290 }
2291
2292 udev_event_apply_format(event, &rules->buf[cur->key.value_off], command, sizeof(command));
baa30fbc
KS		 2293 log_debug("IMPORT builtin '%s' %s:%u\n",
2294 udev_builtin_name(cur->key.builtin_cmd),
2295 &rules->buf[rule->rule.filename_off],
2296 rule->rule.filename_line);
912541b0
KS		 2297
2298 if (udev_builtin_run(event->dev, cur->key.builtin_cmd, command, false) != 0) {
2299 /* remember failure */
baa30fbc
KS		 2300 log_debug("IMPORT builtin '%s' returned non-zero\n",
2301 udev_builtin_name(cur->key.builtin_cmd));
912541b0
KS		 2302 event->builtin_ret |= (1 << cur->key.builtin_cmd);
2303 if (cur->key.op != OP_NOMATCH)
2304 goto nomatch;
2305 }
2306 break;
2307 }
2308 case TK_M_IMPORT_DB: {
2309 const char *key = &rules->buf[cur->key.value_off];
2310 const char *value;
2311
2312 value = udev_device_get_property_value(event->dev_db, key);
2313 if (value != NULL) {
2314 struct udev_list_entry *entry;
2315
2316 entry = udev_device_add_property(event->dev, key, value);
2317 udev_list_entry_set_num(entry, true);
2318 } else {
2319 if (cur->key.op != OP_NOMATCH)
2320 goto nomatch;
2321 }
2322 break;
2323 }
2324 case TK_M_IMPORT_CMDLINE: {
2325 FILE *f;
2326 bool imported = false;
2327
2328 f = fopen("/proc/cmdline", "r");
2329 if (f != NULL) {
2330 char cmdline[4096];
2331
2332 if (fgets(cmdline, sizeof(cmdline), f) != NULL) {
2333 const char *key = &rules->buf[cur->key.value_off];
2334 char *pos;
2335
2336 pos = strstr(cmdline, key);
2337 if (pos != NULL) {
2338 struct udev_list_entry *entry;
2339
2340 pos += strlen(key);
2341 if (pos[0] == '\0' || isspace(pos[0])) {
2342 /* we import simple flags as 'FLAG=1' */
2343 entry = udev_device_add_property(event->dev, key, "1");
2344 udev_list_entry_set_num(entry, true);
2345 imported = true;
2346 } else if (pos[0] == '=') {
2347 const char *value;
2348
2349 pos++;
2350 value = pos;
2351 while (pos[0] != '\0' && !isspace(pos[0]))
2352 pos++;
2353 pos[0] = '\0';
2354 entry = udev_device_add_property(event->dev, key, value);
2355 udev_list_entry_set_num(entry, true);
2356 imported = true;
2357 }
2358 }
2359 }
2360 fclose(f);
2361 }
2362 if (!imported && cur->key.op != OP_NOMATCH)
2363 goto nomatch;
2364 break;
2365 }
2366 case TK_M_IMPORT_PARENT: {
2367 char import[UTIL_PATH_SIZE];
2368
2369 udev_event_apply_format(event, &rules->buf[cur->key.value_off], import, sizeof(import));
2370 if (import_parent_into_properties(event->dev, import) != 0)
2371 if (cur->key.op != OP_NOMATCH)
2372 goto nomatch;
2373 break;
2374 }
2375 case TK_M_RESULT:
2376 if (match_key(rules, cur, event->program_result) != 0)
2377 goto nomatch;
2378 break;
2379 case TK_A_STRING_ESCAPE_NONE:
2380 esc = ESCAPE_NONE;
2381 break;
2382 case TK_A_STRING_ESCAPE_REPLACE:
2383 esc = ESCAPE_REPLACE;
2384 break;
2385 case TK_A_DB_PERSIST:
2386 udev_device_set_db_persist(event->dev);
2387 break;
2388 case TK_A_INOTIFY_WATCH:
2389 if (event->inotify_watch_final)
2390 break;
2391 if (cur->key.op == OP_ASSIGN_FINAL)
2392 event->inotify_watch_final = true;
2393 event->inotify_watch = cur->key.watch;
2394 break;
2395 case TK_A_DEVLINK_PRIO:
2396 udev_device_set_devlink_priority(event->dev, cur->key.devlink_prio);
2397 break;
2398 case TK_A_OWNER: {
2399 char owner[UTIL_NAME_SIZE];
2400
2401 if (event->owner_final)
2402 break;
2403 if (cur->key.op == OP_ASSIGN_FINAL)
2404 event->owner_final = true;
2405 udev_event_apply_format(event, &rules->buf[cur->key.value_off], owner, sizeof(owner));
2406 event->uid = util_lookup_user(event->udev, owner);
baa30fbc
KS		 2407 log_debug("OWNER %u %s:%u\n",
2408 event->uid,
2409 &rules->buf[rule->rule.filename_off],
2410 rule->rule.filename_line);
912541b0
KS		 2411 break;
2412 }
2413 case TK_A_GROUP: {
2414 char group[UTIL_NAME_SIZE];
2415
2416 if (event->group_final)
2417 break;
2418 if (cur->key.op == OP_ASSIGN_FINAL)
2419 event->group_final = true;
2420 udev_event_apply_format(event, &rules->buf[cur->key.value_off], group, sizeof(group));
2421 event->gid = util_lookup_group(event->udev, group);
baa30fbc
KS		 2422 log_debug("GROUP %u %s:%u\n",
2423 event->gid,
2424 &rules->buf[rule->rule.filename_off],
2425 rule->rule.filename_line);
912541b0
KS		 2426 break;
2427 }
2428 case TK_A_MODE: {
2429 char mode_str[UTIL_NAME_SIZE];
2430 mode_t mode;
2431 char *endptr;
2432
2433 if (event->mode_final)
2434 break;
2435 udev_event_apply_format(event, &rules->buf[cur->key.value_off], mode_str, sizeof(mode_str));
2436 mode = strtol(mode_str, &endptr, 8);
2437 if (endptr[0] != '\0') {
baa30fbc 2438 log_error("ignoring invalid mode '%s'\n", mode_str);
912541b0
KS		 2439 break;
2440 }
2441 if (cur->key.op == OP_ASSIGN_FINAL)
2442 event->mode_final = true;
2443 event->mode_set = true;
2444 event->mode = mode;
baa30fbc
KS		 2445 log_debug("MODE %#o %s:%u\n",
2446 event->mode,
2447 &rules->buf[rule->rule.filename_off],
2448 rule->rule.filename_line);
912541b0
KS		 2449 break;
2450 }
2451 case TK_A_OWNER_ID:
2452 if (event->owner_final)
2453 break;
2454 if (cur->key.op == OP_ASSIGN_FINAL)
2455 event->owner_final = true;
2456 event->uid = cur->key.uid;
baa30fbc
KS		 2457 log_debug("OWNER %u %s:%u\n",
2458 event->uid,
2459 &rules->buf[rule->rule.filename_off],
2460 rule->rule.filename_line);
912541b0
KS		 2461 break;
2462 case TK_A_GROUP_ID:
2463 if (event->group_final)
2464 break;
2465 if (cur->key.op == OP_ASSIGN_FINAL)
2466 event->group_final = true;
2467 event->gid = cur->key.gid;
baa30fbc
KS		 2468 log_debug("GROUP %u %s:%u\n",
2469 event->gid,
2470 &rules->buf[rule->rule.filename_off],
2471 rule->rule.filename_line);
912541b0
KS		 2472 break;
2473 case TK_A_MODE_ID:
2474 if (event->mode_final)
2475 break;
2476 if (cur->key.op == OP_ASSIGN_FINAL)
2477 event->mode_final = true;
2478 event->mode_set = true;
2479 event->mode = cur->key.mode;
baa30fbc
KS		 2480 log_debug("MODE %#o %s:%u\n",
2481 event->mode,
2482 &rules->buf[rule->rule.filename_off],
2483 rule->rule.filename_line);
912541b0
KS		 2484 break;
2485 case TK_A_ENV: {
2486 const char *name = &rules->buf[cur->key.attr_off];
2487 char *value = &rules->buf[cur->key.value_off];
2488
2489 if (value[0] != '\0') {
2490 char temp_value[UTIL_NAME_SIZE];
2491 struct udev_list_entry *entry;
2492
2493 udev_event_apply_format(event, value, temp_value, sizeof(temp_value));
2494 entry = udev_device_add_property(event->dev, name, temp_value);
2495 /* store in db, skip private keys */
2496 if (name[0] != '.')
2497 udev_list_entry_set_num(entry, true);
2498 } else {
2499 udev_device_add_property(event->dev, name, NULL);
2500 }
2501 break;
2502 }
2503 case TK_A_TAG: {
2504 char tag[UTIL_PATH_SIZE];
2505 const char *p;
2506
2507 udev_event_apply_format(event, &rules->buf[cur->key.value_off], tag, sizeof(tag));
2508 if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
2509 udev_device_cleanup_tags_list(event->dev);
2510 for (p = tag; *p != '\0'; p++) {
2511 if ((*p >= 'a' && *p <= 'z') ||
2512 (*p >= 'A' && *p <= 'Z') ||
2513 (*p >= '0' && *p <= '9') ||
2514 *p == '-' || *p == '_')
2515 continue;
baa30fbc 2516 log_error("ignoring invalid tag name '%s'\n", tag);
912541b0
KS		 2517 break;
2518 }
2519 udev_device_add_tag(event->dev, tag);
2520 break;
2521 }
2522 case TK_A_NAME: {
2523 const char *name = &rules->buf[cur->key.value_off];
0ecfcbd4 2524
912541b0
KS		 2525 char name_str[UTIL_PATH_SIZE];
2526 int count;
2527
2528 if (event->name_final)
2529 break;
2530 if (cur->key.op == OP_ASSIGN_FINAL)
2531 event->name_final = true;
2532 udev_event_apply_format(event, name, name_str, sizeof(name_str));
2533 if (esc == ESCAPE_UNSET || esc == ESCAPE_REPLACE) {
2534 count = util_replace_chars(name_str, "/");
2535 if (count > 0)
baa30fbc 2536 log_debug("%i character(s) replaced\n", count);
912541b0 2537 }
0ecfcbd4
KS		 2538 if (major(udev_device_get_devnum(event->dev))) {
2539 size_t devlen = strlen(udev_get_dev_path(event->udev))+1;
2540
2541 if (strcmp(name_str, &udev_device_get_devnode(event->dev)[devlen]) != 0) {
baa30fbc 2542 log_error("NAME=\"%s\" ignored, kernel device nodes "
0ecfcbd4
KS		 2543 "can not be renamed; please fix it in %s:%u\n", name,
2544 &rules->buf[rule->rule.filename_off], rule->rule.filename_line);
2545 break;
2546 }
2547 }
912541b0
KS		 2548 free(event->name);
2549 event->name = strdup(name_str);
baa30fbc
KS		 2550 log_debug("NAME '%s' %s:%u\n",
2551 event->name,
2552 &rules->buf[rule->rule.filename_off],
2553 rule->rule.filename_line);
912541b0
KS		 2554 break;
2555 }
2556 case TK_A_DEVLINK: {
2557 char temp[UTIL_PATH_SIZE];
2558 char filename[UTIL_PATH_SIZE];
2559 char *pos, *next;
2560 int count = 0;
2561
2562 if (event->devlink_final)
2563 break;
2564 if (major(udev_device_get_devnum(event->dev)) == 0)
2565 break;
2566 if (cur->key.op == OP_ASSIGN_FINAL)
2567 event->devlink_final = true;
2568 if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
2569 udev_device_cleanup_devlinks_list(event->dev);
2570
2571 /* allow multiple symlinks separated by spaces */
2572 udev_event_apply_format(event, &rules->buf[cur->key.value_off], temp, sizeof(temp));
2573 if (esc == ESCAPE_UNSET)
2574 count = util_replace_chars(temp, "/ ");
2575 else if (esc == ESCAPE_REPLACE)
2576 count = util_replace_chars(temp, "/");
2577 if (count > 0)
baa30fbc 2578 log_debug("%i character(s) replaced\n" , count);
912541b0
KS		 2579 pos = temp;
2580 while (isspace(pos[0]))
2581 pos++;
2582 next = strchr(pos, ' ');
2583 while (next != NULL) {
2584 next[0] = '\0';
baa30fbc
KS		 2585 log_debug("LINK '%s' %s:%u\n", pos,
2586 &rules->buf[rule->rule.filename_off], rule->rule.filename_line);
912541b0
KS		 2587 util_strscpyl(filename, sizeof(filename), udev_get_dev_path(event->udev), "/", pos, NULL);
2588 udev_device_add_devlink(event->dev, filename, cur->key.devlink_unique);
2589 while (isspace(next[1]))
2590 next++;
2591 pos = &next[1];
2592 next = strchr(pos, ' ');
2593 }
2594 if (pos[0] != '\0') {
baa30fbc
KS		 2595 log_debug("LINK '%s' %s:%u\n", pos,
2596 &rules->buf[rule->rule.filename_off], rule->rule.filename_line);
912541b0
KS		 2597 util_strscpyl(filename, sizeof(filename), udev_get_dev_path(event->udev), "/", pos, NULL);
2598 udev_device_add_devlink(event->dev, filename, cur->key.devlink_unique);
2599 }
2600 break;
2601 }
2602 case TK_A_ATTR: {
2603 const char *key_name = &rules->buf[cur->key.attr_off];
2604 char attr[UTIL_PATH_SIZE];
2605 char value[UTIL_NAME_SIZE];
2606 FILE *f;
2607
2608 if (util_resolve_subsys_kernel(event->udev, key_name, attr, sizeof(attr), 0) != 0)
2609 util_strscpyl(attr, sizeof(attr), udev_device_get_syspath(event->dev), "/", key_name, NULL);
2610 attr_subst_subdir(attr, sizeof(attr));
2611
2612 udev_event_apply_format(event, &rules->buf[cur->key.value_off], value, sizeof(value));
baa30fbc
KS		 2613 log_debug("ATTR '%s' writing '%s' %s:%u\n", attr, value,
2614 &rules->buf[rule->rule.filename_off],
2615 rule->rule.filename_line);
912541b0
KS		 2616 f = fopen(attr, "w");
2617 if (f != NULL) {
2618 if (fprintf(f, "%s", value) <= 0)
baa30fbc 2619 log_error("error writing ATTR{%s}: %m\n", attr);
912541b0
KS		 2620 fclose(f);
2621 } else {
baa30fbc 2622 log_error("error opening ATTR{%s} for writing: %m\n", attr);
912541b0
KS		 2623 }
2624 break;
2625 }
83cd6b75
KS		 2626 case TK_A_RUN_BUILTIN:
2627 case TK_A_RUN_PROGRAM: {
2628 struct udev_list_entry *entry;
2629
912541b0
KS		 2630 if (cur->key.op == OP_ASSIGN || cur->key.op == OP_ASSIGN_FINAL)
2631 udev_list_cleanup(&event->run_list);
baa30fbc
KS		 2632 log_debug("RUN '%s' %s:%u\n",
2633 &rules->buf[cur->key.value_off],
2634 &rules->buf[rule->rule.filename_off],
2635 rule->rule.filename_line);
83cd6b75
KS		 2636 entry = udev_list_entry_add(&event->run_list, &rules->buf[cur->key.value_off], NULL);
2637 udev_list_entry_set_num(entry, cur->key.builtin_cmd);
912541b0
KS		 2638 break;
2639 }
2640 case TK_A_GOTO:
2641 if (cur->key.rule_goto == 0)
2642 break;
2643 cur = &rules->tokens[cur->key.rule_goto];
2644 continue;
2645 case TK_END:
2646 return 0;
2647
2648 case TK_M_PARENTS_MIN:
2649 case TK_M_PARENTS_MAX:
2650 case TK_M_MAX:
2651 case TK_UNSET:
baa30fbc 2652 log_error("wrong type %u\n", cur->type);
912541b0
KS		 2653 goto nomatch;
2654 }
2655
2656 cur++;
2657 continue;
2658 nomatch:
2659 /* fast-forward to next rule */
2660 cur = rule + rule->rule.token_count;
912541b0 2661 }
6880b25d 2662}
761dfddc
KS		 2663
2664void udev_rules_apply_static_dev_perms(struct udev_rules *rules)
2665{
912541b0
KS		 2666 struct token *cur;
2667 struct token *rule;
2668 uid_t uid = 0;
2669 gid_t gid = 0;
2670 mode_t mode = 0;
2671
2672 if (rules->tokens == NULL)
2673 return;
2674
2675 cur = &rules->tokens[0];
2676 rule = cur;
2677 for (;;) {
2678 switch (cur->type) {
2679 case TK_RULE:
2680 /* current rule */
2681 rule = cur;
2682
2683 /* skip rules without a static_node tag */
2684 if (!rule->rule.has_static_node)
2685 goto next;
2686
2687 uid = 0;
2688 gid = 0;
2689 mode = 0;
2690 break;
2691 case TK_A_OWNER_ID:
2692 uid = cur->key.uid;
2693 break;
2694 case TK_A_GROUP_ID:
2695 gid = cur->key.gid;
2696 break;
2697 case TK_A_MODE_ID:
2698 mode = cur->key.mode;
2699 break;
2700 case TK_A_STATIC_NODE: {
2701 char filename[UTIL_PATH_SIZE];
2702 struct stat stats;
2703
2704 /* we assure, that the permissions tokens are sorted before the static token */
2705 if (mode == 0 && uid == 0 && gid == 0)
2706 goto next;
2707 util_strscpyl(filename, sizeof(filename), udev_get_dev_path(rules->udev), "/",
2708 &rules->buf[cur->key.value_off], NULL);
2709 if (stat(filename, &stats) != 0)
2710 goto next;
2711 if (!S_ISBLK(stats.st_mode) && !S_ISCHR(stats.st_mode))
2712 goto next;
2713 if (mode == 0) {
2714 if (gid > 0)
2715 mode = 0660;
2716 else
2717 mode = 0600;
2718 }
2719 if (mode != (stats.st_mode & 01777)) {
2720 chmod(filename, mode);
baa30fbc 2721 log_debug("chmod '%s' %#o\n", filename, mode);
912541b0
KS		 2722 }
2723
2724 if ((uid != 0 && uid != stats.st_uid) || (gid != 0 && gid != stats.st_gid)) {
2725 chown(filename, uid, gid);
baa30fbc 2726 log_debug("chown '%s' %u %u\n", filename, uid, gid);
912541b0
KS		 2727 }
2728
2729 utimensat(AT_FDCWD, filename, NULL, 0);
2730 break;
2731 }
2732 case TK_END:
2733 return;
2734 }
2735
2736 cur++;
2737 continue;
761dfddc 2738next:
912541b0
KS		 2739 /* fast-forward to next rule */
2740 cur = rule + rule->rule.token_count;
2741 continue;
2742 }
761dfddc 2743}
Unnamed repository; edit this file 'description' to name the repository.