]> git.ipfire.org Git - thirdparty/kmod.git/blob - libkmod/libkmod-config.c
config: save list of config paths with their timestamps
[thirdparty/kmod.git] / libkmod / libkmod-config.c
1 /*
2 * libkmod - interface to kernel module operations
3 *
4 * Copyright (C) 2011 ProFUSION embedded systems
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <stddef.h>
24 #include <stdarg.h>
25 #include <unistd.h>
26 #include <errno.h>
27 #include <string.h>
28 #include <ctype.h>
29 #include <sys/stat.h>
30 #include <sys/types.h>
31 #include <dirent.h>
32
33 #include "libkmod.h"
34 #include "libkmod-private.h"
35
36 struct kmod_alias {
37 char *name;
38 char modname[];
39 };
40
41 struct kmod_options {
42 char *options;
43 char modname[];
44 };
45
46 struct kmod_command {
47 char *command;
48 char modname[];
49 };
50
51 struct kmod_softdep {
52 char *name;
53 const char **pre;
54 const char **post;
55 unsigned int n_pre;
56 unsigned int n_post;
57 };
58
59 const char *kmod_blacklist_get_modname(const struct kmod_list *l)
60 {
61 return l->data;
62 }
63
64 const char *kmod_alias_get_name(const struct kmod_list *l) {
65 const struct kmod_alias *alias = l->data;
66 return alias->name;
67 }
68
69 const char *kmod_alias_get_modname(const struct kmod_list *l) {
70 const struct kmod_alias *alias = l->data;
71 return alias->modname;
72 }
73
74 const char *kmod_option_get_options(const struct kmod_list *l) {
75 const struct kmod_options *alias = l->data;
76 return alias->options;
77 }
78
79 const char *kmod_option_get_modname(const struct kmod_list *l) {
80 const struct kmod_options *alias = l->data;
81 return alias->modname;
82 }
83
84 const char *kmod_command_get_command(const struct kmod_list *l) {
85 const struct kmod_command *alias = l->data;
86 return alias->command;
87 }
88
89 const char *kmod_command_get_modname(const struct kmod_list *l) {
90 const struct kmod_command *alias = l->data;
91 return alias->modname;
92 }
93
94 const char *kmod_softdep_get_name(const struct kmod_list *l) {
95 const struct kmod_softdep *dep = l->data;
96 return dep->name;
97 }
98
99 const char * const *kmod_softdep_get_pre(const struct kmod_list *l, unsigned int *count) {
100 const struct kmod_softdep *dep = l->data;
101 *count = dep->n_pre;
102 return dep->pre;
103 }
104
105 const char * const *kmod_softdep_get_post(const struct kmod_list *l, unsigned int *count) {
106 const struct kmod_softdep *dep = l->data;
107 *count = dep->n_post;
108 return dep->post;
109 }
110
111 static int kmod_config_add_command(struct kmod_config *config,
112 const char *modname,
113 const char *command,
114 const char *command_name,
115 struct kmod_list **list)
116 {
117 struct kmod_command *cmd;
118 struct kmod_list *l;
119 size_t modnamelen = strlen(modname) + 1;
120 size_t commandlen = strlen(command) + 1;
121
122 DBG(config->ctx, "modname='%s' cmd='%s %s'\n", modname, command_name,
123 command);
124
125 cmd = malloc(sizeof(*cmd) + modnamelen + commandlen);
126 if (cmd == NULL)
127 goto oom_error_init;
128
129 cmd->command = sizeof(*cmd) + modnamelen + (char *)cmd;
130 memcpy(cmd->modname, modname, modnamelen);
131 memcpy(cmd->command, command, commandlen);
132
133 l = kmod_list_append(*list, cmd);
134 if (l == NULL)
135 goto oom_error;
136
137 *list = l;
138 return 0;
139
140 oom_error:
141 free(cmd);
142 oom_error_init:
143 ERR(config->ctx, "out-of-memory\n");
144 return -ENOMEM;
145 }
146
147 static void kmod_config_free_command(struct kmod_config *config,
148 struct kmod_list *l,
149 struct kmod_list **list)
150 {
151 struct kmod_command *cmd = l->data;
152
153 free(cmd);
154 *list = kmod_list_remove(l);
155 }
156
157 static int kmod_config_add_options(struct kmod_config *config,
158 const char *modname, const char *options)
159 {
160 struct kmod_options *opt;
161 struct kmod_list *list;
162 size_t modnamelen = strlen(modname) + 1;
163 size_t optionslen = strlen(options) + 1;
164
165 DBG(config->ctx, "modname='%s' options='%s'\n", modname, options);
166
167 opt = malloc(sizeof(*opt) + modnamelen + optionslen);
168 if (opt == NULL)
169 goto oom_error_init;
170
171 opt->options = sizeof(*opt) + modnamelen + (char *)opt;
172
173 memcpy(opt->modname, modname, modnamelen);
174 memcpy(opt->options, options, optionslen);
175 strchr_replace(opt->options, '\t', ' ');
176
177 list = kmod_list_append(config->options, opt);
178 if (list == NULL)
179 goto oom_error;
180
181 config->options = list;
182 return 0;
183
184 oom_error:
185 free(opt);
186 oom_error_init:
187 ERR(config->ctx, "out-of-memory\n");
188 return -ENOMEM;
189 }
190
191 static void kmod_config_free_options(struct kmod_config *config,
192 struct kmod_list *l)
193 {
194 struct kmod_options *opt = l->data;
195
196 free(opt);
197
198 config->options = kmod_list_remove(l);
199 }
200
201 static int kmod_config_add_alias(struct kmod_config *config,
202 const char *name, const char *modname)
203 {
204 struct kmod_alias *alias;
205 struct kmod_list *list;
206 size_t namelen = strlen(name) + 1, modnamelen = strlen(modname) + 1;
207
208 DBG(config->ctx, "name=%s modname=%s\n", name, modname);
209
210 alias = malloc(sizeof(*alias) + namelen + modnamelen);
211 if (!alias)
212 goto oom_error_init;
213
214 alias->name = sizeof(*alias) + modnamelen + (char *)alias;
215
216 memcpy(alias->modname, modname, modnamelen);
217 memcpy(alias->name, name, namelen);
218
219 list = kmod_list_append(config->aliases, alias);
220 if (!list)
221 goto oom_error;
222
223 config->aliases = list;
224 return 0;
225
226 oom_error:
227 free(alias);
228 oom_error_init:
229 ERR(config->ctx, "out-of-memory name=%s modname=%s\n", name, modname);
230 return -ENOMEM;
231 }
232
233 static void kmod_config_free_alias(struct kmod_config *config,
234 struct kmod_list *l)
235 {
236 struct kmod_alias *alias = l->data;
237
238 free(alias);
239
240 config->aliases = kmod_list_remove(l);
241 }
242
243 static int kmod_config_add_blacklist(struct kmod_config *config,
244 const char *modname)
245 {
246 char *p;
247 struct kmod_list *list;
248
249 DBG(config->ctx, "modname=%s\n", modname);
250
251 p = strdup(modname);
252 if (!p)
253 goto oom_error_init;
254
255 list = kmod_list_append(config->blacklists, p);
256 if (!list)
257 goto oom_error;
258 config->blacklists = list;
259 return 0;
260
261 oom_error:
262 free(p);
263 oom_error_init:
264 ERR(config->ctx, "out-of-memory modname=%s\n", modname);
265 return -ENOMEM;
266 }
267
268 static void kmod_config_free_blacklist(struct kmod_config *config,
269 struct kmod_list *l)
270 {
271 free(l->data);
272 config->blacklists = kmod_list_remove(l);
273 }
274
275 static int kmod_config_add_softdep(struct kmod_config *config,
276 const char *modname,
277 const char *line)
278 {
279 struct kmod_list *list;
280 struct kmod_softdep *dep;
281 const char *s, *p;
282 char *itr;
283 unsigned int n_pre = 0, n_post = 0;
284 size_t modnamelen = strlen(modname) + 1;
285 size_t buflen = 0;
286 bool was_space = false;
287 enum { S_NONE, S_PRE, S_POST } mode = S_NONE;
288
289 DBG(config->ctx, "modname=%s\n", modname);
290
291 /* analyze and count */
292 for (p = s = line; ; s++) {
293 size_t plen;
294
295 if (*s != '\0') {
296 if (!isspace(*s)) {
297 was_space = false;
298 continue;
299 }
300
301 if (was_space) {
302 p = s + 1;
303 continue;
304 }
305 was_space = true;
306
307 if (p >= s)
308 continue;
309 }
310 plen = s - p;
311
312 if (plen == sizeof("pre:") - 1 &&
313 memcmp(p, "pre:", sizeof("pre:") - 1) == 0)
314 mode = S_PRE;
315 else if (plen == sizeof("post:") - 1 &&
316 memcmp(p, "post:", sizeof("post:") - 1) == 0)
317 mode = S_POST;
318 else if (*s != '\0' || (*s == '\0' && !was_space)) {
319 if (mode == S_PRE) {
320 buflen += plen + 1;
321 n_pre++;
322 } else if (mode == S_POST) {
323 buflen += plen + 1;
324 n_post++;
325 }
326 }
327 p = s + 1;
328 if (*s == '\0')
329 break;
330 }
331
332 DBG(config->ctx, "%u pre, %u post\n", n_pre, n_post);
333
334 dep = malloc(sizeof(struct kmod_softdep) + modnamelen +
335 n_pre * sizeof(const char *) +
336 n_post * sizeof(const char *) +
337 buflen);
338 if (dep == NULL) {
339 ERR(config->ctx, "out-of-memory modname=%s\n", modname);
340 return -ENOMEM;
341 }
342 dep->n_pre = n_pre;
343 dep->n_post = n_post;
344 dep->pre = (const char **)((char *)dep + sizeof(struct kmod_softdep));
345 dep->post = dep->pre + n_pre;
346 dep->name = (char *)(dep->post + n_post);
347
348 memcpy(dep->name, modname, modnamelen);
349
350 /* copy strings */
351 itr = dep->name + modnamelen;
352 n_pre = 0;
353 n_post = 0;
354 mode = S_NONE;
355 for (p = s = line; ; s++) {
356 size_t plen;
357
358 if (*s != '\0') {
359 if (!isspace(*s)) {
360 was_space = false;
361 continue;
362 }
363
364 if (was_space) {
365 p = s + 1;
366 continue;
367 }
368 was_space = true;
369
370 if (p >= s)
371 continue;
372 }
373 plen = s - p;
374
375 if (plen == sizeof("pre:") - 1 &&
376 memcmp(p, "pre:", sizeof("pre:") - 1) == 0)
377 mode = S_PRE;
378 else if (plen == sizeof("post:") - 1 &&
379 memcmp(p, "post:", sizeof("post:") - 1) == 0)
380 mode = S_POST;
381 else if (*s != '\0' || (*s == '\0' && !was_space)) {
382 if (mode == S_PRE) {
383 dep->pre[n_pre] = itr;
384 memcpy(itr, p, plen);
385 itr[plen] = '\0';
386 itr += plen + 1;
387 n_pre++;
388 } else if (mode == S_POST) {
389 dep->post[n_post] = itr;
390 memcpy(itr, p, plen);
391 itr[plen] = '\0';
392 itr += plen + 1;
393 n_post++;
394 }
395 }
396 p = s + 1;
397 if (*s == '\0')
398 break;
399 }
400
401 list = kmod_list_append(config->softdeps, dep);
402 if (list == NULL) {
403 free(dep);
404 return -ENOMEM;
405 }
406 config->softdeps = list;
407
408 return 0;
409 }
410
411 static void kmod_config_free_softdep(struct kmod_config *config,
412 struct kmod_list *l)
413 {
414 free(l->data);
415 config->softdeps = kmod_list_remove(l);
416 }
417
418 static void kcmdline_parse_result(struct kmod_config *config, char *modname,
419 char *param, char *value)
420 {
421 if (modname == NULL || param == NULL || value == NULL)
422 return;
423
424 DBG(config->ctx, "%s %s\n", modname, param);
425
426 if (streq(modname, "modprobe") && !strncmp(param, "blacklist=", 10)) {
427 for (;;) {
428 char *t = strsep(&value, ",");
429 if (t == NULL)
430 break;
431
432 kmod_config_add_blacklist(config, t);
433 }
434 } else {
435 kmod_config_add_options(config,
436 underscores(config->ctx, modname), param);
437 }
438 }
439
440 static int kmod_config_parse_kcmdline(struct kmod_config *config)
441 {
442 char buf[KCMD_LINE_SIZE];
443 int fd, err;
444 char *p, *modname, *param = NULL, *value = NULL;
445
446 fd = open("/proc/cmdline", O_RDONLY|O_CLOEXEC);
447 err = read_str_safe(fd, buf, sizeof(buf));
448 close(fd);
449 if (err < 0) {
450 ERR(config->ctx, "could not read from '/proc/cmdline': %s\n",
451 strerror(-err));
452 return err;
453 }
454
455 for (p = buf, modname = buf; *p != '\0' && *p != '\n'; p++) {
456 switch (*p) {
457 case ' ':
458 *p = '\0';
459 kcmdline_parse_result(config, modname, param, value);
460 param = value = NULL;
461 modname = p + 1;
462 break;
463 case '.':
464 *p = '\0';
465 param = p + 1;
466 break;
467 case '=':
468 if (param != NULL)
469 value = p + 1;
470 break;
471 }
472 }
473
474 *p = '\0';
475 kcmdline_parse_result(config, modname, param, value);
476
477 return 0;
478 }
479
480 /*
481 * Take an fd and own it. It will be closed on return. filename is used only
482 * for debug messages
483 */
484 static int kmod_config_parse(struct kmod_config *config, int fd,
485 const char *filename)
486 {
487 struct kmod_ctx *ctx = config->ctx;
488 char *line;
489 FILE *fp;
490 unsigned int linenum = 0;
491 int err;
492
493 fp = fdopen(fd, "r");
494 if (fp == NULL) {
495 err = -errno;
496 ERR(config->ctx, "fd %d: %m", fd);
497 close(fd);
498 return err;
499 }
500
501 while ((line = getline_wrapped(fp, &linenum)) != NULL) {
502 char *cmd, *saveptr;
503
504 if (line[0] == '\0' || line[0] == '#')
505 goto done_next;
506
507 cmd = strtok_r(line, "\t ", &saveptr);
508 if (cmd == NULL)
509 goto done_next;
510
511 if (streq(cmd, "alias")) {
512 char *alias = strtok_r(NULL, "\t ", &saveptr);
513 char *modname = strtok_r(NULL, "\t ", &saveptr);
514
515 if (alias == NULL || modname == NULL)
516 goto syntax_error;
517
518 kmod_config_add_alias(config,
519 underscores(ctx, alias),
520 underscores(ctx, modname));
521 } else if (streq(cmd, "blacklist")) {
522 char *modname = strtok_r(NULL, "\t ", &saveptr);
523
524 if (modname == NULL)
525 goto syntax_error;
526
527 kmod_config_add_blacklist(config,
528 underscores(ctx, modname));
529 } else if (streq(cmd, "options")) {
530 char *modname = strtok_r(NULL, "\t ", &saveptr);
531
532 if (modname == NULL)
533 goto syntax_error;
534
535 kmod_config_add_options(config,
536 underscores(ctx, modname),
537 strtok_r(NULL, "\0", &saveptr));
538 } else if (streq(cmd, "install")) {
539 char *modname = strtok_r(NULL, "\t ", &saveptr);
540
541 if (modname == NULL)
542 goto syntax_error;
543
544 kmod_config_add_command(config,
545 underscores(ctx, modname),
546 strtok_r(NULL, "\0", &saveptr),
547 cmd, &config->install_commands);
548 } else if (streq(cmd, "remove")) {
549 char *modname = strtok_r(NULL, "\t ", &saveptr);
550
551 if (modname == NULL)
552 goto syntax_error;
553
554 kmod_config_add_command(config,
555 underscores(ctx, modname),
556 strtok_r(NULL, "\0", &saveptr),
557 cmd, &config->remove_commands);
558 } else if (streq(cmd, "softdep")) {
559 char *modname = strtok_r(NULL, "\t ", &saveptr);
560
561 if (modname == NULL)
562 goto syntax_error;
563
564 kmod_config_add_softdep(config,
565 underscores(ctx, modname),
566 strtok_r(NULL, "\0", &saveptr));
567 } else if (streq(cmd, "include")
568 || streq(cmd, "config")) {
569 INFO(ctx, "%s: command %s not implemented yet\n",
570 filename, cmd);
571 } else {
572 syntax_error:
573 ERR(ctx, "%s line %u: ignoring bad line starting with '%s'\n",
574 filename, linenum, cmd);
575 }
576
577 done_next:
578 free(line);
579 }
580
581 fclose(fp);
582
583 return 0;
584 }
585
586 void kmod_config_free(struct kmod_config *config)
587 {
588 while (config->aliases)
589 kmod_config_free_alias(config, config->aliases);
590
591 while (config->blacklists)
592 kmod_config_free_blacklist(config, config->blacklists);
593
594 while (config->options)
595 kmod_config_free_options(config, config->options);
596
597 while (config->install_commands) {
598 kmod_config_free_command(config, config->install_commands,
599 &config->install_commands);
600 }
601
602 while (config->remove_commands) {
603 kmod_config_free_command(config, config->remove_commands,
604 &config->remove_commands);
605 }
606
607 while (config->softdeps)
608 kmod_config_free_softdep(config, config->softdeps);
609
610 for (; config->paths != NULL;
611 config->paths = kmod_list_remove(config->paths))
612 free(config->paths->data);
613
614 free(config);
615 }
616
617 static bool conf_files_filter_out(struct kmod_ctx *ctx, DIR *d,
618 const char *path, const char *fn)
619 {
620 size_t len = strlen(fn);
621 struct stat st;
622
623 if (fn[0] == '.')
624 return true;
625
626 if (len < 6 || (!streq(&fn[len - 5], ".conf")
627 && !streq(&fn[len - 6], ".alias")))
628 return true;
629
630 fstatat(dirfd(d), fn, &st, 0);
631
632 if (S_ISDIR(st.st_mode)) {
633 ERR(ctx, "Directories inside directories are not supported: "
634 "%s/%s\n", path, fn);
635 return true;
636 }
637
638 return false;
639 }
640
641 struct conf_file {
642 const char *path;
643 bool is_single;
644 char name[];
645 };
646
647 static int conf_files_insert_sorted(struct kmod_ctx *ctx,
648 struct kmod_list **list,
649 const char *path, const char *name)
650 {
651 struct kmod_list *lpos, *tmp;
652 struct conf_file *cf;
653 size_t namelen;
654 int cmp = -1;
655 bool is_single = false;
656
657 if (name == NULL) {
658 name = basename(path);
659 is_single = true;
660 }
661
662 kmod_list_foreach(lpos, *list) {
663 cf = lpos->data;
664
665 if ((cmp = strcmp(name, cf->name)) <= 0)
666 break;
667 }
668
669 if (cmp == 0) {
670 DBG(ctx, "Ignoring duplicate config file: %s/%s\n", path,
671 name);
672 return -EEXIST;
673 }
674
675 namelen = strlen(name);
676 cf = malloc(sizeof(*cf) + namelen + 1);
677 if (cf == NULL)
678 return -ENOMEM;
679
680 memcpy(cf->name, name, namelen + 1);
681 cf->path = path;
682 cf->is_single = is_single;
683
684 if (lpos == NULL)
685 tmp = kmod_list_append(*list, cf);
686 else if (lpos == *list)
687 tmp = kmod_list_prepend(*list, cf);
688 else
689 tmp = kmod_list_insert_before(lpos, cf);
690
691 if (tmp == NULL) {
692 free(cf);
693 return -ENOMEM;
694 }
695
696 if (lpos == NULL || lpos == *list)
697 *list = tmp;
698
699 return 0;
700 }
701
702 /*
703 * Insert configuration files in @list, ignoring duplicates
704 */
705 static int conf_files_list(struct kmod_ctx *ctx, struct kmod_list **list,
706 const char *path,
707 unsigned long long *path_stamp)
708 {
709 DIR *d;
710 int err;
711 struct stat st;
712
713 if (stat(path, &st) != 0) {
714 err = -errno;
715 DBG(ctx, "could not stat '%s': %m\n", path);
716 return err;
717 }
718
719 *path_stamp = ts_usec(&st.st_mtim);
720
721 if (S_ISREG(st.st_mode)) {
722 conf_files_insert_sorted(ctx, list, path, NULL);
723 return 0;
724 } if (!S_ISDIR(st.st_mode)) {
725 ERR(ctx, "unsupported file mode %s: %#x\n",
726 path, st.st_mode);
727 return -EINVAL;
728 }
729
730 d = opendir(path);
731 if (d == NULL) {
732 ERR(ctx, "%m\n");
733 return -EINVAL;
734 }
735
736 for (;;) {
737 struct dirent ent, *entp;
738
739 err = readdir_r(d, &ent, &entp);
740 if (err != 0) {
741 ERR(ctx, "reading entry %s\n", strerror(-err));
742 goto fail_read;
743 }
744
745 if (entp == NULL)
746 break;
747
748 if (conf_files_filter_out(ctx, d, path, entp->d_name))
749 continue;
750
751 conf_files_insert_sorted(ctx, list, path, entp->d_name);
752 }
753
754 closedir(d);
755 return 0;
756
757 fail_read:
758 closedir(d);
759 return err;
760 }
761
762 int kmod_config_new(struct kmod_ctx *ctx, struct kmod_config **p_config,
763 const char * const *config_paths)
764 {
765 struct kmod_config *config;
766 struct kmod_list *list = NULL;
767 struct kmod_list *path_list = NULL;
768 size_t i;
769
770 for (i = 0; config_paths[i] != NULL; i++) {
771 const char *path = config_paths[i];
772 unsigned long long path_stamp = 0;
773 size_t pathlen;
774 struct kmod_list *tmp;
775 struct kmod_config_path *cf;
776
777 if (conf_files_list(ctx, &list, path, &path_stamp) < 0)
778 continue;
779
780 pathlen = strlen(path) + 1;
781 cf = malloc(sizeof(*cf) + pathlen);
782 if (cf == NULL)
783 goto oom;
784
785 cf->stamp = path_stamp;
786 memcpy(cf->path, path, pathlen);
787
788 tmp = kmod_list_append(path_list, cf);
789 if (tmp == NULL)
790 goto oom;
791 path_list = tmp;
792 }
793
794 *p_config = config = calloc(1, sizeof(struct kmod_config));
795 if (config == NULL)
796 goto oom;
797
798 config->paths = path_list;
799
800 for (; list != NULL; list = kmod_list_remove(list)) {
801 char fn[PATH_MAX];
802 struct conf_file *cf = list->data;
803 int fd;
804
805 if (cf->is_single)
806 strcpy(fn, cf->path);
807 else
808 snprintf(fn, sizeof(fn),"%s/%s", cf->path,
809 cf->name);
810
811 fd = open(fn, O_RDONLY|O_CLOEXEC);
812 DBG(ctx, "parsing file '%s' fd=%d\n", fn, fd);
813
814 if (fd >= 0)
815 kmod_config_parse(config, fd, fn);
816
817 free(cf);
818 }
819
820 kmod_config_parse_kcmdline(config);
821
822 return 0;
823
824 oom:
825 for (; list != NULL; list = kmod_list_remove(list))
826 free(list->data);
827
828 for (; path_list != NULL; path_list = kmod_list_remove(path_list))
829 free(path_list->data);
830
831 return -ENOMEM;
832 }