+ /* Any other char that is special shall appear here.
+ * Example: $ starts a variable
+ case '$':
+ do_variable_expansion();
+ break;
+ * */
+ default:
+ /* any other char is kept as is. */
+ break;
+ }
+ tmp_str++; /* Go to next char */
+ src++; /* Go to next char to find the end of the argument. */
+ }
+ /* End of string, but still no ending quote */
+ if( opt_status & ( ARG_IN_DQUOTES | ARG_IN_SQUOTES ) ) {
+ bb_error_msg_and_die( "unterminated (single or double) quote in options list: %s", src );
+ }
+ *tmp_str++ = '\0';
+ *dst = xrealloc( *dst, (tmp_str - *dst ) );
+ return src;
+}
+#else
+#define parse_command_string(src, dst) (0)
+#endif /* ENABLE_FEATURE_MODPROBE_MULTIPLE_OPTIONS */
+
+/*
+ * This function reads aliases and default module options from a configuration file
+ * (/etc/modprobe.conf syntax). It supports includes (only files, no directories).
+ */
+static void include_conf ( struct dep_t **first, struct dep_t **current, char *buffer, int buflen, int fd )
+{
+ int continuation_line = 0;
+
+ // alias parsing is not 100% correct (no correct handling of continuation lines within an alias) !
+
+ while ( reads ( fd, buffer, buflen)) {
+ int l;
+ char *p;
+
+ p = strchr ( buffer, '#' );
+ if ( p )
+ *p = 0;
+
+ l = strlen ( buffer );
+
+ while ( l && isspace ( buffer [l-1] )) {
+ buffer [l-1] = 0;
+ l--;
+ }
+
+ if ( l == 0 ) {
+ continuation_line = 0;
+ continue;
+ }
+
+ if ( !continuation_line ) {
+ if (( strncmp ( buffer, "alias", 5 ) == 0 ) && isspace ( buffer [5] )) {
+ char *alias, *mod;
+
+ if ( parse_tag_value ( buffer + 6, &alias, &mod )) {
+ /* handle alias as a module dependent on the aliased module */
+ if ( !*current ) {
+ (*first) = (*current) = (struct dep_t *) xcalloc ( 1, sizeof ( struct dep_t ));
+ }
+ else {
+ (*current)-> m_next = (struct dep_t *) xcalloc ( 1, sizeof ( struct dep_t ));
+ (*current) = (*current)-> m_next;
+ }
+ (*current)-> m_name = bb_xstrdup ( alias );
+ (*current)-> m_isalias = 1;
+
+ if (( strcmp ( mod, "off" ) == 0 ) || ( strcmp ( mod, "null" ) == 0 )) {
+ (*current)-> m_depcnt = 0;
+ (*current)-> m_deparr = 0;
+ }
+ else {
+ (*current)-> m_depcnt = 1;
+ (*current)-> m_deparr = xmalloc ( 1 * sizeof( char * ));
+ (*current)-> m_deparr[0] = bb_xstrdup ( mod );
+ }
+ (*current)-> m_next = 0;
+ }
+ }
+ else if (( strncmp ( buffer, "options", 7 ) == 0 ) && isspace ( buffer [7] )) {
+ char *mod, *opt;
+
+ /* split the line in the module/alias name, and options */
+ if ( parse_tag_value ( buffer + 8, &mod, &opt )) {
+ struct dep_t *dt;
+
+ /* find the corresponding module */
+ for ( dt = *first; dt; dt = dt-> m_next ) {
+ if ( strcmp ( dt-> m_name, mod ) == 0 )
+ break;
+ }
+ if ( dt ) {
+ if ( ENABLE_FEATURE_MODPROBE_MULTIPLE_OPTIONS ) {
+ char* new_opt = NULL;
+ while( ( opt = parse_command_string( opt, &new_opt ) ) ) {
+ dt-> m_options = append_option( dt-> m_options, new_opt );
+ }
+ } else {
+ dt-> m_options = append_option( dt-> m_options, opt );
+ }
+ }
+ }
+ }
+ else if (( strncmp ( buffer, "include", 7 ) == 0 ) && isspace ( buffer [7] )) {
+
+ int fdi; char *filename = buffer + 8;
+
+ while ( isspace ( *filename ))
+ filename++;
+
+ if (( fdi = open ( filename, O_RDONLY )) >= 0 ) {
+ include_conf(first, current, buffer, buflen, fdi);
+ close(fdi);
+ }
+ }
+ }
+ }
+}
+
+/*
+ * This function builds a list of dependency rules from /lib/modules/`uname -r`\modules.dep.
+ * It then fills every modules and aliases with their default options, found by parsing
+ * modprobe.conf (or modules.conf, or conf.modules).
+ */
+static struct dep_t *build_dep ( void )
+{
+ int fd;
+ struct utsname un;
+ struct dep_t *first = 0;
+ struct dep_t *current = 0;
+ char buffer[2048];
+ char *filename;
+ int continuation_line = 0;
+ int k_version;
+
+ k_version = 0;
+ if ( uname ( &un ))
+ bb_error_msg_and_die("can't determine kernel version");
+
+ if (un.release[0] == '2') {
+ k_version = un.release[2] - '0';
+ }
+
+ filename = bb_xasprintf("/lib/modules/%s/modules.dep", un.release );
+ fd = open ( filename, O_RDONLY );
+ if (ENABLE_FEATURE_CLEAN_UP)
+ free(filename);
+ if (fd < 0) {
+ /* Ok, that didn't work. Fall back to looking in /lib/modules */
+ if (( fd = open ( "/lib/modules/modules.dep", O_RDONLY )) < 0 ) {
+ return 0;
+ }
+ }
+
+ while ( reads ( fd, buffer, sizeof( buffer ))) {
+ int l = strlen ( buffer );
+ char *p = 0;
+
+ while ( l > 0 && isspace ( buffer [l-1] )) {
+ buffer [l-1] = 0;
+ l--;
+ }
+
+ if ( l == 0 ) {
+ continuation_line = 0;
+ continue;
+ }
+
+ /* Is this a new module dep description? */
+ if ( !continuation_line ) {
+ /* find the dep beginning */
+ char *col = strchr ( buffer, ':' );
+ char *dot = col;
+
+ if ( col ) {
+ /* This line is a dep description */
+ char *mods;
+ char *modpath;
+ char *mod;
+
+ /* Find the beginning of the module file name */
+ *col = 0;
+ mods = strrchr ( buffer, '/' );
+
+ if ( !mods )
+ mods = buffer; /* no path for this module */
+ else
+ mods++; /* there was a path for this module... */
+
+ /* find the path of the module */
+ modpath = strchr ( buffer, '/' ); /* ... and this is the path */
+ if ( !modpath )
+ modpath = buffer; /* module with no path */
+ /* find the end of the module name in the file name */
+ if ( ENABLE_FEATURE_2_6_MODULES &&
+ (k_version > 4) && ( *(col-3) == '.' ) &&
+ ( *(col-2) == 'k' ) && ( *(col-1) == 'o' ) )
+ dot = col - 3;
+ else
+ if (( *(col-2) == '.' ) && ( *(col-1) == 'o' ))
+ dot = col - 2;
+
+ mod = bb_xstrndup ( mods, dot - mods );
+
+ /* enqueue new module */
+ if ( !current ) {
+ first = current = (struct dep_t *) xmalloc ( sizeof ( struct dep_t ));
+ }
+ else {
+ current-> m_next = (struct dep_t *) xmalloc ( sizeof ( struct dep_t ));
+ current = current-> m_next;
+ }
+ current-> m_name = mod;
+ current-> m_path = bb_xstrdup(modpath);
+ current-> m_options = NULL;
+ current-> m_isalias = 0;
+ current-> m_depcnt = 0;
+ current-> m_deparr = 0;
+ current-> m_next = 0;
+
+ p = col + 1;
+ }
+ else
+ /* this line is not a dep description */
+ p = 0;
+ }
+ else
+ /* It's a dep description continuation */
+ p = buffer;
+
+ while ( p && *p && isblank(*p))
+ p++;
+
+ /* p points to the first dependable module; if NULL, no dependable module */
+ if ( p && *p ) {
+ char *end = &buffer [l-1];
+ char *deps;
+ char *dep;
+ char *next;
+ int ext = 0;
+
+ while ( isblank ( *end ) || ( *end == '\\' ))
+ end--;
+
+ do
+ {
+ /* search the end of the dependency */
+ next = strchr (p, ' ' );
+ if (next)
+ {
+ *next = 0;
+ next--;
+ }
+ else
+ next = end;
+
+ /* find the beginning of the module file name */
+ deps = strrchr ( p, '/' );
+
+ if ( !deps || ( deps < p )) {
+ deps = p;
+
+ while ( isblank ( *deps ))
+ deps++;
+ }
+ else
+ deps++;
+
+ /* find the end of the module name in the file name */
+ if ( ENABLE_FEATURE_2_6_MODULES &&
+ (k_version > 4) && ( *(next-2) == '.' ) &&
+ ( *(next-1) == 'k' ) && ( *next == 'o' ) )
+ ext = 3;
+ else
+ if (( *(next-1) == '.' ) && ( *next == 'o' ))
+ ext = 2;
+
+ /* Cope with blank lines */
+ if ((next-deps-ext+1) <= 0)
+ continue;
+ dep = bb_xstrndup ( deps, next - deps - ext + 1 );
+
+ /* Add the new dependable module name */
+ current-> m_depcnt++;
+ current-> m_deparr = (char **) xrealloc ( current-> m_deparr,
+ sizeof ( char *) * current-> m_depcnt );
+ current-> m_deparr [current-> m_depcnt - 1] = dep;
+
+ p = next + 2;
+ } while (next < end);
+ }
+
+ /* is there other dependable module(s) ? */
+ if ( buffer [l-1] == '\\' )
+ continuation_line = 1;
+ else
+ continuation_line = 0;
+ }
+ close ( fd );
+
+ if (!ENABLE_FEATURE_2_6_MODULES
+ || ( fd = open ( "/etc/modprobe.conf", O_RDONLY )) < 0 )
+ if (( fd = open ( "/etc/modules.conf", O_RDONLY )) < 0 )
+ if (( fd = open ( "/etc/conf.modules", O_RDONLY )) < 0 )
+ return first;
+
+ include_conf (&first, ¤t, buffer, sizeof(buffer), fd);
+ close(fd);
+
+ filename = bb_xasprintf("/lib/modules/%s/modules.alias", un.release);
+ fd = open ( filename, O_RDONLY );
+ if (ENABLE_FEATURE_CLEAN_UP)
+ free(filename);
+ if (fd < 0) {
+ /* Ok, that didn't work. Fall back to looking in /lib/modules */
+ if (( fd = open ( "/lib/modules/modules.alias", O_RDONLY )) < 0 ) {
+ return first;
+ }
+ }
+
+ include_conf (&first, ¤t, buffer, sizeof(buffer), fd);
+ close(fd);
+
+ return first;
+}
+
+/* return 1 = loaded, 0 = not loaded, -1 = can't tell */
+static int already_loaded (const char *name)
+{
+ int fd;
+ char buffer[4096];
+
+ fd = open ("/proc/modules", O_RDONLY);
+ if (fd < 0)
+ return -1;
+
+ while ( reads ( fd, buffer, sizeof( buffer ))) {
+ char *p;
+
+ p = strchr (buffer, ' ');
+ if (p) {
+ *p = 0;
+ for( p = buffer; ENABLE_FEATURE_2_6_MODULES && *p; p++ ) {
+ *p = ((*p)=='-')?'_':*p;
+ }
+ if (strcmp (name, buffer) == 0) {
+ close (fd);
+ return 1;
+ }
+ }
+ }
+
+ close (fd);
+ return 0;
+}
+
+static int mod_process ( struct mod_list_t *list, int do_insert )
+{
+ int rc = 0;
+ char **argv = NULL;
+ struct mod_opt_t *opts;
+ int argc_malloc; /* never used when CONFIG_FEATURE_CLEAN_UP not defined */
+ int argc;
+
+ while ( list ) {
+ argc = 0;
+ if( ENABLE_FEATURE_CLEAN_UP )
+ argc_malloc = 0;
+ /* If CONFIG_FEATURE_CLEAN_UP is not defined, then we leak memory
+ * each time we allocate memory for argv.
+ * But it is (quite) small amounts of memory that leak each
+ * time a module is loaded, and it is reclaimed when modprobe
+ * exits anyway (even when standalone shell?).
+ * This could become a problem when loading a module with LOTS of
+ * dependencies, with LOTS of options for each dependencies, with
+ * very little memory on the target... But in that case, the module
+ * would not load because there is no more memory, so there's no
+ * problem. */
+ /* enough for minimal insmod (5 args + NULL) or rmmod (3 args + NULL) */
+ argv = (char**) malloc( 6 * sizeof( char* ) );
+ if ( do_insert ) {
+ if (already_loaded (list->m_name) != 1) {
+ argv[argc++] = "insmod";
+ if (do_syslog)
+ argv[argc++] = "-s";
+ if (autoclean)
+ argv[argc++] = "-k";
+ if (quiet)
+ argv[argc++] = "-q";
+ else if(verbose) /* verbose and quiet are mutually exclusive */
+ argv[argc++] = "-v";
+ argv[argc++] = list-> m_path;
+ if( ENABLE_FEATURE_CLEAN_UP )
+ argc_malloc = argc;
+ opts = list-> m_options;
+ while( opts ) {
+ /* Add one more option */
+ argc++;
+ argv = (char**) xrealloc( argv, ( argc + 1 ) * sizeof( char* ) );
+ argv[argc-1] = opts-> m_opt_val;
+ opts = opts-> m_next;
+ }
+ }
+ } else {
+ /* modutils uses short name for removal */
+ if (already_loaded (list->m_name) != 0) {
+ argv[argc++] = "rmmod";
+ if (do_syslog)
+ argv[argc++] = "-s";
+ argv[argc++] = list->m_name;
+ if( ENABLE_FEATURE_CLEAN_UP )
+ argc_malloc = argc;
+ }
+ }
+ argv[argc] = NULL;
+
+ if (argc) {
+ if (verbose) {
+ printf("%s module %s\n", do_insert?"Loading":"Unloading", list-> m_name );
+ }
+ if (!show_only) {
+ int rc2 = 0;
+ int status;
+ switch (fork()) {
+ case -1:
+ rc2 = 1;
+ break;
+ case 0: //child
+ execvp(argv[0], argv);
+ bb_perror_msg_and_die("exec of %s", argv[0]);
+ /* NOTREACHED */
+ default:
+ if (wait(&status) == -1) {
+ rc2 = 1;
+ break;
+ }
+ if (WIFEXITED(status))
+ rc2 = WEXITSTATUS(status);
+ if (WIFSIGNALED(status))
+ rc2 = WTERMSIG(status);
+ break;
+ }
+ if (do_insert) {
+ rc = rc2; /* only last module matters */
+ }
+ else if (!rc2) {
+ rc = 0; /* success if remove any mod */
+ }
+ }
+ if( ENABLE_FEATURE_CLEAN_UP )
+ /* the last value in the array has index == argc, but
+ * it is the terminating NULL, so we must not free it. */
+ while( argc_malloc < argc ) {
+ free( argv[argc_malloc++] );
+ }
+ }
+ if( ENABLE_FEATURE_CLEAN_UP ) {
+ free( argv );
+ argv = NULL;
+ }
+ list = do_insert ? list-> m_prev : list-> m_next;
+ }
+ return (show_only) ? 0 : rc;
+}
+
+/*
+ * Builds the dependency list (aka stack) of a module.
+ * head: the highest module in the stack (last to insmod, first to rmmod)
+ * tail: the lowest module in the stack (first to insmod, last to rmmod)
+ */
+static void check_dep ( char *mod, struct mod_list_t **head, struct mod_list_t **tail )
+{
+ struct mod_list_t *find;
+ struct dep_t *dt;
+ struct mod_opt_t *opt = 0;
+ char *path = 0;
+
+ // check dependencies
+ for ( dt = depend; dt; dt = dt-> m_next ) {
+ if ( strcmp ( dt-> m_name, mod ) == 0) {