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         if (fd < 0) {
 448                 err = -errno;
 449                 DBG(config->ctx, "could not open '/proc/cmdline' for reading: %m\n");
 450                 return err;
 451         }
 452
 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 '=':
 474                         if (param != NULL)
 475                                 value = p + 1;
 476                         break;
 477                 }
 478         }
 479
 480         *p = '\0';
 481         kcmdline_parse_result(config, modname, param, value);
 482
 483         return 0;
 484 }
 485
 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)
 492 {
 493         struct kmod_ctx *ctx = config->ctx;
 494         char *line;
 495         FILE *fp;
 496         unsigned int linenum = 0;
 497         int err;
 498
 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         }
 506
 507         while ((line = getline_wrapped(fp, &linenum)) != NULL) {
 508                 char *cmd, *saveptr;
 509
 510                 if (line[0] == '\0' || line[0] == '#')
 511                         goto done_next;
 512
 513                 cmd = strtok_r(line, "\t ", &saveptr);
 514                 if (cmd == NULL)
 515                         goto done_next;
 516
 517                 if (streq(cmd, "alias")) {
 518                         char *alias = strtok_r(NULL, "\t ", &saveptr);
 519                         char *modname = strtok_r(NULL, "\t ", &saveptr);
 520
 521                         if (alias == NULL || modname == NULL)
 522                                 goto syntax_error;
 523
 524                         kmod_config_add_alias(config,
 525                                                 underscores(ctx, alias),
 526                                                 underscores(ctx, modname));
 527                 } else if (streq(cmd, "blacklist")) {
 528                         char *modname = strtok_r(NULL, "\t ", &saveptr);
 529
 530                         if (modname == NULL)
 531                                 goto syntax_error;
 532
 533                         kmod_config_add_blacklist(config,
 534                                                 underscores(ctx, modname));
 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));
 544                 } else if (streq(cmd, "install")) {
 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);
 554                 } else if (streq(cmd, "remove")) {
 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);
 564                 } else if (streq(cmd, "softdep")) {
 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));
 573                 } else if (streq(cmd, "include")
 574                                 || streq(cmd, "config")) {
 575                         INFO(ctx, "%s: command %s not implemented yet\n",
 576                                                                 filename, cmd);
 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
 592 void kmod_config_free(struct kmod_config *config)
 593 {
 594         while (config->aliases)
 595                 kmod_config_free_alias(config, config->aliases);
 596
 597         while (config->blacklists)
 598                 kmod_config_free_blacklist(config, config->blacklists);
 599
 600         while (config->options)
 601                 kmod_config_free_options(config, config->options);
 602
 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
 613         while (config->softdeps)
 614                 kmod_config_free_softdep(config, config->softdeps);
 615
 616         for (; config->paths != NULL;
 617                                 config->paths = kmod_list_remove(config->paths))
 618                 free(config->paths->data);
 619
 620         free(config);
 621 }
 622
 623 static bool conf_files_filter_out(struct kmod_ctx *ctx, DIR *d,
 624                                         const char *path, const char *fn)
 625 {
 626         size_t len = strlen(fn);
 627         struct stat st;
 628
 629         if (fn[0] == '.')
 630                 return true;
 631
 632         if (len < 6 || (!streq(&fn[len - 5], ".conf")
 633                                 && !streq(&fn[len - 6], ".alias")))
 634                 return true;
 635
 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);
 641                 return true;
 642         }
 643
 644         return false;
 645 }
 646
 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
 708 /*
 709  * Insert configuration files in @list, ignoring duplicates
 710  */
 711 static int conf_files_list(struct kmod_ctx *ctx, struct kmod_list **list,
 712                                                 const char *path,
 713                                                 unsigned long long *path_stamp)
 714 {
 715         DIR *d;
 716         int err;
 717         struct stat st;
 718
 719         if (stat(path, &st) != 0) {
 720                 err = -errno;
 721                 DBG(ctx, "could not stat '%s': %m\n", path);
 722                 return err;
 723         }
 724
 725         *path_stamp = ts_usec(&st.st_mtim);
 726
 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         }
 735
 736         d = opendir(path);
 737         if (d == NULL) {
 738                 ERR(ctx, "%m\n");
 739                 return -EINVAL;
 740         }
 741
 742         for (;;) {
 743                 struct dirent ent, *entp;
 744
 745                 err = readdir_r(d, &ent, &entp);
 746                 if (err != 0) {
 747                         ERR(ctx, "reading entry %s\n", strerror(-err));
 748                         goto fail_read;
 749                 }
 750
 751                 if (entp == NULL)
 752                         break;
 753
 754                 if (conf_files_filter_out(ctx, d, path, entp->d_name))
 755                         continue;
 756
 757                 conf_files_insert_sorted(ctx, list, path, entp->d_name);
 758         }
 759
 760         closedir(d);
 761         return 0;
 762
 763 fail_read:
 764         closedir(d);
 765         return err;
 766 }
 767
 768 int kmod_config_new(struct kmod_ctx *ctx, struct kmod_config **p_config,
 769                                         const char * const *config_paths)
 770 {
 771         struct kmod_config *config;
 772         struct kmod_list *list = NULL;
 773         struct kmod_list *path_list = NULL;
 774         size_t i;
 775
 776         for (i = 0; config_paths[i] != NULL; i++) {
 777                 const char *path = config_paths[i];
 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;
 790
 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;
 798         }
 799
 800         *p_config = config = calloc(1, sizeof(struct kmod_config));
 801         if (config == NULL)
 802                 goto oom;
 803
 804         config->paths = path_list;
 805         config->ctx = ctx;
 806
 807         for (; list != NULL; list = kmod_list_remove(list)) {
 808                 char fn[PATH_MAX];
 809                 struct conf_file *cf = list->data;
 810                 int fd;
 811
 812                 if (cf->is_single)
 813                         strcpy(fn, cf->path);
 814                 else
 815                         snprintf(fn, sizeof(fn),"%s/%s", cf->path,
 816                                         cf->name);
 817
 818                 fd = open(fn, O_RDONLY|O_CLOEXEC);
 819                 DBG(ctx, "parsing file '%s' fd=%d\n", fn, fd);
 820
 821                 if (fd >= 0)
 822                         kmod_config_parse(config, fd, fn);
 823
 824                 free(cf);
 825         }
 826
 827         kmod_config_parse_kcmdline(config);
 828
 829         return 0;
 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;
 839 }