modutils/modprobe.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Modprobe written from scratch for BusyBox
   4  *
   5  * Copyright (c) 2002 by Robert Griebl, griebl@gmx.de
   6  * Copyright (c) 2003 by Andrew Dennison, andrew.dennison@motec.com.au
   7  * Copyright (c) 2005 by Jim Bauer, jfbauer@nfr.com
   8  *
   9  * Portions Copyright (c) 2005 by Yann E. MORIN, yann.morin.1998@anciens.enib.fr
  10  *
  11  * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  12 */
  13
  14 #include "libbb.h"
  15 #include <sys/utsname.h>
  16 #include <fnmatch.h>
  17
  18 #define line_buffer bb_common_bufsiz1
  19
  20 struct mod_opt_t {      /* one-way list of options to pass to a module */
  21         char *  m_opt_val;
  22         struct mod_opt_t * m_next;
  23 };
  24
  25 struct dep_t {  /* one-way list of dependency rules */
  26         /* a dependency rule */
  27         char *  m_name;                         /* the module name*/
  28         char *  m_path;                         /* the module file path */
  29         struct mod_opt_t *  m_options;          /* the module options */
  30
  31         int     m_isalias  : 1;                 /* the module is an alias */
  32         int     m_isblacklisted : 1;
  33         int     m_reserved : 14;                /* stuffin' */
  34
  35         int     m_depcnt   : 16;                /* the number of dependable module(s) */
  36         char ** m_deparr;                       /* the list of dependable module(s) */
  37
  38         struct dep_t * m_next;                  /* the next dependency rule */
  39 };
  40
  41 struct mod_list_t {     /* two-way list of modules to process */
  42         /* a module description */
  43         const char * m_name;
  44         char * m_path;
  45         struct mod_opt_t * m_options;
  46
  47         struct mod_list_t * m_prev;
  48         struct mod_list_t * m_next;
  49 };
  50
  51
  52 static struct dep_t *depend;
  53
  54 #define MAIN_OPT_STR "acdklnqrst:vVC:"
  55 #define INSERT_ALL     1        /* a */
  56 #define DUMP_CONF_EXIT 2        /* c */
  57 #define D_OPT_IGNORED  4        /* d */
  58 #define AUTOCLEAN_FLG  8        /* k */
  59 #define LIST_ALL       16       /* l */
  60 #define SHOW_ONLY      32       /* n */
  61 #define QUIET          64       /* q */
  62 #define REMOVE_OPT     128      /* r */
  63 #define DO_SYSLOG      256      /* s */
  64 #define RESTRICT_DIR   512      /* t */
  65 #define VERBOSE        1024     /* v */
  66 #define VERSION_ONLY   2048     /* V */
  67 #define CONFIG_FILE    4096     /* C */
  68
  69 #define autoclean       (option_mask32 & AUTOCLEAN_FLG)
  70 #define show_only       (option_mask32 & SHOW_ONLY)
  71 #define quiet           (option_mask32 & QUIET)
  72 #define remove_opt      (option_mask32 & REMOVE_OPT)
  73 #define do_syslog       (option_mask32 & DO_SYSLOG)
  74 #define verbose         (option_mask32 & VERBOSE)
  75
  76 static int parse_tag_value(char *buffer, char **ptag, char **pvalue)
  77 {
  78         char *tag, *value;
  79
  80         buffer = skip_whitespace(buffer);
  81         tag = value = buffer;
  82         while (!isspace(*value)) {
  83                 if (!*value)
  84                         return 0;
  85                 value++;
  86         }
  87         *value++ = '\0';
  88         value = skip_whitespace(value);
  89         if (!*value)
  90                 return 0;
  91
  92         *ptag = tag;
  93         *pvalue = value;
  94
  95         return 1;
  96 }
  97
  98 /*
  99  * This function appends an option to a list
 100  */
 101 static struct mod_opt_t *append_option(struct mod_opt_t *opt_list, char *opt)
 102 {
 103         struct mod_opt_t *ol = opt_list;
 104
 105         if (ol) {
 106                 while (ol->m_next) {
 107                         ol = ol->m_next;
 108                 }
 109                 ol->m_next = xzalloc(sizeof(struct mod_opt_t));
 110                 ol = ol->m_next;
 111         } else {
 112                 ol = opt_list = xzalloc(sizeof(struct mod_opt_t));
 113         }
 114
 115         ol->m_opt_val = xstrdup(opt);
 116         /*ol->m_next = NULL; - done by xzalloc*/
 117
 118         return opt_list;
 119 }
 120
 121 #if ENABLE_FEATURE_MODPROBE_MULTIPLE_OPTIONS
 122 /* static char* parse_command_string(char* src, char **dst);
 123  *   src: pointer to string containing argument
 124  *   dst: pointer to where to store the parsed argument
 125  *   return value: the pointer to the first char after the parsed argument,
 126  *                 NULL if there was no argument parsed (only trailing spaces).
 127  *   Note that memory is allocated with xstrdup when a new argument was
 128  *   parsed. Don't forget to free it!
 129  */
 130 #define ARG_EMPTY      0x00
 131 #define ARG_IN_DQUOTES 0x01
 132 #define ARG_IN_SQUOTES 0x02
 133 static char *parse_command_string(char *src, char **dst)
 134 {
 135         int opt_status = ARG_EMPTY;
 136         char* tmp_str;
 137
 138         /* Dumb you, I have nothing to do... */
 139         if (src == NULL) return src;
 140
 141         /* Skip leading spaces */
 142         while (*src == ' ') {
 143                 src++;
 144         }
 145         /* Is the end of string reached? */
 146         if (*src == '\0') {
 147                 return NULL;
 148         }
 149         /* Reached the start of an argument
 150          * By the way, we duplicate a little too much
 151          * here but what is too much is freed later. */
 152         *dst = tmp_str = xstrdup(src);
 153         /* Get to the end of that argument */
 154         while (*tmp_str != '\0'
 155          && (*tmp_str != ' ' || (opt_status & (ARG_IN_DQUOTES | ARG_IN_SQUOTES)))
 156         ) {
 157                 switch (*tmp_str) {
 158                 case '\'':
 159                         if (opt_status & ARG_IN_DQUOTES) {
 160                                 /* Already in double quotes, keep current char as is */
 161                         } else {
 162                                 /* shift left 1 char, until end of string: get rid of the opening/closing quotes */
 163                                 memmove(tmp_str, tmp_str + 1, strlen(tmp_str));
 164                                 /* mark me: we enter or leave single quotes */
 165                                 opt_status ^= ARG_IN_SQUOTES;
 166                                 /* Back one char, as we need to re-scan the new char there. */
 167                                 tmp_str--;
 168                         }
 169                         break;
 170                 case '"':
 171                         if (opt_status & ARG_IN_SQUOTES) {
 172                                 /* Already in single quotes, keep current char as is */
 173                         } else {
 174                                 /* shift left 1 char, until end of string: get rid of the opening/closing quotes */
 175                                 memmove(tmp_str, tmp_str + 1, strlen(tmp_str));
 176                                 /* mark me: we enter or leave double quotes */
 177                                 opt_status ^= ARG_IN_DQUOTES;
 178                                 /* Back one char, as we need to re-scan the new char there. */
 179                                 tmp_str--;
 180                         }
 181                         break;
 182                 case '\\':
 183                         if (opt_status & ARG_IN_SQUOTES) {
 184                                 /* Between single quotes: keep as is. */
 185                         } else {
 186                                 switch (*(tmp_str+1)) {
 187                                 case 'a':
 188                                 case 'b':
 189                                 case 't':
 190                                 case 'n':
 191                                 case 'v':
 192                                 case 'f':
 193                                 case 'r':
 194                                 case '0':
 195                                         /* We escaped a special character. For now, keep
 196                                          * both the back-slash and the following char. */
 197                                         tmp_str++;
 198                                         src++;
 199                                         break;
 200                                 default:
 201                                         /* We escaped a space or a single or double quote,
 202                                          * or a back-slash, or a non-escapable char. Remove
 203                                          * the '\' and keep the new current char as is. */
 204                                         memmove(tmp_str, tmp_str + 1, strlen(tmp_str));
 205                                         break;
 206                                 }
 207                         }
 208                         break;
 209                 /* Any other char that is special shall appear here.
 210                  * Example: $ starts a variable
 211                 case '$':
 212                         do_variable_expansion();
 213                         break;
 214                  * */
 215                 default:
 216                         /* any other char is kept as is. */
 217                         break;
 218                 }
 219                 tmp_str++; /* Go to next char */
 220                 src++; /* Go to next char to find the end of the argument. */
 221         }
 222         /* End of string, but still no ending quote */
 223         if (opt_status & (ARG_IN_DQUOTES | ARG_IN_SQUOTES)) {
 224                 bb_error_msg_and_die("unterminated (single or double) quote in options list: %s", src);
 225         }
 226         *tmp_str++ = '\0';
 227         *dst = xrealloc(*dst, (tmp_str - *dst));
 228         return src;
 229 }
 230 #else
 231 #define parse_command_string(src, dst)  (0)
 232 #endif /* ENABLE_FEATURE_MODPROBE_MULTIPLE_OPTIONS */
 233
 234 static int is_conf_command(char *buffer, const char *command)
 235 {
 236         int len = strlen(command);
 237         return ((strstr(buffer, command) == buffer) &&
 238                         isspace(buffer[len]));
 239 }
 240
 241 /*
 242  * This function reads aliases and default module options from a configuration file
 243  * (/etc/modprobe.conf syntax). It supports includes (only files, no directories).
 244  */
 245 static void include_conf(struct dep_t **first, struct dep_t **current, char *buffer, int buflen, int fd)
 246 {
 247         int continuation_line = 0;
 248
 249         // alias parsing is not 100% correct (no correct handling of continuation lines within an alias)!
 250
 251         while (reads(fd, buffer, buflen)) {
 252                 int l;
 253
 254                 *strchrnul(buffer, '#') = '\0';
 255
 256                 l = strlen(buffer);
 257
 258                 while (l && isspace(buffer[l-1])) {
 259                         buffer[l-1] = '\0';
 260                         l--;
 261                 }
 262
 263                 if (l == 0) {
 264                         continuation_line = 0;
 265                         continue;
 266                 }
 267
 268                 if (continuation_line)
 269                         continue;
 270
 271                 if (is_conf_command(buffer, "alias")) {
 272                         char *alias, *mod;
 273
 274                         if (parse_tag_value(buffer + 6, &alias, &mod)) {
 275                                 /* handle alias as a module dependent on the aliased module */
 276                                 if (!*current) {
 277                                         (*first) = (*current) = xzalloc(sizeof(struct dep_t));
 278                                 } else {
 279                                         (*current)->m_next = xzalloc(sizeof(struct dep_t));
 280                                         (*current) = (*current)->m_next;
 281                                 }
 282                                 (*current)->m_name = xstrdup(alias);
 283                                 (*current)->m_isalias = 1;
 284
 285                                 if ((strcmp(mod, "off") == 0) || (strcmp(mod, "null") == 0)) {
 286                                         /*(*current)->m_depcnt = 0; - done by xzalloc */
 287                                         /*(*current)->m_deparr = 0;*/
 288                                 } else {
 289                                         (*current)->m_depcnt = 1;
 290                                         (*current)->m_deparr = xmalloc(sizeof(char *));
 291                                         (*current)->m_deparr[0] = xstrdup(mod);
 292                                 }
 293                                 /*(*current)->m_next = NULL; - done by xzalloc */
 294                         }
 295                 } else if (is_conf_command(buffer, "options")) {
 296                         char *mod, *opt;
 297
 298                         /* split the line in the module/alias name, and options */
 299                         if (parse_tag_value(buffer + 8, &mod, &opt)) {
 300                                 struct dep_t *dt;
 301
 302                                 /* find the corresponding module */
 303                                 for (dt = *first; dt; dt = dt->m_next) {
 304                                         if (strcmp(dt->m_name, mod) == 0)
 305                                                 break;
 306                                 }
 307                                 if (dt) {
 308                                         if (ENABLE_FEATURE_MODPROBE_MULTIPLE_OPTIONS) {
 309                                                 char* new_opt = NULL;
 310                                                 while ((opt = parse_command_string(opt, &new_opt))) {
 311                                                         dt->m_options = append_option(dt->m_options, new_opt);
 312                                                 }
 313                                         } else {
 314                                                 dt->m_options = append_option(dt->m_options, opt);
 315                                         }
 316                                 }
 317                         }
 318                 } else if (is_conf_command(buffer, "include")) {
 319                         int fdi;
 320                         char *filename;
 321
 322                         filename = skip_whitespace(buffer + 8);
 323                         fdi = open(filename, O_RDONLY);
 324                         if (fdi >= 0) {
 325                                 include_conf(first, current, buffer, buflen, fdi);
 326                                 close(fdi);
 327                         }
 328                 } else if (ENABLE_FEATURE_MODPROBE_BLACKLIST &&
 329                                 (is_conf_command(buffer, "blacklist"))) {
 330                         char *mod;
 331                         struct dep_t *dt;
 332
 333                         mod = skip_whitespace(buffer + 10);
 334                         for (dt = *first; dt; dt = dt->m_next) {
 335                                 if (strcmp(dt->m_name, mod) == 0)
 336                                         break;
 337                         }
 338                         if (dt)
 339                                 dt->m_isblacklisted = 1;
 340                 }
 341         } /* while (reads(...)) */
 342 }
 343
 344 /*
 345  * This function builds a list of dependency rules from /lib/modules/`uname -r`/modules.dep.
 346  * It then fills every modules and aliases with their default options, found by parsing
 347  * modprobe.conf (or modules.conf, or conf.modules).
 348  */
 349 static struct dep_t *build_dep(void)
 350 {
 351         int fd;
 352         struct utsname un;
 353         struct dep_t *first = NULL;
 354         struct dep_t *current = NULL;
 355         char *filename;
 356         int continuation_line = 0;
 357         int k_version;
 358
 359         if (uname(&un))
 360                 bb_error_msg_and_die("can't determine kernel version");
 361
 362         k_version = 0;
 363         if (un.release[0] == '2') {
 364                 k_version = un.release[2] - '0';
 365         }
 366
 367         filename = xasprintf(CONFIG_DEFAULT_MODULES_DIR"/%s/"CONFIG_DEFAULT_DEPMOD_FILE, un.release);
 368         fd = open(filename, O_RDONLY);
 369         if (ENABLE_FEATURE_CLEAN_UP)
 370                 free(filename);
 371         if (fd < 0) {
 372                 /* Ok, that didn't work.  Fall back to looking in /lib/modules */
 373                 fd = open(CONFIG_DEFAULT_MODULES_DIR"/"CONFIG_DEFAULT_DEPMOD_FILE, O_RDONLY);
 374                 if (fd < 0) {
 375                         bb_error_msg_and_die("cannot parse " CONFIG_DEFAULT_DEPMOD_FILE);
 376                 }
 377         }
 378
 379         while (reads(fd, line_buffer, sizeof(line_buffer))) {
 380                 int l = strlen(line_buffer);
 381                 char *p = 0;
 382
 383                 while (l > 0 && isspace(line_buffer[l-1])) {
 384                         line_buffer[l-1] = '\0';
 385                         l--;
 386                 }
 387
 388                 if (l == 0) {
 389                         continuation_line = 0;
 390                         continue;
 391                 }
 392
 393                 /* Is this a new module dep description? */
 394                 if (!continuation_line) {
 395                         /* find the dep beginning */
 396                         char *col = strchr(line_buffer, ':');
 397                         char *dot = col;
 398
 399                         if (col) {
 400                                 /* This line is a dep description */
 401                                 const char *mods;
 402                                 char *modpath;
 403                                 char *mod;
 404
 405                                 /* Find the beginning of the module file name */
 406                                 *col = '\0';
 407                                 mods = bb_basename(line_buffer);
 408
 409                                 /* find the path of the module */
 410                                 modpath = strchr(line_buffer, '/'); /* ... and this is the path */
 411                                 if (!modpath)
 412                                         modpath = line_buffer; /* module with no path */
 413                                 /* find the end of the module name in the file name */
 414                                 if (ENABLE_FEATURE_2_6_MODULES &&
 415                                     (k_version > 4) && (col[-3] == '.') &&
 416                                     (col[-2] == 'k') && (col[-1] == 'o'))
 417                                         dot = col - 3;
 418                                 else if ((col[-2] == '.') && (col[-1] == 'o'))
 419                                         dot = col - 2;
 420
 421                                 mod = xstrndup(mods, dot - mods);
 422
 423                                 /* enqueue new module */
 424                                 if (!current) {
 425                                         first = current = xzalloc(sizeof(struct dep_t));
 426                                 } else {
 427                                         current->m_next = xzalloc(sizeof(struct dep_t));
 428                                         current = current->m_next;
 429                                 }
 430                                 current->m_name = mod;
 431                                 current->m_path = xstrdup(modpath);
 432                                 /*current->m_options = NULL; - xzalloc did it*/
 433                                 /*current->m_isalias = 0;*/
 434                                 /*current->m_depcnt = 0;*/
 435                                 /*current->m_deparr = 0;*/
 436                                 /*current->m_next = 0;*/
 437
 438                                 p = col + 1;
 439                         } else
 440                                 /* this line is not a dep description */
 441                                 p = NULL;
 442                 } else
 443                         /* It's a dep description continuation */
 444                         p = line_buffer;
 445
 446                 while (p && *p && isblank(*p))
 447                         p++;
 448
 449                 /* p points to the first dependable module; if NULL, no dependable module */
 450                 if (p && *p) {
 451                         char *end = &line_buffer[l-1];
 452                         const char *deps;
 453                         char *dep;
 454                         char *next;
 455                         int ext = 0;
 456
 457                         while (isblank(*end) || (*end == '\\'))
 458                                 end--;
 459
 460                         do {
 461                                 /* search the end of the dependency */
 462                                 next = strchr(p, ' ');
 463                                 if (next) {
 464                                         *next = '\0';
 465                                         next--;
 466                                 } else
 467                                         next = end;
 468
 469                                 /* find the beginning of the module file name */
 470                                 deps = bb_basename(p);
 471                                 if (deps == p) {
 472                                         while (isblank(*deps))
 473                                                 deps++;
 474                                 }
 475
 476                                 /* find the end of the module name in the file name */
 477                                 if (ENABLE_FEATURE_2_6_MODULES
 478                                  && (k_version > 4) && (next[-2] == '.')
 479                                  && (next[-1] == 'k') && (next[0] == 'o'))
 480                                         ext = 3;
 481                                 else if ((next[-1] == '.') && (next[0] == 'o'))
 482                                         ext = 2;
 483
 484                                 /* Cope with blank lines */
 485                                 if ((next-deps-ext+1) <= 0)
 486                                         continue;
 487                                 dep = xstrndup(deps, next - deps - ext + 1);
 488
 489                                 /* Add the new dependable module name */
 490                                 current->m_depcnt++;
 491                                 current->m_deparr = xrealloc(current->m_deparr,
 492                                                 sizeof(char *) * current->m_depcnt);
 493                                 current->m_deparr[current->m_depcnt - 1] = dep;
 494
 495                                 p = next + 2;
 496                         } while (next < end);
 497                 }
 498
 499                 /* is there other dependable module(s) ? */
 500                 continuation_line = (line_buffer[l-1] == '\\');
 501         } /* while (reads(...)) */
 502         close(fd);
 503
 504         /*
 505          * First parse system-specific options and aliases
 506          * as they take precedence over the kernel ones.
 507          * >=2.6: we only care about modprobe.conf
 508          * <=2.4: we care about modules.conf and conf.modules
 509          */
 510         if (ENABLE_FEATURE_2_6_MODULES
 511          && (fd = open("/etc/modprobe.conf", O_RDONLY)) < 0)
 512                 if (ENABLE_FEATURE_2_4_MODULES
 513                  && (fd = open("/etc/modules.conf", O_RDONLY)) < 0)
 514                         if (ENABLE_FEATURE_2_4_MODULES)
 515                                 fd = open("/etc/conf.modules", O_RDONLY);
 516
 517         if (fd >= 0) {
 518                 include_conf(&first, &current, line_buffer, sizeof(line_buffer), fd);
 519                 close(fd);
 520         }
 521
 522         /* Only 2.6 has a modules.alias file */
 523         if (ENABLE_FEATURE_2_6_MODULES) {
 524                 /* Parse kernel-declared module aliases */
 525                 filename = xasprintf(CONFIG_DEFAULT_MODULES_DIR"/%s/modules.alias", un.release);
 526                 fd = open(filename, O_RDONLY);
 527                 if (fd < 0) {
 528                         /* Ok, that didn't work.  Fall back to looking in /lib/modules */
 529                         fd = open(CONFIG_DEFAULT_MODULES_DIR"/modules.alias", O_RDONLY);
 530                 }
 531                 if (ENABLE_FEATURE_CLEAN_UP)
 532                         free(filename);
 533
 534                 if (fd >= 0) {
 535                         include_conf(&first, &current, line_buffer, sizeof(line_buffer), fd);
 536                         close(fd);
 537                 }
 538
 539                 /* Parse kernel-declared symbol aliases */
 540                 filename = xasprintf(CONFIG_DEFAULT_MODULES_DIR"/%s/modules.symbols", un.release);
 541                 fd = open(filename, O_RDONLY);
 542                 if (fd < 0) {
 543                         /* Ok, that didn't work.  Fall back to looking in /lib/modules */
 544                         fd = open(CONFIG_DEFAULT_MODULES_DIR"/modules.symbols", O_RDONLY);
 545                 }
 546                 if (ENABLE_FEATURE_CLEAN_UP)
 547                         free(filename);
 548
 549                 if (fd >= 0) {
 550                         include_conf(&first, &current, line_buffer, sizeof(line_buffer), fd);
 551                         close(fd);
 552                 }
 553         }
 554
 555         return first;
 556 }
 557
 558 /* return 1 = loaded, 0 = not loaded, -1 = can't tell */
 559 static int already_loaded(const char *name)
 560 {
 561         int fd, ret = 0;
 562
 563         fd = open("/proc/modules", O_RDONLY);
 564         if (fd < 0)
 565                 return -1;
 566
 567         while (reads(fd, line_buffer, sizeof(line_buffer))) {
 568                 char *p;
 569
 570                 p = strchr(line_buffer, ' ');
 571                 if (p) {
 572                         const char *n;
 573
 574                         // Truncate buffer at first space and check for matches, with
 575                         // the idiosyncrasy that _ and - are interchangeable because the
 576                         // 2.6 kernel does weird things.
 577
 578                         *p = '\0';
 579                         for (p = line_buffer, n = name; ; p++, n++) {
 580                                 if (*p != *n) {
 581                                         if ((*p == '_' || *p == '-') && (*n == '_' || *n == '-'))
 582                                                 continue;
 583                                         break;
 584                                 }
 585                                 // If we made it to the end, that's a match.
 586                                 if (!*p) {
 587                                         ret = 1;
 588                                         goto done;
 589                                 }
 590                         }
 591                 }
 592         }
 593  done:
 594         close(fd);
 595         return ret;
 596 }
 597
 598 static int mod_process(const struct mod_list_t *list, int do_insert)
 599 {
 600         int rc = 0;
 601         char **argv = NULL;
 602         struct mod_opt_t *opts;
 603         int argc_malloc; /* never used when CONFIG_FEATURE_CLEAN_UP not defined */
 604         int argc;
 605
 606         while (list) {
 607                 argc = 0;
 608                 if (ENABLE_FEATURE_CLEAN_UP)
 609                         argc_malloc = 0;
 610                 /* If CONFIG_FEATURE_CLEAN_UP is not defined, then we leak memory
 611                  * each time we allocate memory for argv.
 612                  * But it is (quite) small amounts of memory that leak each
 613                  * time a module is loaded,  and it is reclaimed when modprobe
 614                  * exits anyway (even when standalone shell?).
 615                  * This could become a problem when loading a module with LOTS of
 616                  * dependencies, with LOTS of options for each dependencies, with
 617                  * very little memory on the target... But in that case, the module
 618                  * would not load because there is no more memory, so there's no
 619                  * problem. */
 620                 /* enough for minimal insmod (5 args + NULL) or rmmod (3 args + NULL) */
 621                 argv = xmalloc(6 * sizeof(char*));
 622                 if (do_insert) {
 623                         if (already_loaded(list->m_name) != 1) {
 624                                 argv[argc++] = (char*)"insmod";
 625                                 if (ENABLE_FEATURE_2_4_MODULES) {
 626                                         if (do_syslog)
 627                                                 argv[argc++] = (char*)"-s";
 628                                         if (autoclean)
 629                                                 argv[argc++] = (char*)"-k";
 630                                         if (quiet)
 631                                                 argv[argc++] = (char*)"-q";
 632                                         else if (verbose) /* verbose and quiet are mutually exclusive */
 633                                                 argv[argc++] = (char*)"-v";
 634                                 }
 635                                 argv[argc++] = list->m_path;
 636                                 if (ENABLE_FEATURE_CLEAN_UP)
 637                                         argc_malloc = argc;
 638                                 opts = list->m_options;
 639                                 while (opts) {
 640                                         /* Add one more option */
 641                                         argc++;
 642                                         argv = xrealloc(argv, (argc + 1) * sizeof(char*));
 643                                         argv[argc-1] = opts->m_opt_val;
 644                                         opts = opts->m_next;
 645                                 }
 646                         }
 647                 } else {
 648                         /* modutils uses short name for removal */
 649                         if (already_loaded(list->m_name) != 0) {
 650                                 argv[argc++] = (char*)"rmmod";
 651                                 if (do_syslog)
 652                                         argv[argc++] = (char*)"-s";
 653                                 argv[argc++] = (char*)list->m_name;
 654                                 if (ENABLE_FEATURE_CLEAN_UP)
 655                                         argc_malloc = argc;
 656                         }
 657                 }
 658                 argv[argc] = NULL;
 659
 660                 if (argc) {
 661                         if (verbose) {
 662                                 printf("%s module %s\n", do_insert?"Loading":"Unloading", list->m_name);
 663                         }
 664                         if (!show_only) {
 665                                 int rc2 = wait4pid(spawn(argv));
 666
 667                                 if (do_insert) {
 668                                         rc = rc2; /* only last module matters */
 669                                 } else if (!rc2) {
 670                                         rc = 0; /* success if remove any mod */
 671                                 }
 672                         }
 673                         if (ENABLE_FEATURE_CLEAN_UP) {
 674                                 /* the last value in the array has index == argc, but
 675                                  * it is the terminating NULL, so we must not free it. */
 676                                 while (argc_malloc < argc) {
 677                                         free(argv[argc_malloc++]);
 678                                 }
 679                         }
 680                 }
 681                 if (ENABLE_FEATURE_CLEAN_UP) {
 682                         free(argv);
 683                         argv = NULL;
 684                 }
 685                 list = do_insert ? list->m_prev : list->m_next;
 686         }
 687         return (show_only) ? 0 : rc;
 688 }
 689
 690 /*
 691  * Check the matching between a pattern and a module name.
 692  * We need this as *_* is equivalent to *-*, even in pattern matching.
 693  */
 694 static int check_pattern(const char* pat_src, const char* mod_src)
 695 {
 696         int ret;
 697
 698         if (ENABLE_FEATURE_MODPROBE_FANCY_ALIAS) {
 699                 char* pat;
 700                 char* mod;
 701                 char* p;
 702
 703                 pat = xstrdup(pat_src);
 704                 mod = xstrdup(mod_src);
 705
 706                 for (p = pat; (p = strchr(p, '-')); *p++ = '_');
 707                 for (p = mod; (p = strchr(p, '-')); *p++ = '_');
 708
 709                 ret = fnmatch(pat, mod, 0);
 710
 711                 if (ENABLE_FEATURE_CLEAN_UP) {
 712                         free(pat);
 713                         free(mod);
 714                 }
 715
 716                 return ret;
 717         }
 718         return fnmatch(pat_src, mod_src, 0);
 719 }
 720
 721 /*
 722  * Builds the dependency list (aka stack) of a module.
 723  * head: the highest module in the stack (last to insmod, first to rmmod)
 724  * tail: the lowest module in the stack (first to insmod, last to rmmod)
 725  */
 726 static void check_dep(char *mod, struct mod_list_t **head, struct mod_list_t **tail)
 727 {
 728         struct mod_list_t *find;
 729         struct dep_t *dt;
 730         struct mod_opt_t *opt = NULL;
 731         char *path = NULL;
 732
 733         /* Search for the given module name amongst all dependency rules.
 734          * The module name in a dependency rule can be a shell pattern,
 735          * so try to match the given module name against such a pattern.
 736          * Of course if the name in the dependency rule is a plain string,
 737          * then we consider it a pattern, and matching will still work. */
 738         for (dt = depend; dt; dt = dt->m_next) {
 739                 if (check_pattern(dt->m_name, mod) == 0) {
 740                         break;
 741                 }
 742         }
 743
 744         if (!dt) {
 745                 bb_error_msg("module %s not found", mod);
 746                 return;
 747         }
 748
 749         // resolve alias names
 750         while (dt->m_isalias) {
 751                 if (dt->m_depcnt == 1) {
 752                         struct dep_t *adt;
 753
 754                         for (adt = depend; adt; adt = adt->m_next) {
 755                                 if (check_pattern(adt->m_name, dt->m_deparr[0]) == 0 &&
 756                                                 !(ENABLE_FEATURE_MODPROBE_BLACKLIST &&
 757                                                         adt->m_isblacklisted))
 758                                         break;
 759                         }
 760                         if (adt) {
 761                                 /* This is the module we are aliased to */
 762                                 struct mod_opt_t *opts = dt->m_options;
 763                                 /* Option of the alias are appended to the options of the module */
 764                                 while (opts) {
 765                                         adt->m_options = append_option(adt->m_options, opts->m_opt_val);
 766                                         opts = opts->m_next;
 767                                 }
 768                                 dt = adt;
 769                         } else {
 770                                 bb_error_msg("module %s not found", mod);
 771                                 return;
 772                         }
 773                 } else {
 774                         bb_error_msg("bad alias %s", dt->m_name);
 775                         return;
 776                 }
 777         }
 778
 779         mod = dt->m_name;
 780         path = dt->m_path;
 781         opt = dt->m_options;
 782
 783         // search for duplicates
 784         for (find = *head; find; find = find->m_next) {
 785                 if (strcmp(mod, find->m_name) == 0) {
 786                         // found -> dequeue it
 787
 788                         if (find->m_prev)
 789                                 find->m_prev->m_next = find->m_next;
 790                         else
 791                                 *head = find->m_next;
 792
 793                         if (find->m_next)
 794                                 find->m_next->m_prev = find->m_prev;
 795                         else
 796                                 *tail = find->m_prev;
 797
 798                         break; // there can be only one duplicate
 799                 }
 800         }
 801
 802         if (!find) { // did not find a duplicate
 803                 find = xzalloc(sizeof(struct mod_list_t));
 804                 find->m_name = mod;
 805                 find->m_path = path;
 806                 find->m_options = opt;
 807         }
 808
 809         // enqueue at tail
 810         if (*tail)
 811                 (*tail)->m_next = find;
 812         find->m_prev = *tail;
 813         find->m_next = NULL; /* possibly NOT done by xzalloc! */
 814
 815         if (!*head)
 816                 *head = find;
 817         *tail = find;
 818
 819         if (dt) {
 820                 int i;
 821
 822                 /* Add all dependable module for that new module */
 823                 for (i = 0; i < dt->m_depcnt; i++)
 824                         check_dep(dt->m_deparr[i], head, tail);
 825         }
 826 }
 827
 828 static int mod_insert(char *mod, int argc, char **argv)
 829 {
 830         struct mod_list_t *tail = NULL;
 831         struct mod_list_t *head = NULL;
 832         int rc;
 833
 834         // get dep list for module mod
 835         check_dep(mod, &head, &tail);
 836
 837         rc = 1;
 838         if (head && tail) {
 839                 if (argc) {
 840                         int i;
 841                         // append module args
 842                         for (i = 0; i < argc; i++)
 843                                 head->m_options = append_option(head->m_options, argv[i]);
 844                 }
 845
 846                 // process tail ---> head
 847                 rc = mod_process(tail, 1);
 848                 if (rc) {
 849                         /*
 850                          * In case of using udev, multiple instances of modprobe can be
 851                          * spawned to load the same module (think of two same usb devices,
 852                          * for example; or cold-plugging at boot time). Thus we shouldn't
 853                          * fail if the module was loaded, and not by us.
 854                          */
 855                         if (already_loaded(mod))
 856                                 rc = 0;
 857                 }
 858         }
 859         return rc;
 860 }
 861
 862 static int mod_remove(char *mod)
 863 {
 864         int rc;
 865         static const struct mod_list_t rm_a_dummy = { "-a", NULL, NULL, NULL, NULL };
 866
 867         struct mod_list_t *head = NULL;
 868         struct mod_list_t *tail = NULL;
 869
 870         if (mod)
 871                 check_dep(mod, &head, &tail);
 872         else  // autoclean
 873                 head = tail = (struct mod_list_t*) &rm_a_dummy;
 874
 875         rc = 1;
 876         if (head && tail)
 877                 rc = mod_process(head, 0);  // process head ---> tail
 878         return rc;
 879 }
 880
 881 int modprobe_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 882 int modprobe_main(int argc, char **argv)
 883 {
 884         int rc = EXIT_SUCCESS;
 885         char *unused;
 886
 887         opt_complementary = "q-v:v-q";
 888         getopt32(argv, MAIN_OPT_STR, &unused, &unused);
 889
 890         if (option_mask32 & (DUMP_CONF_EXIT | LIST_ALL))
 891                 return EXIT_SUCCESS;
 892         if (option_mask32 & (RESTRICT_DIR | CONFIG_FILE))
 893                 bb_error_msg_and_die("-t and -C not supported");
 894
 895         depend = build_dep();
 896
 897         if (!depend)
 898                 bb_error_msg_and_die("cannot parse "CONFIG_DEFAULT_DEPMOD_FILE);
 899
 900         if (remove_opt) {
 901                 do {
 902                         /* argv[optind] can be NULL here */
 903                         if (mod_remove(argv[optind])) {
 904                                 bb_error_msg("failed to remove module %s",
 905                                                 argv[optind]);
 906                                 rc = EXIT_FAILURE;
 907                         }
 908                 } while (++optind < argc);
 909         } else {
 910                 if (optind >= argc)
 911                         bb_error_msg_and_die("no module or pattern provided");
 912
 913                 if (mod_insert(argv[optind], argc - optind - 1, argv + optind + 1))
 914                         bb_error_msg_and_die("failed to load module %s", argv[optind]);
 915         }
 916
 917         /* Here would be a good place to free up memory allocated during the dependencies build. */
 918
 919         return rc;
 920 }