release/src/router/hotplug2/linux24_compat/hotplug2-modwrap.c

   1 /*****************************************************************************\
   2 *  _  _       _          _              ___                                   *
   3 * | || | ___ | |_  _ __ | | _  _  __ _ |_  )                                  *
   4 * | __ |/ _ \|  _|| '_ \| || || |/ _` | / /                                   *
   5 * |_||_|\___/ \__|| .__/|_| \_,_|\__, |/___|                                  *
   6 *                 |_|            |___/                                        *
   7 \*****************************************************************************/
   8
   9 #define _GNU_SOURCE
  10
  11 #include <fcntl.h>
  12 #include <stdio.h>
  13 #include <unistd.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <errno.h>
  17 #include <dirent.h>
  18 #include <ctype.h>
  19 #include <fnmatch.h>
  20 #include <sys/types.h>
  21 #include <sys/wait.h>
  22 #include <sys/stat.h>
  23 #include <sys/mman.h>
  24 #include <sys/utsname.h>
  25 #include <linux/types.h>
  26 #include <linux/input.h>
  27
  28 #include "../hotplug2.h"
  29 #include "../mem_utils.h"
  30 #include "../parser_utils.h"
  31 #include "../filemap_utils.h"
  32
  33 #define MODULES_PATH            "/lib/modules/"
  34 #define MODULES_ALIAS           "modules.alias"
  35
  36 /**
  37  * A simple fork/exec wrapper
  38  *
  39  * @1 Complete argv, including app path
  40  *
  41  * Returns: -1 if error, children return value otherwise
  42  */
  43 int execute(char **argv) {
  44         pid_t p;
  45         int status;
  46
  47         p = fork();
  48         switch (p) {
  49                 case -1:
  50                         return -1;
  51                 case 0:
  52                         execvp(argv[0], argv);
  53                         exit(1);
  54                         break;
  55                 default:
  56                         waitpid(p, &status, 0);
  57                         break;
  58         }
  59
  60         return WEXITSTATUS(status);
  61 }
  62
  63 int main(int argc, char *argv[]) {
  64         struct utsname unamebuf;
  65         struct filemap_t aliasmap;
  66         char *line, *nline, *nptr;
  67         char *token;
  68         char *filename;
  69
  70         char *cur_alias, *match_alias, *module;
  71
  72         if (argc < 2) {
  73                 fprintf(stderr, "Usage: hotplug2-modwrap [options for modprobe] <alias>\n");
  74         }
  75
  76         match_alias = strdup(argv[argc - 1]);
  77
  78         /*
  79          * If we can't do uname, we're absolutely screwed and there's no
  80          * sense thinking twice about anything.
  81          */
  82         if (uname(&unamebuf)) {
  83                 ERROR("uname", "Unable to perform uname: %s.", strerror(errno));
  84                 return 1;
  85         }
  86
  87         /*
  88          * We allow setting the modprobe command to an arbitrary value.
  89          *
  90          * The whole trick lies in executing modprobe with exactly the
  91          * same argv as this app was executed, except we use a different
  92          * argv[0] (application path) and argv[argc-1] (we substitute
  93          * the given modalias by the matching module name)
  94          */
  95         argv[0] = getenv("MODPROBE_COMMAND");
  96         if (argv[0] == NULL)
  97                 argv[0] = "/sbin/modprobe";
  98
  99         /*
 100          * Compose a path, /lib/modules/`uname -r`/modules.alias
 101          *
 102          * "/lib/modules/" + "/" + "\0"
 103          */
 104         filename = xmalloc(strlen(MODULES_PATH) + strlen(unamebuf.release) + strlen(MODULES_ALIAS));
 105         strcpy(filename, MODULES_PATH);
 106         strcat(filename, unamebuf.release);
 107         strcat(filename, MODULES_ALIAS);
 108
 109         if (map_file(filename, &aliasmap)) {
 110                 ERROR("map_file", "Unable to map file: `%s'.", filename);
 111                 free(filename);
 112                 free(match_alias);
 113                 return 1;
 114         }
 115
 116         /*
 117          * Read all the aliases, match them against given parameter.
 118          */
 119         nptr = aliasmap.map;
 120         while ((line = dup_line(nptr, &nptr)) != NULL) {
 121                 nline = line;
 122
 123                 /*
 124                  * We want aliases only
 125                  */
 126                 token = dup_token(nline, &nline, isspace);
 127                 if (!token || strcmp(token, "alias")) {
 128                         free(token);
 129                         free(line);
 130                         continue;
 131                 }
 132                 free(token);
 133
 134                 /*
 135                  * It's an alias, so fetch it
 136                  */
 137                 cur_alias = dup_token(nline, &nline, isspace);
 138                 if (!cur_alias) {
 139                         free(line);
 140                         continue;
 141                 }
 142
 143                 /*
 144                  * And now we get the module name
 145                  */
 146                 module = dup_token(nline, &nline, isspace);
 147                 if (!module) {
 148                         free(line);
 149                         free(cur_alias);
 150                         continue;
 151                 }
 152
 153                 /*
 154                  * If we match, we do the modalias->module name
 155                  * substitution as described above and execute.
 156                  */
 157                 if (!fnmatch(cur_alias, match_alias, 0)) {
 158                         argv[argc - 1] = module;
 159                         if (execute(argv)) {
 160                                 ERROR("execute", "Error during exection of: `%s'.", argv[0]);
 161                         }
 162                 }
 163
 164                 free(cur_alias);
 165                 free(module);
 166                 free(line);
 167         }
 168
 169         /*
 170          * Perhaps we didn't match anything, so we might've been given
 171          * a module name instead of a modalias. Try to modprobe it
 172          * right away.
 173          */
 174         if (strcmp(argv[argc - 1], match_alias) == 0) {
 175                 if (execute(argv)) {
 176                         ERROR("execute", "Error during exection of: `%s'.", argv[0]);
 177                 }
 178         }
 179
 180         free(filename);
 181         free(match_alias);
 182         unmap_file(&aliasmap);
 183
 184         return 0;
 185 }