libkmod/libkmod-config.c

   1 /*
   2  * libkmod - interface to kernel module operations
   3  *
   4  * Copyright (C) 2011-2013  ProFUSION embedded systems
   5  * Copyright (C) 2013  Intel Corporation. All rights reserved.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <ctype.h>
  22 #include <dirent.h>
  23 #include <errno.h>
  24 #include <stdarg.h>
  25 #include <stddef.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30 #include <sys/stat.h>
  31 #include <sys/types.h>
  32
  33 #include <shared/util.h>
  34
  35 #include "libkmod.h"
  36 #include "libkmod-internal.h"
  37
  38 struct kmod_alias {
  39         char *name;
  40         char modname[];
  41 };
  42
  43 struct kmod_options {
  44         char *options;
  45         char modname[];
  46 };
  47
  48 struct kmod_command {
  49         char *command;
  50         char modname[];
  51 };
  52
  53 struct kmod_softdep {
  54         char *name;
  55         const char **pre;
  56         const char **post;
  57         unsigned int n_pre;
  58         unsigned int n_post;
  59 };
  60
  61 const char *kmod_blacklist_get_modname(const struct kmod_list *l)
  62 {
  63         return l->data;
  64 }
  65
  66 const char *kmod_alias_get_name(const struct kmod_list *l) {
  67         const struct kmod_alias *alias = l->data;
  68         return alias->name;
  69 }
  70
  71 const char *kmod_alias_get_modname(const struct kmod_list *l) {
  72         const struct kmod_alias *alias = l->data;
  73         return alias->modname;
  74 }
  75
  76 const char *kmod_option_get_options(const struct kmod_list *l) {
  77         const struct kmod_options *alias = l->data;
  78         return alias->options;
  79 }
  80
  81 const char *kmod_option_get_modname(const struct kmod_list *l) {
  82         const struct kmod_options *alias = l->data;
  83         return alias->modname;
  84 }
  85
  86 const char *kmod_command_get_command(const struct kmod_list *l) {
  87         const struct kmod_command *alias = l->data;
  88         return alias->command;
  89 }
  90
  91 const char *kmod_command_get_modname(const struct kmod_list *l) {
  92         const struct kmod_command *alias = l->data;
  93         return alias->modname;
  94 }
  95
  96 const char *kmod_softdep_get_name(const struct kmod_list *l) {
  97         const struct kmod_softdep *dep = l->data;
  98         return dep->name;
  99 }
 100
 101 const char * const *kmod_softdep_get_pre(const struct kmod_list *l, unsigned int *count) {
 102         const struct kmod_softdep *dep = l->data;
 103         *count = dep->n_pre;
 104         return dep->pre;
 105 }
 106
 107 const char * const *kmod_softdep_get_post(const struct kmod_list *l, unsigned int *count) {
 108         const struct kmod_softdep *dep = l->data;
 109         *count = dep->n_post;
 110         return dep->post;
 111 }
 112
 113 static int kmod_config_add_command(struct kmod_config *config,
 114                                                 const char *modname,
 115                                                 const char *command,
 116                                                 const char *command_name,
 117                                                 struct kmod_list **list)
 118 {
 119         _cleanup_free_ struct kmod_command *cmd;
 120         struct kmod_list *l;
 121         size_t modnamelen = strlen(modname) + 1;
 122         size_t commandlen = strlen(command) + 1;
 123
 124         DBG(config->ctx, "modname='%s' cmd='%s %s'\n", modname, command_name,
 125                                                                 command);
 126
 127         cmd = malloc(sizeof(*cmd) + modnamelen + commandlen);
 128         if (!cmd)
 129                 return -ENOMEM;
 130
 131         cmd->command = sizeof(*cmd) + modnamelen + (char *)cmd;
 132         memcpy(cmd->modname, modname, modnamelen);
 133         memcpy(cmd->command, command, commandlen);
 134
 135         l = kmod_list_append(*list, cmd);
 136         if (!l)
 137                 return -ENOMEM;
 138
 139         *list = l;
 140         cmd = NULL;
 141         return 0;
 142 }
 143
 144 static void kmod_config_free_command(struct kmod_config *config,
 145                                         struct kmod_list *l,
 146                                         struct kmod_list **list)
 147 {
 148         struct kmod_command *cmd = l->data;
 149
 150         free(cmd);
 151         *list = kmod_list_remove(l);
 152 }
 153
 154 static int kmod_config_add_options(struct kmod_config *config,
 155                                 const char *modname, const char *options)
 156 {
 157         _cleanup_free_ struct kmod_options *opt;
 158         struct kmod_list *list;
 159         size_t modnamelen = strlen(modname) + 1;
 160         size_t optionslen = strlen(options) + 1;
 161
 162         DBG(config->ctx, "modname='%s' options='%s'\n", modname, options);
 163
 164         opt = malloc(sizeof(*opt) + modnamelen + optionslen);
 165         if (!opt)
 166                 return -ENOMEM;
 167
 168         opt->options = sizeof(*opt) + modnamelen + (char *)opt;
 169
 170         memcpy(opt->modname, modname, modnamelen);
 171         memcpy(opt->options, options, optionslen);
 172         strchr_replace(opt->options, '\t', ' ');
 173
 174         list = kmod_list_append(config->options, opt);
 175         if (!list)
 176                 return -ENOMEM;
 177
 178         opt = NULL;
 179         config->options = list;
 180         return 0;
 181 }
 182
 183 static void kmod_config_free_options(struct kmod_config *config,
 184                                                         struct kmod_list *l)
 185 {
 186         struct kmod_options *opt = l->data;
 187
 188         free(opt);
 189
 190         config->options = kmod_list_remove(l);
 191 }
 192
 193 static int kmod_config_add_alias(struct kmod_config *config,
 194                                         const char *name, const char *modname)
 195 {
 196         _cleanup_free_ struct kmod_alias *alias;
 197         struct kmod_list *list;
 198         size_t namelen = strlen(name) + 1, modnamelen = strlen(modname) + 1;
 199
 200         DBG(config->ctx, "name=%s modname=%s\n", name, modname);
 201
 202         alias = malloc(sizeof(*alias) + namelen + modnamelen);
 203         if (!alias)
 204                 return -ENOMEM;
 205
 206         alias->name = sizeof(*alias) + modnamelen + (char *)alias;
 207
 208         memcpy(alias->modname, modname, modnamelen);
 209         memcpy(alias->name, name, namelen);
 210
 211         list = kmod_list_append(config->aliases, alias);
 212         if (!list)
 213                 return -ENOMEM;
 214
 215         alias = NULL;
 216         config->aliases = list;
 217         return 0;
 218 }
 219
 220 static void kmod_config_free_alias(struct kmod_config *config,
 221                                                         struct kmod_list *l)
 222 {
 223         struct kmod_alias *alias = l->data;
 224
 225         free(alias);
 226
 227         config->aliases = kmod_list_remove(l);
 228 }
 229
 230 static int kmod_config_add_blacklist(struct kmod_config *config,
 231                                                         const char *modname)
 232 {
 233         _cleanup_free_ char *p;
 234         struct kmod_list *list;
 235
 236         DBG(config->ctx, "modname=%s\n", modname);
 237
 238         p = strdup(modname);
 239         if (!p)
 240                 return -ENOMEM;
 241
 242         list = kmod_list_append(config->blacklists, p);
 243         if (!list)
 244                 return -ENOMEM;
 245
 246         p = NULL;
 247         config->blacklists = list;
 248         return 0;
 249 }
 250
 251 static void kmod_config_free_blacklist(struct kmod_config *config,
 252                                                         struct kmod_list *l)
 253 {
 254         free(l->data);
 255         config->blacklists = kmod_list_remove(l);
 256 }
 257
 258 static int kmod_config_add_softdep(struct kmod_config *config,
 259                                                         const char *modname,
 260                                                         const char *line)
 261 {
 262         struct kmod_list *list;
 263         struct kmod_softdep *dep;
 264         const char *s, *p;
 265         char *itr;
 266         unsigned int n_pre = 0, n_post = 0;
 267         size_t modnamelen = strlen(modname) + 1;
 268         size_t buflen = 0;
 269         bool was_space = false;
 270         enum { S_NONE, S_PRE, S_POST } mode = S_NONE;
 271
 272         DBG(config->ctx, "modname=%s\n", modname);
 273
 274         /* analyze and count */
 275         for (p = s = line; ; s++) {
 276                 size_t plen;
 277
 278                 if (*s != '\0') {
 279                         if (!isspace(*s)) {
 280                                 was_space = false;
 281                                 continue;
 282                         }
 283
 284                         if (was_space) {
 285                                 p = s + 1;
 286                                 continue;
 287                         }
 288                         was_space = true;
 289
 290                         if (p >= s)
 291                                 continue;
 292                 }
 293                 plen = s - p;
 294
 295                 if (plen == sizeof("pre:") - 1 &&
 296                                 memcmp(p, "pre:", sizeof("pre:") - 1) == 0)
 297                         mode = S_PRE;
 298                 else if (plen == sizeof("post:") - 1 &&
 299                                 memcmp(p, "post:", sizeof("post:") - 1) == 0)
 300                         mode = S_POST;
 301                 else if (*s != '\0' || (*s == '\0' && !was_space)) {
 302                         if (mode == S_PRE) {
 303                                 buflen += plen + 1;
 304                                 n_pre++;
 305                         } else if (mode == S_POST) {
 306                                 buflen += plen + 1;
 307                                 n_post++;
 308                         }
 309                 }
 310                 p = s + 1;
 311                 if (*s == '\0')
 312                         break;
 313         }
 314
 315         DBG(config->ctx, "%u pre, %u post\n", n_pre, n_post);
 316
 317         dep = malloc(sizeof(struct kmod_softdep) + modnamelen +
 318                      n_pre * sizeof(const char *) +
 319                      n_post * sizeof(const char *) +
 320                      buflen);
 321         if (dep == NULL) {
 322                 ERR(config->ctx, "out-of-memory modname=%s\n", modname);
 323                 return -ENOMEM;
 324         }
 325         dep->n_pre = n_pre;
 326         dep->n_post = n_post;
 327         dep->pre = (const char **)((char *)dep + sizeof(struct kmod_softdep));
 328         dep->post = dep->pre + n_pre;
 329         dep->name = (char *)(dep->post + n_post);
 330
 331         memcpy(dep->name, modname, modnamelen);
 332
 333         /* copy strings */
 334         itr = dep->name + modnamelen;
 335         n_pre = 0;
 336         n_post = 0;
 337         mode = S_NONE;
 338         was_space = false;
 339         for (p = s = line; ; s++) {
 340                 size_t plen;
 341
 342                 if (*s != '\0') {
 343                         if (!isspace(*s)) {
 344                                 was_space = false;
 345                                 continue;
 346                         }
 347
 348                         if (was_space) {
 349                                 p = s + 1;
 350                                 continue;
 351                         }
 352                         was_space = true;
 353
 354                         if (p >= s)
 355                                 continue;
 356                 }
 357                 plen = s - p;
 358
 359                 if (plen == sizeof("pre:") - 1 &&
 360                                 memcmp(p, "pre:", sizeof("pre:") - 1) == 0)
 361                         mode = S_PRE;
 362                 else if (plen == sizeof("post:") - 1 &&
 363                                 memcmp(p, "post:", sizeof("post:") - 1) == 0)
 364                         mode = S_POST;
 365                 else if (*s != '\0' || (*s == '\0' && !was_space)) {
 366                         if (mode == S_PRE) {
 367                                 dep->pre[n_pre] = itr;
 368                                 memcpy(itr, p, plen);
 369                                 itr[plen] = '\0';
 370                                 itr += plen + 1;
 371                                 n_pre++;
 372                         } else if (mode == S_POST) {
 373                                 dep->post[n_post] = itr;
 374                                 memcpy(itr, p, plen);
 375                                 itr[plen] = '\0';
 376                                 itr += plen + 1;
 377                                 n_post++;
 378                         }
 379                 }
 380                 p = s + 1;
 381                 if (*s == '\0')
 382                         break;
 383         }
 384
 385         list = kmod_list_append(config->softdeps, dep);
 386         if (list == NULL) {
 387                 free(dep);
 388                 return -ENOMEM;
 389         }
 390         config->softdeps = list;
 391
 392         return 0;
 393 }
 394
 395 static char *softdep_to_char(struct kmod_softdep *dep) {
 396         const size_t sz_preprefix = sizeof("pre: ") - 1;
 397         const size_t sz_postprefix = sizeof("post: ") - 1;
 398         size_t sz = 1; /* at least '\0' */
 399         size_t sz_pre, sz_post;
 400         const char *start, *end;
 401         char *s, *itr;
 402
 403         /*
 404          * Rely on the fact that dep->pre[] and dep->post[] are strv's that
 405          * point to a contiguous buffer
 406          */
 407         if (dep->n_pre > 0) {
 408                 start = dep->pre[0];
 409                 end = dep->pre[dep->n_pre - 1]
 410                                         + strlen(dep->pre[dep->n_pre - 1]);
 411                 sz_pre = end - start;
 412                 sz += sz_pre + sz_preprefix;
 413         } else
 414                 sz_pre = 0;
 415
 416         if (dep->n_post > 0) {
 417                 start = dep->post[0];
 418                 end = dep->post[dep->n_post - 1]
 419                                         + strlen(dep->post[dep->n_post - 1]);
 420                 sz_post = end - start;
 421                 sz += sz_post + sz_postprefix;
 422         } else
 423                 sz_post = 0;
 424
 425         itr = s = malloc(sz);
 426         if (s == NULL)
 427                 return NULL;
 428
 429         if (sz_pre) {
 430                 char *p;
 431
 432                 memcpy(itr, "pre: ", sz_preprefix);
 433                 itr += sz_preprefix;
 434
 435                 /* include last '\0' */
 436                 memcpy(itr, dep->pre[0], sz_pre + 1);
 437                 for (p = itr; p < itr + sz_pre; p++) {
 438                         if (*p == '\0')
 439                                 *p = ' ';
 440                 }
 441                 itr = p;
 442         }
 443
 444         if (sz_post) {
 445                 char *p;
 446
 447                 memcpy(itr, "post: ", sz_postprefix);
 448                 itr += sz_postprefix;
 449
 450                 /* include last '\0' */
 451                 memcpy(itr, dep->post[0], sz_post + 1);
 452                 for (p = itr; p < itr + sz_post; p++) {
 453                         if (*p == '\0')
 454                                 *p = ' ';
 455                 }
 456                 itr = p;
 457         }
 458
 459         *itr = '\0';
 460
 461         return s;
 462 }
 463
 464 static void kmod_config_free_softdep(struct kmod_config *config,
 465                                                         struct kmod_list *l)
 466 {
 467         free(l->data);
 468         config->softdeps = kmod_list_remove(l);
 469 }
 470
 471 static void kcmdline_parse_result(struct kmod_config *config, char *modname,
 472                                                 char *param, char *value)
 473 {
 474         if (modname == NULL || param == NULL)
 475                 return;
 476
 477         DBG(config->ctx, "%s %s\n", modname, param);
 478
 479         if (streq(modname, "modprobe") && !strncmp(param, "blacklist=", 10)) {
 480                 for (;;) {
 481                         char *t = strsep(&value, ",");
 482                         if (t == NULL)
 483                                 break;
 484
 485                         kmod_config_add_blacklist(config, t);
 486                 }
 487         } else {
 488                 if (underscores(modname) < 0) {
 489                         ERR(config->ctx, "Ignoring bad option on kernel command line while parsing module name: '%s'\n",
 490                             modname);
 491                 } else {
 492                         kmod_config_add_options(config, modname, param);
 493                 }
 494         }
 495 }
 496
 497 static int kmod_config_parse_kcmdline(struct kmod_config *config)
 498 {
 499         char buf[KCMD_LINE_SIZE];
 500         int fd, err;
 501         char *p, *p_quote_start, *modname,  *param = NULL, *value = NULL;
 502         bool is_quoted = false, iter = true;
 503         enum state {
 504                 STATE_IGNORE,
 505                 STATE_MODNAME,
 506                 STATE_PARAM,
 507                 STATE_VALUE,
 508                 STATE_COMPLETE,
 509         } state;
 510
 511         fd = open("/proc/cmdline", O_RDONLY|O_CLOEXEC);
 512         if (fd < 0) {
 513                 err = -errno;
 514                 DBG(config->ctx, "could not open '/proc/cmdline' for reading: %m\n");
 515                 return err;
 516         }
 517
 518         err = read_str_safe(fd, buf, sizeof(buf));
 519         close(fd);
 520         if (err < 0) {
 521                 ERR(config->ctx, "could not read from '/proc/cmdline': %s\n",
 522                                                         strerror(-err));
 523                 return err;
 524         }
 525
 526         state = STATE_MODNAME;
 527         p_quote_start = NULL;
 528         for (p = buf, modname = buf; iter; p++) {
 529                 switch (*p) {
 530                 case '"':
 531                         is_quoted = !is_quoted;
 532
 533                         /*
 534                          * only allow starting quote as first char when looking
 535                          * for a modname: anything else is considered ill-formed
 536                          */
 537                         if (is_quoted && state == STATE_MODNAME && p == modname) {
 538                                 p_quote_start = p;
 539                                 modname = p + 1;
 540                         } else if (state != STATE_VALUE) {
 541                                 state = STATE_IGNORE;
 542                         }
 543
 544                         break;
 545                 case '\0':
 546                         iter = false;
 547                         /* fall-through */
 548                 case ' ':
 549                 case '\n':
 550                 case '\t':
 551                 case '\v':
 552                 case '\f':
 553                 case '\r':
 554                         if (is_quoted && state == STATE_VALUE) {
 555                                 /* no state change*/;
 556                         } else if (is_quoted) {
 557                                 /* spaces are only allowed in the value part */
 558                                 state = STATE_IGNORE;
 559                         } else if (state == STATE_VALUE || state == STATE_PARAM) {
 560                                 *p = '\0';
 561                                 state = STATE_COMPLETE;
 562                         } else {
 563                                 /*
 564                                  * go to next option, ignoring any possible
 565                                  * partial match we have
 566                                  */
 567                                 modname = p + 1;
 568                                 state = STATE_MODNAME;
 569                                 p_quote_start = NULL;
 570                         }
 571                         break;
 572                 case '.':
 573                         if (state == STATE_MODNAME) {
 574                                 *p = '\0';
 575                                 param = p + 1;
 576                                 state = STATE_PARAM;
 577                         } else if (state == STATE_PARAM) {
 578                                 state = STATE_IGNORE;
 579                         }
 580                         break;
 581                 case '=':
 582                         if (state == STATE_PARAM) {
 583                                 /*
 584                                  * Don't set *p to '\0': the value var shadows
 585                                  * param
 586                                  */
 587                                 value = p + 1;
 588                                 state = STATE_VALUE;
 589                         } else if (state == STATE_MODNAME) {
 590                                 state = STATE_IGNORE;
 591                         }
 592                         break;
 593                 }
 594
 595                 if (state == STATE_COMPLETE) {
 596                         /*
 597                          * We may need to re-quote to unmangle what the
 598                          * bootloader passed. Example: grub passes the option as
 599                          * "parport.dyndbg=file drivers/parport/ieee1284_ops.c +mpf"
 600                          * instead of
 601                          * parport.dyndbg="file drivers/parport/ieee1284_ops.c +mpf"
 602                          */
 603                         if (p_quote_start && p_quote_start < modname) {
 604                                 /*
 605                                  * p_quote_start
 606                                  * |
 607                                  * |modname  param  value
 608                                  * ||        |      |
 609                                  * vv        v      v
 610                                  * "parport\0dyndbg=file drivers/parport/ieee1284_ops.c +mpf" */
 611                                 memmove(p_quote_start, modname, value - modname);
 612                                 value--; modname--; param--;
 613                                 *value = '"';
 614                         }
 615                         kcmdline_parse_result(config, modname, param, value);
 616                         /* start over on next iteration */
 617                         modname = p + 1;
 618                         state = STATE_MODNAME;
 619                         p_quote_start = NULL;
 620                 }
 621         }
 622
 623         return 0;
 624 }
 625
 626 /*
 627  * Take an fd and own it. It will be closed on return. filename is used only
 628  * for debug messages
 629  */
 630 static int kmod_config_parse(struct kmod_config *config, int fd,
 631                                                         const char *filename)
 632 {
 633         struct kmod_ctx *ctx = config->ctx;
 634         char *line;
 635         FILE *fp;
 636         unsigned int linenum = 0;
 637         int err;
 638
 639         fp = fdopen(fd, "r");
 640         if (fp == NULL) {
 641                 err = -errno;
 642                 ERR(config->ctx, "fd %d: %m\n", fd);
 643                 close(fd);
 644                 return err;
 645         }
 646
 647         while ((line = freadline_wrapped(fp, &linenum)) != NULL) {
 648                 char *cmd, *saveptr;
 649
 650                 if (line[0] == '\0' || line[0] == '#')
 651                         goto done_next;
 652
 653                 cmd = strtok_r(line, "\t ", &saveptr);
 654                 if (cmd == NULL)
 655                         goto done_next;
 656
 657                 if (streq(cmd, "alias")) {
 658                         char *alias = strtok_r(NULL, "\t ", &saveptr);
 659                         char *modname = strtok_r(NULL, "\t ", &saveptr);
 660
 661                         if (underscores(alias) < 0 || underscores(modname) < 0)
 662                                 goto syntax_error;
 663
 664                         kmod_config_add_alias(config, alias, modname);
 665                 } else if (streq(cmd, "blacklist")) {
 666                         char *modname = strtok_r(NULL, "\t ", &saveptr);
 667
 668                         if (underscores(modname) < 0)
 669                                 goto syntax_error;
 670
 671                         kmod_config_add_blacklist(config, modname);
 672                 } else if (streq(cmd, "options")) {
 673                         char *modname = strtok_r(NULL, "\t ", &saveptr);
 674                         char *options = strtok_r(NULL, "\0", &saveptr);
 675
 676                         if (underscores(modname) < 0 || options == NULL)
 677                                 goto syntax_error;
 678
 679                         kmod_config_add_options(config, modname, options);
 680                 } else if (streq(cmd, "install")) {
 681                         char *modname = strtok_r(NULL, "\t ", &saveptr);
 682                         char *installcmd = strtok_r(NULL, "\0", &saveptr);
 683
 684                         if (underscores(modname) < 0 || installcmd == NULL)
 685                                 goto syntax_error;
 686
 687                         kmod_config_add_command(config, modname, installcmd,
 688                                         cmd, &config->install_commands);
 689                 } else if (streq(cmd, "remove")) {
 690                         char *modname = strtok_r(NULL, "\t ", &saveptr);
 691                         char *removecmd = strtok_r(NULL, "\0", &saveptr);
 692
 693                         if (underscores(modname) < 0 || removecmd == NULL)
 694                                 goto syntax_error;
 695
 696                         kmod_config_add_command(config, modname, removecmd,
 697                                         cmd, &config->remove_commands);
 698                 } else if (streq(cmd, "softdep")) {
 699                         char *modname = strtok_r(NULL, "\t ", &saveptr);
 700                         char *softdeps = strtok_r(NULL, "\0", &saveptr);
 701
 702                         if (underscores(modname) < 0 || softdeps == NULL)
 703                                 goto syntax_error;
 704
 705                         kmod_config_add_softdep(config, modname, softdeps);
 706                 } else if (streq(cmd, "include")
 707                                 || streq(cmd, "config")) {
 708                         ERR(ctx, "%s: command %s is deprecated and not parsed anymore\n",
 709                                                                 filename, cmd);
 710                 } else {
 711 syntax_error:
 712                         ERR(ctx, "%s line %u: ignoring bad line starting with '%s'\n",
 713                                                 filename, linenum, cmd);
 714                 }
 715
 716 done_next:
 717                 free(line);
 718         }
 719
 720         fclose(fp);
 721
 722         return 0;
 723 }
 724
 725 void kmod_config_free(struct kmod_config *config)
 726 {
 727         while (config->aliases)
 728                 kmod_config_free_alias(config, config->aliases);
 729
 730         while (config->blacklists)
 731                 kmod_config_free_blacklist(config, config->blacklists);
 732
 733         while (config->options)
 734                 kmod_config_free_options(config, config->options);
 735
 736         while (config->install_commands) {
 737                 kmod_config_free_command(config, config->install_commands,
 738                                                 &config->install_commands);
 739         }
 740
 741         while (config->remove_commands) {
 742                 kmod_config_free_command(config, config->remove_commands,
 743                                                 &config->remove_commands);
 744         }
 745
 746         while (config->softdeps)
 747                 kmod_config_free_softdep(config, config->softdeps);
 748
 749         for (; config->paths != NULL;
 750                                 config->paths = kmod_list_remove(config->paths))
 751                 free(config->paths->data);
 752
 753         free(config);
 754 }
 755
 756 static bool conf_files_filter_out(struct kmod_ctx *ctx, DIR *d,
 757                                         const char *path, const char *fn)
 758 {
 759         size_t len = strlen(fn);
 760         struct stat st;
 761
 762         if (fn[0] == '.')
 763                 return true;
 764
 765         if (len < 6 || (!streq(&fn[len - 5], ".conf")
 766                                 && !streq(&fn[len - 6], ".alias")))
 767                 return true;
 768
 769         fstatat(dirfd(d), fn, &st, 0);
 770
 771         if (S_ISDIR(st.st_mode)) {
 772                 ERR(ctx, "Directories inside directories are not supported: "
 773                                                         "%s/%s\n", path, fn);
 774                 return true;
 775         }
 776
 777         return false;
 778 }
 779
 780 struct conf_file {
 781         const char *path;
 782         bool is_single;
 783         char name[];
 784 };
 785
 786 static int conf_files_insert_sorted(struct kmod_ctx *ctx,
 787                                         struct kmod_list **list,
 788                                         const char *path, const char *name)
 789 {
 790         struct kmod_list *lpos, *tmp;
 791         struct conf_file *cf;
 792         size_t namelen;
 793         int cmp = -1;
 794         bool is_single = false;
 795
 796         if (name == NULL) {
 797                 name = basename(path);
 798                 is_single = true;
 799         }
 800
 801         kmod_list_foreach(lpos, *list) {
 802                 cf = lpos->data;
 803
 804                 if ((cmp = strcmp(name, cf->name)) <= 0)
 805                         break;
 806         }
 807
 808         if (cmp == 0) {
 809                 DBG(ctx, "Ignoring duplicate config file: %s/%s\n", path,
 810                                                                         name);
 811                 return -EEXIST;
 812         }
 813
 814         namelen = strlen(name);
 815         cf = malloc(sizeof(*cf) + namelen + 1);
 816         if (cf == NULL)
 817                 return -ENOMEM;
 818
 819         memcpy(cf->name, name, namelen + 1);
 820         cf->path = path;
 821         cf->is_single = is_single;
 822
 823         if (lpos == NULL)
 824                 tmp = kmod_list_append(*list, cf);
 825         else if (lpos == *list)
 826                 tmp = kmod_list_prepend(*list, cf);
 827         else
 828                 tmp = kmod_list_insert_before(lpos, cf);
 829
 830         if (tmp == NULL) {
 831                 free(cf);
 832                 return -ENOMEM;
 833         }
 834
 835         if (lpos == NULL || lpos == *list)
 836                 *list = tmp;
 837
 838         return 0;
 839 }
 840
 841 /*
 842  * Insert configuration files in @list, ignoring duplicates
 843  */
 844 static int conf_files_list(struct kmod_ctx *ctx, struct kmod_list **list,
 845                                                 const char *path,
 846                                                 unsigned long long *path_stamp)
 847 {
 848         DIR *d;
 849         int err;
 850         struct stat st;
 851         struct dirent *dent;
 852
 853         if (stat(path, &st) != 0) {
 854                 err = -errno;
 855                 DBG(ctx, "could not stat '%s': %m\n", path);
 856                 return err;
 857         }
 858
 859         *path_stamp = stat_mstamp(&st);
 860
 861         if (!S_ISDIR(st.st_mode)) {
 862                 conf_files_insert_sorted(ctx, list, path, NULL);
 863                 return 0;
 864         }
 865
 866         d = opendir(path);
 867         if (d == NULL) {
 868                 ERR(ctx, "opendir(%s): %m\n", path);
 869                 return -EINVAL;
 870         }
 871
 872         for (dent = readdir(d); dent != NULL; dent = readdir(d)) {
 873                 if (conf_files_filter_out(ctx, d, path, dent->d_name))
 874                         continue;
 875
 876                 conf_files_insert_sorted(ctx, list, path, dent->d_name);
 877         }
 878
 879         closedir(d);
 880         return 0;
 881 }
 882
 883 int kmod_config_new(struct kmod_ctx *ctx, struct kmod_config **p_config,
 884                                         const char * const *config_paths)
 885 {
 886         struct kmod_config *config;
 887         struct kmod_list *list = NULL;
 888         struct kmod_list *path_list = NULL;
 889         size_t i;
 890
 891         conf_files_insert_sorted(ctx, &list, kmod_get_dirname(ctx), "modules.softdep");
 892
 893         for (i = 0; config_paths[i] != NULL; i++) {
 894                 const char *path = config_paths[i];
 895                 unsigned long long path_stamp = 0;
 896                 size_t pathlen;
 897                 struct kmod_list *tmp;
 898                 struct kmod_config_path *cf;
 899
 900                 if (conf_files_list(ctx, &list, path, &path_stamp) < 0)
 901                         continue;
 902
 903                 pathlen = strlen(path) + 1;
 904                 cf = malloc(sizeof(*cf) + pathlen);
 905                 if (cf == NULL)
 906                         goto oom;
 907
 908                 cf->stamp = path_stamp;
 909                 memcpy(cf->path, path, pathlen);
 910
 911                 tmp = kmod_list_append(path_list, cf);
 912                 if (tmp == NULL) {
 913                         free(cf);
 914                         goto oom;
 915                 }
 916                 path_list = tmp;
 917         }
 918
 919         *p_config = config = calloc(1, sizeof(struct kmod_config));
 920         if (config == NULL)
 921                 goto oom;
 922
 923         config->paths = path_list;
 924         config->ctx = ctx;
 925
 926         for (; list != NULL; list = kmod_list_remove(list)) {
 927                 char buf[PATH_MAX];
 928                 const char *fn = buf;
 929                 struct conf_file *cf = list->data;
 930                 int fd;
 931
 932                 if (cf->is_single) {
 933                         fn = cf->path;
 934                 } else if (snprintf(buf, sizeof(buf), "%s/%s",
 935                                     cf->path, cf->name) >= (int)sizeof(buf)) {
 936                         ERR(ctx, "Error parsing %s/%s: path too long\n",
 937                             cf->path, cf->name);
 938                         free(cf);
 939                         continue;
 940                 }
 941
 942                 fd = open(fn, O_RDONLY|O_CLOEXEC);
 943                 DBG(ctx, "parsing file '%s' fd=%d\n", fn, fd);
 944
 945                 if (fd >= 0)
 946                         kmod_config_parse(config, fd, fn);
 947
 948                 free(cf);
 949         }
 950
 951         kmod_config_parse_kcmdline(config);
 952
 953         return 0;
 954
 955 oom:
 956         for (; list != NULL; list = kmod_list_remove(list))
 957                 free(list->data);
 958
 959         for (; path_list != NULL; path_list = kmod_list_remove(path_list))
 960                 free(path_list->data);
 961
 962         return -ENOMEM;
 963 }
 964
 965 /**********************************************************************
 966  * struct kmod_config_iter functions
 967  **********************************************************************/
 968
 969 enum config_type {
 970         CONFIG_TYPE_BLACKLIST = 0,
 971         CONFIG_TYPE_INSTALL,
 972         CONFIG_TYPE_REMOVE,
 973         CONFIG_TYPE_ALIAS,
 974         CONFIG_TYPE_OPTION,
 975         CONFIG_TYPE_SOFTDEP,
 976 };
 977
 978 struct kmod_config_iter {
 979         enum config_type type;
 980         bool intermediate;
 981         const struct kmod_list *list;
 982         const struct kmod_list *curr;
 983         void *data;
 984         const char *(*get_key)(const struct kmod_list *l);
 985         const char *(*get_value)(const struct kmod_list *l);
 986 };
 987
 988 static const char *softdep_get_plain_softdep(const struct kmod_list *l)
 989 {
 990         char *s = softdep_to_char(l->data);
 991         return s;
 992 }
 993
 994 static struct kmod_config_iter *kmod_config_iter_new(const struct kmod_ctx* ctx,
 995                                                         enum config_type type)
 996 {
 997         struct kmod_config_iter *iter = calloc(1, sizeof(*iter));
 998         const struct kmod_config *config = kmod_get_config(ctx);
 999
1000         if (iter == NULL)
1001                 return NULL;
1002
1003         iter->type = type;
1004
1005         switch (type) {
1006         case CONFIG_TYPE_BLACKLIST:
1007                 iter->list = config->blacklists;
1008                 iter->get_key = kmod_blacklist_get_modname;
1009                 break;
1010         case CONFIG_TYPE_INSTALL:
1011                 iter->list = config->install_commands;
1012                 iter->get_key = kmod_command_get_modname;
1013                 iter->get_value = kmod_command_get_command;
1014                 break;
1015         case CONFIG_TYPE_REMOVE:
1016                 iter->list = config->remove_commands;
1017                 iter->get_key = kmod_command_get_modname;
1018                 iter->get_value = kmod_command_get_command;
1019                 break;
1020         case CONFIG_TYPE_ALIAS:
1021                 iter->list = config->aliases;
1022                 iter->get_key = kmod_alias_get_name;
1023                 iter->get_value = kmod_alias_get_modname;
1024                 break;
1025         case CONFIG_TYPE_OPTION:
1026                 iter->list = config->options;
1027                 iter->get_key = kmod_option_get_modname;
1028                 iter->get_value = kmod_option_get_options;
1029                 break;
1030         case CONFIG_TYPE_SOFTDEP:
1031                 iter->list = config->softdeps;
1032                 iter->get_key = kmod_softdep_get_name;
1033                 iter->get_value = softdep_get_plain_softdep;
1034                 iter->intermediate = true;
1035                 break;
1036         }
1037
1038         return iter;
1039 }
1040
1041 /**
1042  * SECTION:libkmod-config
1043  * @short_description: retrieve current libkmod configuration
1044  */
1045
1046 /**
1047  * kmod_config_get_blacklists:
1048  * @ctx: kmod library context
1049  *
1050  * Retrieve an iterator to deal with the blacklist maintained inside the
1051  * library. See kmod_config_iter_get_key(), kmod_config_iter_get_value() and
1052  * kmod_config_iter_next(). At least one call to kmod_config_iter_next() must
1053  * be made to initialize the iterator and check if it's valid.
1054  *
1055  * Returns: a new iterator over the blacklists or NULL on failure. Free it
1056  * with kmod_config_iter_free_iter().
1057  */
1058 KMOD_EXPORT struct kmod_config_iter *kmod_config_get_blacklists(const struct kmod_ctx *ctx)
1059 {
1060         if (ctx == NULL)
1061                 return NULL;;
1062
1063         return kmod_config_iter_new(ctx, CONFIG_TYPE_BLACKLIST);
1064 }
1065
1066 /**
1067  * kmod_config_get_install_commands:
1068  * @ctx: kmod library context
1069  *
1070  * Retrieve an iterator to deal with the install commands maintained inside the
1071  * library. See kmod_config_iter_get_key(), kmod_config_iter_get_value() and
1072  * kmod_config_iter_next(). At least one call to kmod_config_iter_next() must
1073  * be made to initialize the iterator and check if it's valid.
1074  *
1075  * Returns: a new iterator over the install commands or NULL on failure. Free
1076  * it with kmod_config_iter_free_iter().
1077  */
1078 KMOD_EXPORT struct kmod_config_iter *kmod_config_get_install_commands(const struct kmod_ctx *ctx)
1079 {
1080         if (ctx == NULL)
1081                 return NULL;;
1082
1083         return kmod_config_iter_new(ctx, CONFIG_TYPE_INSTALL);
1084 }
1085
1086 /**
1087  * kmod_config_get_remove_commands:
1088  * @ctx: kmod library context
1089  *
1090  * Retrieve an iterator to deal with the remove commands maintained inside the
1091  * library. See kmod_config_iter_get_key(), kmod_config_iter_get_value() and
1092  * kmod_config_iter_next(). At least one call to kmod_config_iter_next() must
1093  * be made to initialize the iterator and check if it's valid.
1094  *
1095  * Returns: a new iterator over the remove commands or NULL on failure. Free
1096  * it with kmod_config_iter_free_iter().
1097  */
1098 KMOD_EXPORT struct kmod_config_iter *kmod_config_get_remove_commands(const struct kmod_ctx *ctx)
1099 {
1100         if (ctx == NULL)
1101                 return NULL;;
1102
1103         return kmod_config_iter_new(ctx, CONFIG_TYPE_REMOVE);
1104 }
1105
1106 /**
1107  * kmod_config_get_aliases:
1108  * @ctx: kmod library context
1109  *
1110  * Retrieve an iterator to deal with the aliases maintained inside the
1111  * library. See kmod_config_iter_get_key(), kmod_config_iter_get_value() and
1112  * kmod_config_iter_next(). At least one call to kmod_config_iter_next() must
1113  * be made to initialize the iterator and check if it's valid.
1114  *
1115  * Returns: a new iterator over the aliases or NULL on failure. Free it with
1116  * kmod_config_iter_free_iter().
1117  */
1118 KMOD_EXPORT struct kmod_config_iter *kmod_config_get_aliases(const struct kmod_ctx *ctx)
1119 {
1120         if (ctx == NULL)
1121                 return NULL;;
1122
1123         return kmod_config_iter_new(ctx, CONFIG_TYPE_ALIAS);
1124 }
1125
1126 /**
1127  * kmod_config_get_options:
1128  * @ctx: kmod library context
1129  *
1130  * Retrieve an iterator to deal with the options maintained inside the
1131  * library. See kmod_config_iter_get_key(), kmod_config_iter_get_value() and
1132  * kmod_config_iter_next(). At least one call to kmod_config_iter_next() must
1133  * be made to initialize the iterator and check if it's valid.
1134  *
1135  * Returns: a new iterator over the options or NULL on failure. Free it with
1136  * kmod_config_iter_free_iter().
1137  */
1138 KMOD_EXPORT struct kmod_config_iter *kmod_config_get_options(const struct kmod_ctx *ctx)
1139 {
1140         if (ctx == NULL)
1141                 return NULL;;
1142
1143         return kmod_config_iter_new(ctx, CONFIG_TYPE_OPTION);
1144 }
1145
1146 /**
1147  * kmod_config_get_softdeps:
1148  * @ctx: kmod library context
1149  *
1150  * Retrieve an iterator to deal with the softdeps maintained inside the
1151  * library. See kmod_config_iter_get_key(), kmod_config_iter_get_value() and
1152  * kmod_config_iter_next(). At least one call to kmod_config_iter_next() must
1153  * be made to initialize the iterator and check if it's valid.
1154  *
1155  * Returns: a new iterator over the softdeps or NULL on failure. Free it with
1156  * kmod_config_iter_free_iter().
1157  */
1158 KMOD_EXPORT struct kmod_config_iter *kmod_config_get_softdeps(const struct kmod_ctx *ctx)
1159 {
1160         if (ctx == NULL)
1161                 return NULL;;
1162
1163         return kmod_config_iter_new(ctx, CONFIG_TYPE_SOFTDEP);
1164 }
1165
1166 /**
1167  * kmod_config_iter_get_key:
1168  * @iter: iterator over a certain configuration
1169  *
1170  * When using a new allocated iterator, user must perform a call to
1171  * kmod_config_iter_next() to initialize iterator's position and check if it's
1172  * valid.
1173  *
1174  * Returns: the key of the current configuration pointed by @iter.
1175  */
1176 KMOD_EXPORT const char *kmod_config_iter_get_key(const struct kmod_config_iter *iter)
1177 {
1178         if (iter == NULL || iter->curr == NULL)
1179                 return NULL;
1180
1181         return iter->get_key(iter->curr);
1182 }
1183
1184 /**
1185  * kmod_config_iter_get_value:
1186  * @iter: iterator over a certain configuration
1187  *
1188  * When using a new allocated iterator, user must perform a call to
1189  * kmod_config_iter_next() to initialize iterator's position and check if it's
1190  * valid.
1191  *
1192  * Returns: the value of the current configuration pointed by @iter.
1193  */
1194 KMOD_EXPORT const char *kmod_config_iter_get_value(const struct kmod_config_iter *iter)
1195 {
1196         const char *s;
1197
1198         if (iter == NULL || iter->curr == NULL)
1199                 return NULL;
1200
1201         if (iter->get_value == NULL)
1202                 return NULL;
1203
1204         if (iter->intermediate) {
1205                 struct kmod_config_iter *i = (struct kmod_config_iter *)iter;
1206
1207                 free(i->data);
1208                 s = i->data = (void *) iter->get_value(iter->curr);
1209         } else
1210                 s = iter->get_value(iter->curr);
1211
1212         return s;
1213 }
1214
1215 /**
1216  * kmod_config_iter_next:
1217  * @iter: iterator over a certain configuration
1218  *
1219  * Make @iter point to the next item of a certain configuration. It's an
1220  * automatically recycling iterator. When it reaches the end, false is
1221  * returned; then if user wants to iterate again, it's sufficient to call this
1222  * function once more.
1223  *
1224  * Returns: true if next position of @iter is valid or false if its end is
1225  * reached.
1226  */
1227 KMOD_EXPORT bool kmod_config_iter_next(struct kmod_config_iter *iter)
1228 {
1229         if (iter == NULL)
1230                 return false;
1231
1232         if (iter->curr == NULL) {
1233                 iter->curr = iter->list;
1234                 return iter->curr != NULL;
1235         }
1236
1237         iter->curr = kmod_list_next(iter->list, iter->curr);
1238
1239         return iter->curr != NULL;
1240 }
1241
1242 /**
1243  * kmod_config_iter_free_iter:
1244  * @iter: iterator over a certain configuration
1245  *
1246  * Free resources used by the iterator.
1247  */
1248 KMOD_EXPORT void kmod_config_iter_free_iter(struct kmod_config_iter *iter)
1249 {
1250         free(iter->data);
1251         free(iter);
1252 }