]>
Commit | Line | Data |
---|---|---|
7c2ab358 LDM |
1 | /* |
2 | * libkmod - interface to kernel module operations | |
3 | * | |
a66a6a99 | 4 | * Copyright (C) 2011-2012 ProFUSION embedded systems |
7c2ab358 LDM |
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 | |
cb451f35 LDM |
8 | * License as published by the Free Software Foundation; either |
9 | * version 2.1 of the License, or (at your option) any later version. | |
7c2ab358 LDM |
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 | ||
7c2ab358 LDM |
36 | struct kmod_alias { |
37 | char *name; | |
43c29d10 | 38 | char modname[]; |
7c2ab358 LDM |
39 | }; |
40 | ||
615c42be LDM |
41 | struct kmod_options { |
42 | char *options; | |
43 | char modname[]; | |
44 | }; | |
45 | ||
a5cce6d6 LDM |
46 | struct kmod_command { |
47 | char *command; | |
48 | char modname[]; | |
49 | }; | |
50 | ||
1c522600 GSB |
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 | ||
c1c9c446 LDM |
59 | const char *kmod_blacklist_get_modname(const struct kmod_list *l) |
60 | { | |
61 | return l->data; | |
62 | } | |
63 | ||
b0ef19f7 | 64 | const char *kmod_alias_get_name(const struct kmod_list *l) { |
1ce08a56 | 65 | const struct kmod_alias *alias = l->data; |
b0ef19f7 LDM |
66 | return alias->name; |
67 | } | |
68 | ||
69 | const char *kmod_alias_get_modname(const struct kmod_list *l) { | |
1ce08a56 | 70 | const struct kmod_alias *alias = l->data; |
b0ef19f7 LDM |
71 | return alias->modname; |
72 | } | |
73 | ||
bd3f5535 GSB |
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 | ||
1c522600 GSB |
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 | ||
a5cce6d6 LDM |
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 | ||
e5a7f6ac | 122 | DBG(config->ctx, "modname='%s' cmd='%s %s'\n", modname, command_name, |
a5cce6d6 LDM |
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 | ||
615c42be LDM |
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 | ||
23c0d012 | 165 | DBG(config->ctx, "modname='%s' options='%s'\n", modname, options); |
615c42be LDM |
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 | ||
c35347f1 LDM |
191 | static void kmod_config_free_options(struct kmod_config *config, |
192 | struct kmod_list *l) | |
615c42be LDM |
193 | { |
194 | struct kmod_options *opt = l->data; | |
195 | ||
196 | free(opt); | |
197 | ||
198 | config->options = kmod_list_remove(l); | |
199 | } | |
200 | ||
d13e606f | 201 | static int kmod_config_add_alias(struct kmod_config *config, |
c35347f1 | 202 | const char *name, const char *modname) |
7c2ab358 LDM |
203 | { |
204 | struct kmod_alias *alias; | |
d13e606f | 205 | struct kmod_list *list; |
43c29d10 | 206 | size_t namelen = strlen(name) + 1, modnamelen = strlen(modname) + 1; |
7c2ab358 | 207 | |
d13e606f | 208 | DBG(config->ctx, "name=%s modname=%s\n", name, modname); |
7c2ab358 | 209 | |
43c29d10 | 210 | alias = malloc(sizeof(*alias) + namelen + modnamelen); |
d13e606f GSB |
211 | if (!alias) |
212 | goto oom_error_init; | |
28c175ed | 213 | |
43c29d10 GSB |
214 | alias->name = sizeof(*alias) + modnamelen + (char *)alias; |
215 | ||
216 | memcpy(alias->modname, modname, modnamelen); | |
217 | memcpy(alias->name, name, namelen); | |
7c2ab358 | 218 | |
d13e606f GSB |
219 | list = kmod_list_append(config->aliases, alias); |
220 | if (!list) | |
221 | goto oom_error; | |
28c175ed | 222 | |
d13e606f GSB |
223 | config->aliases = list; |
224 | return 0; | |
225 | ||
226 | oom_error: | |
d13e606f GSB |
227 | free(alias); |
228 | oom_error_init: | |
229 | ERR(config->ctx, "out-of-memory name=%s modname=%s\n", name, modname); | |
230 | return -ENOMEM; | |
7c2ab358 LDM |
231 | } |
232 | ||
c35347f1 LDM |
233 | static void kmod_config_free_alias(struct kmod_config *config, |
234 | struct kmod_list *l) | |
7c2ab358 LDM |
235 | { |
236 | struct kmod_alias *alias = l->data; | |
237 | ||
7c2ab358 LDM |
238 | free(alias); |
239 | ||
d13e606f | 240 | config->aliases = kmod_list_remove(l); |
7c2ab358 LDM |
241 | } |
242 | ||
d13e606f | 243 | static int kmod_config_add_blacklist(struct kmod_config *config, |
c35347f1 | 244 | const char *modname) |
81cf2060 | 245 | { |
81cf2060 | 246 | char *p; |
d13e606f | 247 | struct kmod_list *list; |
81cf2060 | 248 | |
d13e606f | 249 | DBG(config->ctx, "modname=%s\n", modname); |
81cf2060 LDM |
250 | |
251 | p = strdup(modname); | |
d13e606f GSB |
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; | |
81cf2060 | 260 | |
d13e606f GSB |
261 | oom_error: |
262 | free(p); | |
263 | oom_error_init: | |
264 | ERR(config->ctx, "out-of-memory modname=%s\n", modname); | |
265 | return -ENOMEM; | |
81cf2060 LDM |
266 | } |
267 | ||
d13e606f | 268 | static void kmod_config_free_blacklist(struct kmod_config *config, |
81cf2060 LDM |
269 | struct kmod_list *l) |
270 | { | |
271 | free(l->data); | |
d13e606f | 272 | config->blacklists = kmod_list_remove(l); |
81cf2060 LDM |
273 | } |
274 | ||
1c522600 GSB |
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 | ||
1684e440 LDM |
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 | ||
79e5ea91 | 446 | fd = open("/proc/cmdline", O_RDONLY|O_CLOEXEC); |
dd1cf10f LDM |
447 | if (fd < 0) { |
448 | err = -errno; | |
449 | DBG(config->ctx, "could not open '/proc/cmdline' for reading: %m\n"); | |
450 | return err; | |
451 | } | |
452 | ||
1684e440 LDM |
453 | err = read_str_safe(fd, buf, sizeof(buf)); |
454 | close(fd); | |
455 | if (err < 0) { | |
456 | ERR(config->ctx, "could not read from '/proc/cmdline': %s\n", | |
457 | strerror(-err)); | |
458 | return err; | |
459 | } | |
460 | ||
461 | for (p = buf, modname = buf; *p != '\0' && *p != '\n'; p++) { | |
462 | switch (*p) { | |
463 | case ' ': | |
464 | *p = '\0'; | |
465 | kcmdline_parse_result(config, modname, param, value); | |
466 | param = value = NULL; | |
467 | modname = p + 1; | |
468 | break; | |
469 | case '.': | |
470 | *p = '\0'; | |
471 | param = p + 1; | |
472 | break; | |
473 | case '=': | |
135bffd6 LDM |
474 | if (param != NULL) |
475 | value = p + 1; | |
1684e440 LDM |
476 | break; |
477 | } | |
478 | } | |
479 | ||
480 | *p = '\0'; | |
481 | kcmdline_parse_result(config, modname, param, value); | |
482 | ||
483 | return 0; | |
484 | } | |
485 | ||
b7b7ac29 LDM |
486 | /* |
487 | * Take an fd and own it. It will be closed on return. filename is used only | |
488 | * for debug messages | |
489 | */ | |
490 | static int kmod_config_parse(struct kmod_config *config, int fd, | |
491 | const char *filename) | |
7c2ab358 | 492 | { |
d13e606f | 493 | struct kmod_ctx *ctx = config->ctx; |
7c2ab358 LDM |
494 | char *line; |
495 | FILE *fp; | |
759214fa | 496 | unsigned int linenum = 0; |
b7b7ac29 | 497 | int err; |
7c2ab358 | 498 | |
b7b7ac29 LDM |
499 | fp = fdopen(fd, "r"); |
500 | if (fp == NULL) { | |
501 | err = -errno; | |
502 | ERR(config->ctx, "fd %d: %m", fd); | |
503 | close(fd); | |
504 | return err; | |
505 | } | |
7c2ab358 LDM |
506 | |
507 | while ((line = getline_wrapped(fp, &linenum)) != NULL) { | |
c11e62bf | 508 | char *cmd, *saveptr; |
7c2ab358 LDM |
509 | |
510 | if (line[0] == '\0' || line[0] == '#') | |
511 | goto done_next; | |
512 | ||
c11e62bf | 513 | cmd = strtok_r(line, "\t ", &saveptr); |
7c2ab358 LDM |
514 | if (cmd == NULL) |
515 | goto done_next; | |
516 | ||
877e80cd | 517 | if (streq(cmd, "alias")) { |
c11e62bf LDM |
518 | char *alias = strtok_r(NULL, "\t ", &saveptr); |
519 | char *modname = strtok_r(NULL, "\t ", &saveptr); | |
7c2ab358 LDM |
520 | |
521 | if (alias == NULL || modname == NULL) | |
522 | goto syntax_error; | |
523 | ||
d13e606f | 524 | kmod_config_add_alias(config, |
30be7513 LDM |
525 | underscores(ctx, alias), |
526 | underscores(ctx, modname)); | |
877e80cd | 527 | } else if (streq(cmd, "blacklist")) { |
c11e62bf | 528 | char *modname = strtok_r(NULL, "\t ", &saveptr); |
81cf2060 LDM |
529 | |
530 | if (modname == NULL) | |
531 | goto syntax_error; | |
532 | ||
d13e606f | 533 | kmod_config_add_blacklist(config, |
2295acc5 | 534 | underscores(ctx, modname)); |
615c42be LDM |
535 | } else if (streq(cmd, "options")) { |
536 | char *modname = strtok_r(NULL, "\t ", &saveptr); | |
537 | ||
538 | if (modname == NULL) | |
539 | goto syntax_error; | |
540 | ||
541 | kmod_config_add_options(config, | |
542 | underscores(ctx, modname), | |
543 | strtok_r(NULL, "\0", &saveptr)); | |
40ee8dad | 544 | } else if (streq(cmd, "install")) { |
a5cce6d6 LDM |
545 | char *modname = strtok_r(NULL, "\t ", &saveptr); |
546 | ||
547 | if (modname == NULL) | |
548 | goto syntax_error; | |
549 | ||
550 | kmod_config_add_command(config, | |
551 | underscores(ctx, modname), | |
552 | strtok_r(NULL, "\0", &saveptr), | |
553 | cmd, &config->install_commands); | |
40ee8dad | 554 | } else if (streq(cmd, "remove")) { |
a5cce6d6 LDM |
555 | char *modname = strtok_r(NULL, "\t ", &saveptr); |
556 | ||
557 | if (modname == NULL) | |
558 | goto syntax_error; | |
559 | ||
560 | kmod_config_add_command(config, | |
561 | underscores(ctx, modname), | |
562 | strtok_r(NULL, "\0", &saveptr), | |
563 | cmd, &config->remove_commands); | |
40ee8dad | 564 | } else if (streq(cmd, "softdep")) { |
1c522600 GSB |
565 | char *modname = strtok_r(NULL, "\t ", &saveptr); |
566 | ||
567 | if (modname == NULL) | |
568 | goto syntax_error; | |
569 | ||
570 | kmod_config_add_softdep(config, | |
571 | underscores(ctx, modname), | |
572 | strtok_r(NULL, "\0", &saveptr)); | |
615c42be | 573 | } else if (streq(cmd, "include") |
877e80cd | 574 | || streq(cmd, "config")) { |
81cf2060 LDM |
575 | INFO(ctx, "%s: command %s not implemented yet\n", |
576 | filename, cmd); | |
7c2ab358 LDM |
577 | } else { |
578 | syntax_error: | |
579 | ERR(ctx, "%s line %u: ignoring bad line starting with '%s'\n", | |
580 | filename, linenum, cmd); | |
581 | } | |
582 | ||
583 | done_next: | |
584 | free(line); | |
585 | } | |
586 | ||
587 | fclose(fp); | |
588 | ||
589 | return 0; | |
590 | } | |
591 | ||
d13e606f | 592 | void kmod_config_free(struct kmod_config *config) |
7c2ab358 LDM |
593 | { |
594 | while (config->aliases) | |
d13e606f | 595 | kmod_config_free_alias(config, config->aliases); |
81cf2060 LDM |
596 | |
597 | while (config->blacklists) | |
d13e606f GSB |
598 | kmod_config_free_blacklist(config, config->blacklists); |
599 | ||
615c42be LDM |
600 | while (config->options) |
601 | kmod_config_free_options(config, config->options); | |
602 | ||
a5cce6d6 LDM |
603 | while (config->install_commands) { |
604 | kmod_config_free_command(config, config->install_commands, | |
605 | &config->install_commands); | |
606 | } | |
607 | ||
608 | while (config->remove_commands) { | |
609 | kmod_config_free_command(config, config->remove_commands, | |
610 | &config->remove_commands); | |
611 | } | |
612 | ||
1c522600 GSB |
613 | while (config->softdeps) |
614 | kmod_config_free_softdep(config, config->softdeps); | |
615 | ||
b6a4dfb1 LDM |
616 | for (; config->paths != NULL; |
617 | config->paths = kmod_list_remove(config->paths)) | |
618 | free(config->paths->data); | |
619 | ||
d13e606f | 620 | free(config); |
7c2ab358 LDM |
621 | } |
622 | ||
98c80f44 LDM |
623 | static bool conf_files_filter_out(struct kmod_ctx *ctx, DIR *d, |
624 | const char *path, const char *fn) | |
7c2ab358 LDM |
625 | { |
626 | size_t len = strlen(fn); | |
98c80f44 | 627 | struct stat st; |
7c2ab358 LDM |
628 | |
629 | if (fn[0] == '.') | |
8f767e2d | 630 | return true; |
7c2ab358 | 631 | |
877e80cd | 632 | if (len < 6 || (!streq(&fn[len - 5], ".conf") |
9070b117 | 633 | && !streq(&fn[len - 6], ".alias"))) |
8f767e2d | 634 | return true; |
7c2ab358 | 635 | |
98c80f44 LDM |
636 | fstatat(dirfd(d), fn, &st, 0); |
637 | ||
638 | if (S_ISDIR(st.st_mode)) { | |
639 | ERR(ctx, "Directories inside directories are not supported: " | |
640 | "%s/%s\n", path, fn); | |
8f767e2d | 641 | return true; |
98c80f44 LDM |
642 | } |
643 | ||
8f767e2d | 644 | return false; |
7c2ab358 LDM |
645 | } |
646 | ||
7fe5f7ab LDM |
647 | struct conf_file { |
648 | const char *path; | |
649 | bool is_single; | |
650 | char name[]; | |
651 | }; | |
652 | ||
653 | static int conf_files_insert_sorted(struct kmod_ctx *ctx, | |
654 | struct kmod_list **list, | |
655 | const char *path, const char *name) | |
656 | { | |
657 | struct kmod_list *lpos, *tmp; | |
658 | struct conf_file *cf; | |
659 | size_t namelen; | |
660 | int cmp = -1; | |
661 | bool is_single = false; | |
662 | ||
663 | if (name == NULL) { | |
664 | name = basename(path); | |
665 | is_single = true; | |
666 | } | |
667 | ||
668 | kmod_list_foreach(lpos, *list) { | |
669 | cf = lpos->data; | |
670 | ||
671 | if ((cmp = strcmp(name, cf->name)) <= 0) | |
672 | break; | |
673 | } | |
674 | ||
675 | if (cmp == 0) { | |
676 | DBG(ctx, "Ignoring duplicate config file: %s/%s\n", path, | |
677 | name); | |
678 | return -EEXIST; | |
679 | } | |
680 | ||
681 | namelen = strlen(name); | |
682 | cf = malloc(sizeof(*cf) + namelen + 1); | |
683 | if (cf == NULL) | |
684 | return -ENOMEM; | |
685 | ||
686 | memcpy(cf->name, name, namelen + 1); | |
687 | cf->path = path; | |
688 | cf->is_single = is_single; | |
689 | ||
690 | if (lpos == NULL) | |
691 | tmp = kmod_list_append(*list, cf); | |
692 | else if (lpos == *list) | |
693 | tmp = kmod_list_prepend(*list, cf); | |
694 | else | |
695 | tmp = kmod_list_insert_before(lpos, cf); | |
696 | ||
697 | if (tmp == NULL) { | |
698 | free(cf); | |
699 | return -ENOMEM; | |
700 | } | |
701 | ||
702 | if (lpos == NULL || lpos == *list) | |
703 | *list = tmp; | |
704 | ||
705 | return 0; | |
706 | } | |
707 | ||
4782396c | 708 | /* |
7fe5f7ab | 709 | * Insert configuration files in @list, ignoring duplicates |
4782396c | 710 | */ |
7fe5f7ab | 711 | static int conf_files_list(struct kmod_ctx *ctx, struct kmod_list **list, |
b6a4dfb1 LDM |
712 | const char *path, |
713 | unsigned long long *path_stamp) | |
7c2ab358 | 714 | { |
7c2ab358 LDM |
715 | DIR *d; |
716 | int err; | |
7fe5f7ab | 717 | struct stat st; |
7c2ab358 | 718 | |
7fe5f7ab LDM |
719 | if (stat(path, &st) != 0) { |
720 | err = -errno; | |
721 | DBG(ctx, "could not stat '%s': %m\n", path); | |
722 | return err; | |
723 | } | |
724 | ||
b6a4dfb1 LDM |
725 | *path_stamp = ts_usec(&st.st_mtim); |
726 | ||
7fe5f7ab LDM |
727 | if (S_ISREG(st.st_mode)) { |
728 | conf_files_insert_sorted(ctx, list, path, NULL); | |
729 | return 0; | |
730 | } if (!S_ISDIR(st.st_mode)) { | |
731 | ERR(ctx, "unsupported file mode %s: %#x\n", | |
732 | path, st.st_mode); | |
733 | return -EINVAL; | |
734 | } | |
1c250ec1 | 735 | |
7c2ab358 LDM |
736 | d = opendir(path); |
737 | if (d == NULL) { | |
7c2ab358 | 738 | ERR(ctx, "%m\n"); |
7fe5f7ab | 739 | return -EINVAL; |
7c2ab358 LDM |
740 | } |
741 | ||
742 | for (;;) { | |
743 | struct dirent ent, *entp; | |
7c2ab358 LDM |
744 | |
745 | err = readdir_r(d, &ent, &entp); | |
746 | if (err != 0) { | |
b7b7ac29 LDM |
747 | ERR(ctx, "reading entry %s\n", strerror(-err)); |
748 | goto fail_read; | |
7c2ab358 LDM |
749 | } |
750 | ||
751 | if (entp == NULL) | |
752 | break; | |
753 | ||
8f767e2d | 754 | if (conf_files_filter_out(ctx, d, path, entp->d_name)) |
7c2ab358 LDM |
755 | continue; |
756 | ||
7fe5f7ab | 757 | conf_files_insert_sorted(ctx, list, path, entp->d_name); |
b7b7ac29 | 758 | } |
7c2ab358 | 759 | |
7fe5f7ab LDM |
760 | closedir(d); |
761 | return 0; | |
7c2ab358 | 762 | |
b7b7ac29 | 763 | fail_read: |
b7b7ac29 | 764 | closedir(d); |
7fe5f7ab | 765 | return err; |
7c2ab358 LDM |
766 | } |
767 | ||
c35347f1 LDM |
768 | int kmod_config_new(struct kmod_ctx *ctx, struct kmod_config **p_config, |
769 | const char * const *config_paths) | |
7c2ab358 | 770 | { |
d13e606f | 771 | struct kmod_config *config; |
7fe5f7ab | 772 | struct kmod_list *list = NULL; |
b6a4dfb1 | 773 | struct kmod_list *path_list = NULL; |
b7b7ac29 | 774 | size_t i; |
7c2ab358 | 775 | |
cb8d4d3e GSB |
776 | for (i = 0; config_paths[i] != NULL; i++) { |
777 | const char *path = config_paths[i]; | |
b6a4dfb1 LDM |
778 | unsigned long long path_stamp = 0; |
779 | size_t pathlen; | |
780 | struct kmod_list *tmp; | |
781 | struct kmod_config_path *cf; | |
782 | ||
783 | if (conf_files_list(ctx, &list, path, &path_stamp) < 0) | |
784 | continue; | |
785 | ||
786 | pathlen = strlen(path) + 1; | |
787 | cf = malloc(sizeof(*cf) + pathlen); | |
788 | if (cf == NULL) | |
789 | goto oom; | |
7c2ab358 | 790 | |
b6a4dfb1 LDM |
791 | cf->stamp = path_stamp; |
792 | memcpy(cf->path, path, pathlen); | |
793 | ||
794 | tmp = kmod_list_append(path_list, cf); | |
795 | if (tmp == NULL) | |
796 | goto oom; | |
797 | path_list = tmp; | |
7fe5f7ab | 798 | } |
cb8d4d3e | 799 | |
b6a4dfb1 LDM |
800 | *p_config = config = calloc(1, sizeof(struct kmod_config)); |
801 | if (config == NULL) | |
802 | goto oom; | |
803 | ||
804 | config->paths = path_list; | |
29b69c0b | 805 | config->ctx = ctx; |
b6a4dfb1 | 806 | |
7fe5f7ab LDM |
807 | for (; list != NULL; list = kmod_list_remove(list)) { |
808 | char fn[PATH_MAX]; | |
809 | struct conf_file *cf = list->data; | |
810 | int fd; | |
cb8d4d3e | 811 | |
7fe5f7ab LDM |
812 | if (cf->is_single) |
813 | strcpy(fn, cf->path); | |
814 | else | |
815 | snprintf(fn, sizeof(fn),"%s/%s", cf->path, | |
816 | cf->name); | |
7c2ab358 | 817 | |
7fe5f7ab LDM |
818 | fd = open(fn, O_RDONLY|O_CLOEXEC); |
819 | DBG(ctx, "parsing file '%s' fd=%d\n", fn, fd); | |
7c2ab358 | 820 | |
7fe5f7ab LDM |
821 | if (fd >= 0) |
822 | kmod_config_parse(config, fd, fn); | |
7c2ab358 | 823 | |
7fe5f7ab | 824 | free(cf); |
7c2ab358 LDM |
825 | } |
826 | ||
1684e440 LDM |
827 | kmod_config_parse_kcmdline(config); |
828 | ||
b7b7ac29 | 829 | return 0; |
b6a4dfb1 LDM |
830 | |
831 | oom: | |
832 | for (; list != NULL; list = kmod_list_remove(list)) | |
833 | free(list->data); | |
834 | ||
835 | for (; path_list != NULL; path_list = kmod_list_remove(path_list)) | |
836 | free(path_list->data); | |
837 | ||
838 | return -ENOMEM; | |
7c2ab358 | 839 | } |