blob: ab595c847ec0ec9f5f7812e392e5c9caa22b3a6f [file] [log] [blame]
Eric Andersen0139ca92001-07-22 23:01:03 +00001/* vi: set sw=4 ts=4: */
2/*
Robert Grieblaead70b2002-07-26 15:54:20 +00003 * Modprobe written from scratch for BusyBox
Eric Andersen60e56f52002-04-26 06:04:01 +00004 *
Robert Griebl6859d762002-08-05 02:57:12 +00005 * Copyright (c) 2002 by Robert Griebl, griebl@gmx.de
Eric Andersen908e3622003-06-20 09:56:37 +00006 * Copyright (c) 2003 by Andrew Dennison, andrew.dennison@motec.com.au
Paul Fox8eeb6552005-08-04 18:33:36 +00007 * Copyright (c) 2005 by Jim Bauer, jfbauer@nfr.com
Bernhard Reutner-Fischer17d355c2005-12-14 08:32:44 +00008 *
Rob Landleye9190962005-12-12 19:38:44 +00009 * Portions Copyright (c) 2005 by Yann E. MORIN, yann.morin.1998@anciens.enib.fr
Robert Griebl6859d762002-08-05 02:57:12 +000010 *
Rob Landley79e1cab2005-11-15 00:08:29 +000011 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
Robert Griebl6859d762002-08-05 02:57:12 +000012*/
Eric Andersen0139ca92001-07-22 23:01:03 +000013
Bernhard Reutner-Fischerdeda6a52006-06-03 19:35:15 +000014#include "busybox.h"
Robert Griebl52e8d062002-05-14 23:42:08 +000015#include <sys/utsname.h>
Bernhard Reutner-Fischer2c351a82006-06-03 19:08:49 +000016#include <fnmatch.h>
Eric Andersen0139ca92001-07-22 23:01:03 +000017
Rob Landleye9190962005-12-12 19:38:44 +000018struct mod_opt_t { /* one-way list of options to pass to a module */
19 char * m_opt_val;
20 struct mod_opt_t * m_next;
Eric Andersen60e56f52002-04-26 06:04:01 +000021};
22
Rob Landleye9190962005-12-12 19:38:44 +000023struct dep_t { /* one-way list of dependency rules */
24 /* a dependency rule */
25 char * m_name; /* the module name*/
26 char * m_path; /* the module file path */
27 struct mod_opt_t * m_options; /* the module options */
Bernhard Reutner-Fischer17d355c2005-12-14 08:32:44 +000028
Rob Landleye9190962005-12-12 19:38:44 +000029 int m_isalias : 1; /* the module is an alias */
30 int m_reserved : 15; /* stuffin' */
31
32 int m_depcnt : 16; /* the number of dependable module(s) */
33 char ** m_deparr; /* the list of dependable module(s) */
34
35 struct dep_t * m_next; /* the next dependency rule */
36};
37
38struct mod_list_t { /* two-way list of modules to process */
39 /* a module description */
Eric Andersen807bd842004-08-19 18:30:31 +000040 char * m_name;
41 char * m_path;
Rob Landleye9190962005-12-12 19:38:44 +000042 struct mod_opt_t * m_options;
Eric Andersen3b1a7442003-12-24 20:30:45 +000043
Robert Griebl52e8d062002-05-14 23:42:08 +000044 struct mod_list_t * m_prev;
45 struct mod_list_t * m_next;
46};
47
48
Robert Griebl236abbf2002-05-22 23:34:35 +000049static struct dep_t *depend;
"Vladimir N. Oleynik"4fc92202006-02-02 14:48:54 +000050
51#define main_options "acdklnqrst:vVC:"
52#define INSERT_ALL 1 /* a */
53#define DUMP_CONF_EXIT 2 /* c */
54#define D_OPT_IGNORED 4 /* d */
55#define AUTOCLEAN_FLG 8 /* k */
56#define LIST_ALL 16 /* l */
57#define SHOW_ONLY 32 /* n */
58#define QUIET 64 /* q */
59#define REMOVE_OPT 128 /* r */
60#define DO_SYSLOG 256 /* s */
61#define RESTRICT_DIR 512 /* t */
62#define VERBOSE 1024 /* v */
63#define VERSION_ONLY 2048 /* V */
64#define CONFIG_FILE 4096 /* C */
65
66#define autoclean (main_opts & AUTOCLEAN_FLG)
67#define show_only (main_opts & SHOW_ONLY)
68#define quiet (main_opts & QUIET)
69#define remove_opt (main_opts & REMOVE_OPT)
70#define do_syslog (main_opts & DO_SYSLOG)
71#define verbose (main_opts & VERBOSE)
72
73static int main_opts;
Robert Griebl52e8d062002-05-14 23:42:08 +000074
Eric Andersen14f5c8d2005-04-16 19:39:00 +000075static int parse_tag_value ( char *buffer, char **ptag, char **pvalue )
Robert Grieblaead70b2002-07-26 15:54:20 +000076{
77 char *tag, *value;
78
79 while ( isspace ( *buffer ))
Eric Andersen716ccb22004-01-10 11:29:31 +000080 buffer++;
Robert Grieblaead70b2002-07-26 15:54:20 +000081 tag = value = buffer;
82 while ( !isspace ( *value ))
Eric Andersen7e496a72004-04-06 12:06:03 +000083 if (!*value) return 0;
84 else value++;
Robert Grieblaead70b2002-07-26 15:54:20 +000085 *value++ = 0;
86 while ( isspace ( *value ))
87 value++;
Eric Andersen7e496a72004-04-06 12:06:03 +000088 if (!*value) return 0;
Robert Grieblaead70b2002-07-26 15:54:20 +000089
90 *ptag = tag;
91 *pvalue = value;
Eric Andersen3b1a7442003-12-24 20:30:45 +000092
Eric Andersen7e496a72004-04-06 12:06:03 +000093 return 1;
Robert Grieblaead70b2002-07-26 15:54:20 +000094}
Eric Andersen60e56f52002-04-26 06:04:01 +000095
Rob Landleye9190962005-12-12 19:38:44 +000096/*
97 * This function appends an option to a list
98 */
Bernhard Reutner-Fischer101a4702006-04-03 15:46:14 +000099static struct mod_opt_t *append_option( struct mod_opt_t *opt_list, char *opt )
Eric Andersen60e56f52002-04-26 06:04:01 +0000100{
Rob Landleye9190962005-12-12 19:38:44 +0000101 struct mod_opt_t *ol = opt_list;
Eric Andersen3b1a7442003-12-24 20:30:45 +0000102
Rob Landleye9190962005-12-12 19:38:44 +0000103 if( ol ) {
104 while( ol-> m_next ) {
105 ol = ol-> m_next;
106 }
107 ol-> m_next = xmalloc( sizeof( struct mod_opt_t ) );
108 ol = ol-> m_next;
109 } else {
110 ol = opt_list = xmalloc( sizeof( struct mod_opt_t ) );
Eric Andersen03d80912003-12-19 21:04:19 +0000111 }
Eric Andersen3b1a7442003-12-24 20:30:45 +0000112
Rob Landleyd921b2e2006-08-03 15:41:12 +0000113 ol-> m_opt_val = xstrdup( opt );
Rob Landleye9190962005-12-12 19:38:44 +0000114 ol-> m_next = NULL;
Eric Andersen60e56f52002-04-26 06:04:01 +0000115
Rob Landleye9190962005-12-12 19:38:44 +0000116 return opt_list;
Eric Andersen60e56f52002-04-26 06:04:01 +0000117}
118
Bernhard Reutner-Fischer17d355c2005-12-14 08:32:44 +0000119#if ENABLE_FEATURE_MODPROBE_MULTIPLE_OPTIONS
Rob Landley79e1cab2005-11-15 00:08:29 +0000120/* static char* parse_command_string( char* src, char **dst );
121 * src: pointer to string containing argument
122 * dst: pointer to where to store the parsed argument
123 * return value: the pointer to the first char after the parsed argument,
124 * NULL if there was no argument parsed (only trailing spaces).
Rob Landleyd921b2e2006-08-03 15:41:12 +0000125 * Note that memory is allocated with xstrdup when a new argument was
Rob Landley79e1cab2005-11-15 00:08:29 +0000126 * parsed. Don't forget to free it!
127 */
128#define ARG_EMPTY 0x00
129#define ARG_IN_DQUOTES 0x01
130#define ARG_IN_SQUOTES 0x02
131static char *parse_command_string( char *src, char **dst )
132{
133 int opt_status = ARG_EMPTY;
134 char* tmp_str;
135
136 /* Dumb you, I have nothing to do... */
137 if( src == NULL ) return src;
138
139 /* Skip leading spaces */
140 while( *src == ' ' ) {
141 src++;
142 }
143 /* Is the end of string reached? */
144 if( *src == '\0' ) {
145 return NULL;
146 }
147 /* Reached the start of an argument
Rob Landleye9190962005-12-12 19:38:44 +0000148 * By the way, we duplicate a little too much
149 * here but what is too much is freed later. */
Rob Landleyd921b2e2006-08-03 15:41:12 +0000150 *dst = tmp_str = xstrdup( src );
Rob Landley79e1cab2005-11-15 00:08:29 +0000151 /* Get to the end of that argument */
152 while( ( *tmp_str != '\0' )
Rob Landleye9190962005-12-12 19:38:44 +0000153 && ( ( *tmp_str != ' ' )
154 || ( opt_status & ( ARG_IN_DQUOTES | ARG_IN_SQUOTES ) ) ) ) {
Rob Landley79e1cab2005-11-15 00:08:29 +0000155 switch( *tmp_str ) {
156 case '\'':
157 if( opt_status & ARG_IN_DQUOTES ) {
158 /* Already in double quotes, keep current char as is */
159 } else {
160 /* shift left 1 char, until end of string: get rid of the opening/closing quotes */
161 memmove( tmp_str, tmp_str + 1, strlen( tmp_str ) );
162 /* mark me: we enter or leave single quotes */
163 opt_status ^= ARG_IN_SQUOTES;
164 /* Back one char, as we need to re-scan the new char there. */
165 tmp_str--;
166 }
167 break;
168 case '"':
169 if( opt_status & ARG_IN_SQUOTES ) {
170 /* Already in single quotes, keep current char as is */
171 } else {
172 /* shift left 1 char, until end of string: get rid of the opening/closing quotes */
173 memmove( tmp_str, tmp_str + 1, strlen( tmp_str ) );
174 /* mark me: we enter or leave double quotes */
175 opt_status ^= ARG_IN_DQUOTES;
176 /* Back one char, as we need to re-scan the new char there. */
177 tmp_str--;
178 }
179 break;
180 case '\\':
181 if( opt_status & ARG_IN_SQUOTES ) {
182 /* Between single quotes: keep as is. */
183 } else {
184 switch( *(tmp_str+1) ) {
185 case 'a':
186 case 'b':
187 case 't':
188 case 'n':
189 case 'v':
190 case 'f':
191 case 'r':
192 case '0':
193 /* We escaped a special character. For now, keep
194 * both the back-slash and the following char. */
195 tmp_str++; src++;
196 break;
197 default:
198 /* We escaped a space or a single or double quote,
199 * or a back-slash, or a non-escapable char. Remove
200 * the '\' and keep the new current char as is. */
201 memmove( tmp_str, tmp_str + 1, strlen( tmp_str ) );
202 break;
203 }
204 }
205 break;
206 /* Any other char that is special shall appear here.
207 * Example: $ starts a variable
208 case '$':
209 do_variable_expansion();
210 break;
211 * */
212 default:
213 /* any other char is kept as is. */
214 break;
215 }
216 tmp_str++; /* Go to next char */
217 src++; /* Go to next char to find the end of the argument. */
218 }
219 /* End of string, but still no ending quote */
220 if( opt_status & ( ARG_IN_DQUOTES | ARG_IN_SQUOTES ) ) {
221 bb_error_msg_and_die( "unterminated (single or double) quote in options list: %s", src );
222 }
"Vladimir N. Oleynik"4fc92202006-02-02 14:48:54 +0000223 *tmp_str++ = '\0';
224 *dst = xrealloc( *dst, (tmp_str - *dst ) );
Rob Landley79e1cab2005-11-15 00:08:29 +0000225 return src;
226}
Rob Landleyae50c6d2005-12-15 07:42:13 +0000227#else
228#define parse_command_string(src, dst) (0)
Bernhard Reutner-Fischer17d355c2005-12-14 08:32:44 +0000229#endif /* ENABLE_FEATURE_MODPROBE_MULTIPLE_OPTIONS */
Rob Landley79e1cab2005-11-15 00:08:29 +0000230
Rob Landleye9190962005-12-12 19:38:44 +0000231/*
Rob Landley72615752006-04-10 16:09:52 +0000232 * This function reads aliases and default module options from a configuration file
233 * (/etc/modprobe.conf syntax). It supports includes (only files, no directories).
234 */
235static void include_conf ( struct dep_t **first, struct dep_t **current, char *buffer, int buflen, int fd )
236{
237 int continuation_line = 0;
238
239 // alias parsing is not 100% correct (no correct handling of continuation lines within an alias) !
240
241 while ( reads ( fd, buffer, buflen)) {
242 int l;
243 char *p;
244
245 p = strchr ( buffer, '#' );
246 if ( p )
247 *p = 0;
248
Rob Landleya3896512006-05-07 20:20:34 +0000249 l = strlen ( buffer );
Rob Landley72615752006-04-10 16:09:52 +0000250
251 while ( l && isspace ( buffer [l-1] )) {
252 buffer [l-1] = 0;
253 l--;
254 }
255
256 if ( l == 0 ) {
257 continuation_line = 0;
258 continue;
259 }
260
261 if ( !continuation_line ) {
262 if (( strncmp ( buffer, "alias", 5 ) == 0 ) && isspace ( buffer [5] )) {
263 char *alias, *mod;
264
265 if ( parse_tag_value ( buffer + 6, &alias, &mod )) {
266 /* handle alias as a module dependent on the aliased module */
267 if ( !*current ) {
Rob Landley081e3842006-08-03 20:07:35 +0000268 (*first) = (*current) = (struct dep_t *) xzalloc (sizeof ( struct dep_t ));
Rob Landley72615752006-04-10 16:09:52 +0000269 }
270 else {
Rob Landley081e3842006-08-03 20:07:35 +0000271 (*current)-> m_next = (struct dep_t *) xzalloc (sizeof ( struct dep_t ));
Rob Landley72615752006-04-10 16:09:52 +0000272 (*current) = (*current)-> m_next;
273 }
Rob Landleyd921b2e2006-08-03 15:41:12 +0000274 (*current)-> m_name = xstrdup ( alias );
Rob Landley72615752006-04-10 16:09:52 +0000275 (*current)-> m_isalias = 1;
276
277 if (( strcmp ( mod, "off" ) == 0 ) || ( strcmp ( mod, "null" ) == 0 )) {
278 (*current)-> m_depcnt = 0;
279 (*current)-> m_deparr = 0;
280 }
281 else {
282 (*current)-> m_depcnt = 1;
283 (*current)-> m_deparr = xmalloc ( 1 * sizeof( char * ));
Rob Landleyd921b2e2006-08-03 15:41:12 +0000284 (*current)-> m_deparr[0] = xstrdup ( mod );
Rob Landley72615752006-04-10 16:09:52 +0000285 }
286 (*current)-> m_next = 0;
287 }
288 }
289 else if (( strncmp ( buffer, "options", 7 ) == 0 ) && isspace ( buffer [7] )) {
290 char *mod, *opt;
291
292 /* split the line in the module/alias name, and options */
293 if ( parse_tag_value ( buffer + 8, &mod, &opt )) {
294 struct dep_t *dt;
295
296 /* find the corresponding module */
297 for ( dt = *first; dt; dt = dt-> m_next ) {
298 if ( strcmp ( dt-> m_name, mod ) == 0 )
299 break;
300 }
301 if ( dt ) {
302 if ( ENABLE_FEATURE_MODPROBE_MULTIPLE_OPTIONS ) {
303 char* new_opt = NULL;
304 while( ( opt = parse_command_string( opt, &new_opt ) ) ) {
305 dt-> m_options = append_option( dt-> m_options, new_opt );
306 }
307 } else {
308 dt-> m_options = append_option( dt-> m_options, opt );
309 }
310 }
311 }
312 }
313 else if (( strncmp ( buffer, "include", 7 ) == 0 ) && isspace ( buffer [7] )) {
314
315 int fdi; char *filename = buffer + 8;
316
317 while ( isspace ( *filename ))
318 filename++;
319
320 if (( fdi = open ( filename, O_RDONLY )) >= 0 ) {
321 include_conf(first, current, buffer, buflen, fdi);
322 close(fdi);
323 }
324 }
325 }
326 }
327}
328
329/*
Bernhard Reutner-Fischere3c150b2006-05-19 11:24:28 +0000330 * This function builds a list of dependency rules from /lib/modules/`uname -r`\modules.dep.
331 * It then fills every modules and aliases with their default options, found by parsing
Rob Landleye9190962005-12-12 19:38:44 +0000332 * modprobe.conf (or modules.conf, or conf.modules).
333 */
334static struct dep_t *build_dep ( void )
335{
336 int fd;
337 struct utsname un;
338 struct dep_t *first = 0;
339 struct dep_t *current = 0;
340 char buffer[2048];
"Vladimir N. Oleynik"4fc92202006-02-02 14:48:54 +0000341 char *filename;
Rob Landleye9190962005-12-12 19:38:44 +0000342 int continuation_line = 0;
343 int k_version;
344
345 k_version = 0;
346 if ( uname ( &un ))
347 bb_error_msg_and_die("can't determine kernel version");
348
Rob Landleye9190962005-12-12 19:38:44 +0000349 if (un.release[0] == '2') {
350 k_version = un.release[2] - '0';
351 }
352
Rob Landleyd921b2e2006-08-03 15:41:12 +0000353 filename = xasprintf("/lib/modules/%s/modules.dep", un.release );
Rob Landley3afb0702006-05-18 20:41:43 +0000354 fd = open ( filename, O_RDONLY );
Bernhard Reutner-Fischere3c150b2006-05-19 11:24:28 +0000355 if (ENABLE_FEATURE_CLEAN_UP)
356 free(filename);
Rob Landley3afb0702006-05-18 20:41:43 +0000357 if (fd < 0) {
Rob Landleye9190962005-12-12 19:38:44 +0000358 /* Ok, that didn't work. Fall back to looking in /lib/modules */
359 if (( fd = open ( "/lib/modules/modules.dep", O_RDONLY )) < 0 ) {
360 return 0;
361 }
362 }
363
364 while ( reads ( fd, buffer, sizeof( buffer ))) {
Rob Landleya3896512006-05-07 20:20:34 +0000365 int l = strlen ( buffer );
Rob Landleye9190962005-12-12 19:38:44 +0000366 char *p = 0;
367
"Vladimir N. Oleynik"4fc92202006-02-02 14:48:54 +0000368 while ( l > 0 && isspace ( buffer [l-1] )) {
Rob Landleye9190962005-12-12 19:38:44 +0000369 buffer [l-1] = 0;
370 l--;
371 }
372
373 if ( l == 0 ) {
374 continuation_line = 0;
375 continue;
376 }
377
378 /* Is this a new module dep description? */
379 if ( !continuation_line ) {
Bernhard Reutner-Fischer17d355c2005-12-14 08:32:44 +0000380 /* find the dep beginning */
Rob Landleye9190962005-12-12 19:38:44 +0000381 char *col = strchr ( buffer, ':' );
382 char *dot = col;
383
384 if ( col ) {
385 /* This line is a dep description */
386 char *mods;
387 char *modpath;
388 char *mod;
389
390 /* Find the beginning of the module file name */
391 *col = 0;
392 mods = strrchr ( buffer, '/' );
393
394 if ( !mods )
395 mods = buffer; /* no path for this module */
396 else
397 mods++; /* there was a path for this module... */
398
399 /* find the path of the module */
400 modpath = strchr ( buffer, '/' ); /* ... and this is the path */
401 if ( !modpath )
402 modpath = buffer; /* module with no path */
403 /* find the end of the module name in the file name */
404 if ( ENABLE_FEATURE_2_6_MODULES &&
405 (k_version > 4) && ( *(col-3) == '.' ) &&
406 ( *(col-2) == 'k' ) && ( *(col-1) == 'o' ) )
407 dot = col - 3;
408 else
409 if (( *(col-2) == '.' ) && ( *(col-1) == 'o' ))
410 dot = col - 2;
411
Rob Landleyd921b2e2006-08-03 15:41:12 +0000412 mod = xstrndup ( mods, dot - mods );
Rob Landleye9190962005-12-12 19:38:44 +0000413
414 /* enqueue new module */
415 if ( !current ) {
416 first = current = (struct dep_t *) xmalloc ( sizeof ( struct dep_t ));
417 }
418 else {
419 current-> m_next = (struct dep_t *) xmalloc ( sizeof ( struct dep_t ));
420 current = current-> m_next;
421 }
422 current-> m_name = mod;
Rob Landleyd921b2e2006-08-03 15:41:12 +0000423 current-> m_path = xstrdup(modpath);
Rob Landleye9190962005-12-12 19:38:44 +0000424 current-> m_options = NULL;
425 current-> m_isalias = 0;
426 current-> m_depcnt = 0;
427 current-> m_deparr = 0;
428 current-> m_next = 0;
429
430 p = col + 1;
431 }
432 else
433 /* this line is not a dep description */
434 p = 0;
435 }
436 else
437 /* It's a dep description continuation */
438 p = buffer;
439
440 while ( p && *p && isblank(*p))
441 p++;
442
443 /* p points to the first dependable module; if NULL, no dependable module */
444 if ( p && *p ) {
445 char *end = &buffer [l-1];
446 char *deps;
447 char *dep;
448 char *next;
449 int ext = 0;
450
451 while ( isblank ( *end ) || ( *end == '\\' ))
452 end--;
453
454 do
455 {
456 /* search the end of the dependency */
457 next = strchr (p, ' ' );
458 if (next)
459 {
460 *next = 0;
461 next--;
462 }
463 else
464 next = end;
465
Bernhard Reutner-Fischer17d355c2005-12-14 08:32:44 +0000466 /* find the beginning of the module file name */
Rob Landleye9190962005-12-12 19:38:44 +0000467 deps = strrchr ( p, '/' );
468
469 if ( !deps || ( deps < p )) {
470 deps = p;
471
472 while ( isblank ( *deps ))
473 deps++;
474 }
475 else
476 deps++;
477
478 /* find the end of the module name in the file name */
479 if ( ENABLE_FEATURE_2_6_MODULES &&
480 (k_version > 4) && ( *(next-2) == '.' ) &&
481 ( *(next-1) == 'k' ) && ( *next == 'o' ) )
482 ext = 3;
483 else
484 if (( *(next-1) == '.' ) && ( *next == 'o' ))
485 ext = 2;
486
487 /* Cope with blank lines */
488 if ((next-deps-ext+1) <= 0)
489 continue;
Rob Landleyd921b2e2006-08-03 15:41:12 +0000490 dep = xstrndup ( deps, next - deps - ext + 1 );
Rob Landleye9190962005-12-12 19:38:44 +0000491
492 /* Add the new dependable module name */
493 current-> m_depcnt++;
494 current-> m_deparr = (char **) xrealloc ( current-> m_deparr,
495 sizeof ( char *) * current-> m_depcnt );
496 current-> m_deparr [current-> m_depcnt - 1] = dep;
497
498 p = next + 2;
499 } while (next < end);
500 }
501
502 /* is there other dependable module(s) ? */
503 if ( buffer [l-1] == '\\' )
504 continuation_line = 1;
505 else
506 continuation_line = 0;
507 }
508 close ( fd );
509
Rob Landley3b0cfb42006-07-19 21:33:42 +0000510 /*
511 * First parse system-specific options and aliases
512 * as they take precedence over the kernel ones.
513 */
Rob Landleyae50c6d2005-12-15 07:42:13 +0000514 if (!ENABLE_FEATURE_2_6_MODULES
515 || ( fd = open ( "/etc/modprobe.conf", O_RDONLY )) < 0 )
Rob Landleye9190962005-12-12 19:38:44 +0000516 if (( fd = open ( "/etc/modules.conf", O_RDONLY )) < 0 )
Rob Landley3b0cfb42006-07-19 21:33:42 +0000517 fd = open ( "/etc/conf.modules", O_RDONLY );
Rob Landleye9190962005-12-12 19:38:44 +0000518
Rob Landley3b0cfb42006-07-19 21:33:42 +0000519 if (fd >= 0) {
520 include_conf (&first, &current, buffer, sizeof(buffer), fd);
521 close(fd);
Rob Landleye9190962005-12-12 19:38:44 +0000522 }
Rob Landley72615752006-04-10 16:09:52 +0000523
Rob Landley3b0cfb42006-07-19 21:33:42 +0000524 /* Only 2.6 has a modules.alias file */
525 if (ENABLE_FEATURE_2_6_MODULES) {
526 /* Parse kernel-declared aliases */
Rob Landleyd921b2e2006-08-03 15:41:12 +0000527 filename = xasprintf("/lib/modules/%s/modules.alias", un.release);
Rob Landley3b0cfb42006-07-19 21:33:42 +0000528 if ((fd = open ( filename, O_RDONLY )) < 0) {
529 /* Ok, that didn't work. Fall back to looking in /lib/modules */
530 fd = open ( "/lib/modules/modules.alias", O_RDONLY );
531 }
532 if (ENABLE_FEATURE_CLEAN_UP)
533 free(filename);
534
535 if (fd >= 0) {
536 include_conf (&first, &current, buffer, sizeof(buffer), fd);
537 close(fd);
538 }
539 }
Rob Landleye9190962005-12-12 19:38:44 +0000540
541 return first;
542}
543
544/* return 1 = loaded, 0 = not loaded, -1 = can't tell */
545static int already_loaded (const char *name)
546{
Rob Landleyd7605602006-06-14 01:51:16 +0000547 int fd, ret = 0;
Rob Landleye9190962005-12-12 19:38:44 +0000548 char buffer[4096];
549
550 fd = open ("/proc/modules", O_RDONLY);
551 if (fd < 0)
552 return -1;
553
554 while ( reads ( fd, buffer, sizeof( buffer ))) {
555 char *p;
556
557 p = strchr (buffer, ' ');
558 if (p) {
Rob Landleyd7605602006-06-14 01:51:16 +0000559 const char *n;
560
561 // Truncate buffer at first space and check for matches, with
562 // the idiosyncrasy that _ and - are interchangeable because the
563 // 2.6 kernel does weird things.
564
Rob Landleye9190962005-12-12 19:38:44 +0000565 *p = 0;
Rob Landleyd7605602006-06-14 01:51:16 +0000566 for (p = buffer, n = name; ; p++, n++) {
567 if (*p != *n) {
568 if ((*p == '_' || *p == '-') && (*n == '_' || *n == '-'))
569 continue;
570 break;
571 }
572 // If we made it to the end, that's a match.
573 if (!*p) {
574 ret = 1;
575 goto done;
576 }
Rob Landleye9190962005-12-12 19:38:44 +0000577 }
578 }
579 }
Rob Landleyd7605602006-06-14 01:51:16 +0000580done:
Rob Landleye9190962005-12-12 19:38:44 +0000581 close (fd);
Mike Frysinger135cee32006-06-21 23:03:37 +0000582 return ret;
Rob Landleye9190962005-12-12 19:38:44 +0000583}
584
Robert Griebl236abbf2002-05-22 23:34:35 +0000585static int mod_process ( struct mod_list_t *list, int do_insert )
Eric Andersen60e56f52002-04-26 06:04:01 +0000586{
Eric Andersen44b57582004-08-03 08:23:33 +0000587 int rc = 0;
Rob Landley79e1cab2005-11-15 00:08:29 +0000588 char **argv = NULL;
Rob Landleye9190962005-12-12 19:38:44 +0000589 struct mod_opt_t *opts;
590 int argc_malloc; /* never used when CONFIG_FEATURE_CLEAN_UP not defined */
Paul Fox8eeb6552005-08-04 18:33:36 +0000591 int argc;
Eric Andersen864b7972002-05-03 15:48:26 +0000592
Robert Griebl52e8d062002-05-14 23:42:08 +0000593 while ( list ) {
Paul Fox8eeb6552005-08-04 18:33:36 +0000594 argc = 0;
Rob Landleye9190962005-12-12 19:38:44 +0000595 if( ENABLE_FEATURE_CLEAN_UP )
596 argc_malloc = 0;
597 /* If CONFIG_FEATURE_CLEAN_UP is not defined, then we leak memory
598 * each time we allocate memory for argv.
599 * But it is (quite) small amounts of memory that leak each
600 * time a module is loaded, and it is reclaimed when modprobe
601 * exits anyway (even when standalone shell?).
602 * This could become a problem when loading a module with LOTS of
603 * dependencies, with LOTS of options for each dependencies, with
604 * very little memory on the target... But in that case, the module
605 * would not load because there is no more memory, so there's no
606 * problem. */
607 /* enough for minimal insmod (5 args + NULL) or rmmod (3 args + NULL) */
608 argv = (char**) malloc( 6 * sizeof( char* ) );
Glenn L McGrath350733a2003-09-08 00:32:49 +0000609 if ( do_insert ) {
Rob Landley79e1cab2005-11-15 00:08:29 +0000610 if (already_loaded (list->m_name) != 1) {
Paul Fox8eeb6552005-08-04 18:33:36 +0000611 argv[argc++] = "insmod";
Rob Landleyd7605602006-06-14 01:51:16 +0000612 if (ENABLE_FEATURE_2_4_MODULES) {
613 if (do_syslog)
614 argv[argc++] = "-s";
615 if (autoclean)
616 argv[argc++] = "-k";
617 if (quiet)
618 argv[argc++] = "-q";
619 else if(verbose) /* verbose and quiet are mutually exclusive */
620 argv[argc++] = "-v";
621 }
Paul Fox8eeb6552005-08-04 18:33:36 +0000622 argv[argc++] = list-> m_path;
Rob Landleye9190962005-12-12 19:38:44 +0000623 if( ENABLE_FEATURE_CLEAN_UP )
624 argc_malloc = argc;
Rob Landley79e1cab2005-11-15 00:08:29 +0000625 opts = list-> m_options;
Rob Landleye9190962005-12-12 19:38:44 +0000626 while( opts ) {
627 /* Add one more option */
Rob Landley79e1cab2005-11-15 00:08:29 +0000628 argc++;
629 argv = (char**) xrealloc( argv, ( argc + 1 ) * sizeof( char* ) );
Rob Landleye9190962005-12-12 19:38:44 +0000630 argv[argc-1] = opts-> m_opt_val;
631 opts = opts-> m_next;
Rob Landley79e1cab2005-11-15 00:08:29 +0000632 }
Paul Fox8eeb6552005-08-04 18:33:36 +0000633 }
Glenn L McGrath350733a2003-09-08 00:32:49 +0000634 } else {
Eric Andersen807bd842004-08-19 18:30:31 +0000635 /* modutils uses short name for removal */
Rob Landley79e1cab2005-11-15 00:08:29 +0000636 if (already_loaded (list->m_name) != 0) {
Paul Fox8eeb6552005-08-04 18:33:36 +0000637 argv[argc++] = "rmmod";
638 if (do_syslog)
639 argv[argc++] = "-s";
640 argv[argc++] = list->m_name;
Rob Landleye9190962005-12-12 19:38:44 +0000641 if( ENABLE_FEATURE_CLEAN_UP )
642 argc_malloc = argc;
Paul Fox8eeb6552005-08-04 18:33:36 +0000643 }
Glenn L McGrath350733a2003-09-08 00:32:49 +0000644 }
Paul Fox8eeb6552005-08-04 18:33:36 +0000645 argv[argc] = NULL;
Eric Andersen3b1a7442003-12-24 20:30:45 +0000646
Paul Fox8eeb6552005-08-04 18:33:36 +0000647 if (argc) {
Glenn L McGrathfcf47322004-08-11 05:56:30 +0000648 if (verbose) {
Rob Landleye9190962005-12-12 19:38:44 +0000649 printf("%s module %s\n", do_insert?"Loading":"Unloading", list-> m_name );
Glenn L McGrathfcf47322004-08-11 05:56:30 +0000650 }
651 if (!show_only) {
Rob Landleyd921b2e2006-08-03 15:41:12 +0000652 int rc2 = wait4pid(spawn(argv));
Rob Landley4b5827a2006-08-22 23:50:11 +0000653
Glenn L McGrathfcf47322004-08-11 05:56:30 +0000654 if (do_insert) {
655 rc = rc2; /* only last module matters */
656 }
657 else if (!rc2) {
658 rc = 0; /* success if remove any mod */
659 }
660 }
Rob Landleye9190962005-12-12 19:38:44 +0000661 if( ENABLE_FEATURE_CLEAN_UP )
662 /* the last value in the array has index == argc, but
663 * it is the terminating NULL, so we must not free it. */
664 while( argc_malloc < argc ) {
665 free( argv[argc_malloc++] );
Rob Landley79e1cab2005-11-15 00:08:29 +0000666 }
Eric Andersen908e3622003-06-20 09:56:37 +0000667 }
Rob Landleye9190962005-12-12 19:38:44 +0000668 if( ENABLE_FEATURE_CLEAN_UP ) {
669 free( argv );
670 argv = NULL;
Rob Landley79e1cab2005-11-15 00:08:29 +0000671 }
Robert Griebl52e8d062002-05-14 23:42:08 +0000672 list = do_insert ? list-> m_prev : list-> m_next;
Eric Andersen60e56f52002-04-26 06:04:01 +0000673 }
Eric Andersen908e3622003-06-20 09:56:37 +0000674 return (show_only) ? 0 : rc;
Eric Andersen60e56f52002-04-26 06:04:01 +0000675}
676
Rob Landleye9190962005-12-12 19:38:44 +0000677/*
Rob Landleybf30c692006-07-20 17:36:18 +0000678 * Check the matching between a pattern and a module name.
679 * We need this as *_* is equivalent to *-*, even in pattern matching.
680 */
681static int check_pattern( const char* pat_src, const char* mod_src ) {
682 int ret;
683
684 if (ENABLE_FEATURE_MODPROBE_FANCY_ALIAS) {
685 char* pat;
686 char* mod;
687 char* p;
688
Rob Landleyd921b2e2006-08-03 15:41:12 +0000689 pat = xstrdup (pat_src);
690 mod = xstrdup (mod_src);
Rob Landleybf30c692006-07-20 17:36:18 +0000691
692 for (p = pat; (p = strchr(p, '-')); *p++ = '_' );
693 for (p = mod; (p = strchr(p, '-')); *p++ = '_' );
694
695 ret = fnmatch ( pat, mod, 0 );
696
697 if (ENABLE_FEATURE_CLEAN_UP) {
698 free (pat);
699 free (mod);
700 }
701
702 return ret;
703 } else {
704 return fnmatch ( pat_src, mod_src, 0 );
705 }
706}
707
708/*
Rob Landleye9190962005-12-12 19:38:44 +0000709 * Builds the dependency list (aka stack) of a module.
710 * head: the highest module in the stack (last to insmod, first to rmmod)
711 * tail: the lowest module in the stack (first to insmod, last to rmmod)
712 */
Robert Griebl52e8d062002-05-14 23:42:08 +0000713static void check_dep ( char *mod, struct mod_list_t **head, struct mod_list_t **tail )
Eric Andersen60e56f52002-04-26 06:04:01 +0000714{
Robert Griebl52e8d062002-05-14 23:42:08 +0000715 struct mod_list_t *find;
Eric Andersen60e56f52002-04-26 06:04:01 +0000716 struct dep_t *dt;
Rob Landleye9190962005-12-12 19:38:44 +0000717 struct mod_opt_t *opt = 0;
Eric Andersen807bd842004-08-19 18:30:31 +0000718 char *path = 0;
Robert Griebl52e8d062002-05-14 23:42:08 +0000719
Bernhard Reutner-Fischer2c351a82006-06-03 19:08:49 +0000720 /* Search for the given module name amongst all dependency rules.
721 * The module name in a dependency rule can be a shell pattern,
722 * so try to match the given module name against such a pattern.
723 * Of course if the name in the dependency rule is a plain string,
724 * then we consider it a pattern, and matching will still work. */
Robert Griebl1d4ef2a2002-05-28 21:32:10 +0000725 for ( dt = depend; dt; dt = dt-> m_next ) {
Rob Landleybf30c692006-07-20 17:36:18 +0000726 if ( check_pattern ( dt-> m_name, mod ) == 0) {
Robert Griebl1d4ef2a2002-05-28 21:32:10 +0000727 break;
Robert Grieblaead70b2002-07-26 15:54:20 +0000728 }
Robert Griebl1d4ef2a2002-05-28 21:32:10 +0000729 }
Eric Andersen3b1a7442003-12-24 20:30:45 +0000730
Rob Landleye9190962005-12-12 19:38:44 +0000731 if( !dt ) {
732 bb_error_msg ("module %s not found.", mod);
733 return;
734 }
735
Robert Griebl1d4ef2a2002-05-28 21:32:10 +0000736 // resolve alias names
Rob Landleye9190962005-12-12 19:38:44 +0000737 while ( dt-> m_isalias ) {
Robert Grieblaead70b2002-07-26 15:54:20 +0000738 if ( dt-> m_depcnt == 1 ) {
739 struct dep_t *adt;
Eric Andersen3b1a7442003-12-24 20:30:45 +0000740
Robert Grieblaead70b2002-07-26 15:54:20 +0000741 for ( adt = depend; adt; adt = adt-> m_next ) {
Rob Landleybf30c692006-07-20 17:36:18 +0000742 if ( check_pattern ( adt-> m_name, dt-> m_deparr [0] ) == 0 )
Robert Grieblaead70b2002-07-26 15:54:20 +0000743 break;
Robert Grieblaead70b2002-07-26 15:54:20 +0000744 }
Robert Griebl70112da2002-07-29 20:28:38 +0000745 if ( adt ) {
Rob Landleye9190962005-12-12 19:38:44 +0000746 /* This is the module we are aliased to */
747 struct mod_opt_t *opts = dt-> m_options;
748 /* Option of the alias are appended to the options of the module */
749 while( opts ) {
750 adt-> m_options = append_option( adt-> m_options, opts-> m_opt_val );
751 opts = opts-> m_next;
752 }
Eric Andersen716ccb22004-01-10 11:29:31 +0000753 dt = adt;
Robert Griebl70112da2002-07-29 20:28:38 +0000754 }
Rob Landleye9190962005-12-12 19:38:44 +0000755 else {
756 bb_error_msg ("module %s not found.", mod);
Robert Griebl70112da2002-07-29 20:28:38 +0000757 return;
Rob Landleye9190962005-12-12 19:38:44 +0000758 }
Robert Grieblaead70b2002-07-26 15:54:20 +0000759 }
Rob Landleye9190962005-12-12 19:38:44 +0000760 else {
761 bb_error_msg ("Bad alias %s", dt-> m_name);
Eric Andersen716ccb22004-01-10 11:29:31 +0000762 return;
Rob Landleye9190962005-12-12 19:38:44 +0000763 }
Robert Griebl1d4ef2a2002-05-28 21:32:10 +0000764 }
Eric Andersen3b1a7442003-12-24 20:30:45 +0000765
Rob Landleye9190962005-12-12 19:38:44 +0000766 mod = dt-> m_name;
767 path = dt-> m_path;
768 opt = dt-> m_options;
Bernhard Reutner-Fischer17d355c2005-12-14 08:32:44 +0000769
Robert Griebl52e8d062002-05-14 23:42:08 +0000770 // search for duplicates
771 for ( find = *head; find; find = find-> m_next ) {
Eric Andersen807bd842004-08-19 18:30:31 +0000772 if ( !strcmp ( mod, find-> m_name )) {
Robert Griebl52e8d062002-05-14 23:42:08 +0000773 // found -> dequeue it
774
775 if ( find-> m_prev )
776 find-> m_prev-> m_next = find-> m_next;
777 else
778 *head = find-> m_next;
Eric Andersen3b1a7442003-12-24 20:30:45 +0000779
Robert Griebl52e8d062002-05-14 23:42:08 +0000780 if ( find-> m_next )
781 find-> m_next-> m_prev = find-> m_prev;
782 else
783 *tail = find-> m_prev;
Eric Andersen3b1a7442003-12-24 20:30:45 +0000784
Robert Griebl52e8d062002-05-14 23:42:08 +0000785 break; // there can be only one duplicate
Eric Andersen716ccb22004-01-10 11:29:31 +0000786 }
Robert Griebl52e8d062002-05-14 23:42:08 +0000787 }
788
789 if ( !find ) { // did not find a duplicate
Eric Andersen716ccb22004-01-10 11:29:31 +0000790 find = (struct mod_list_t *) xmalloc ( sizeof(struct mod_list_t));
Eric Andersen807bd842004-08-19 18:30:31 +0000791 find-> m_name = mod;
792 find-> m_path = path;
Robert Grieblaead70b2002-07-26 15:54:20 +0000793 find-> m_options = opt;
Robert Griebl52e8d062002-05-14 23:42:08 +0000794 }
795
Eric Andersen716ccb22004-01-10 11:29:31 +0000796 // enqueue at tail
Robert Griebl52e8d062002-05-14 23:42:08 +0000797 if ( *tail )
798 (*tail)-> m_next = find;
799 find-> m_prev = *tail;
800 find-> m_next = 0;
Robert Griebl1d4ef2a2002-05-28 21:32:10 +0000801
Robert Griebl52e8d062002-05-14 23:42:08 +0000802 if ( !*head )
803 *head = find;
804 *tail = find;
Eric Andersen3b1a7442003-12-24 20:30:45 +0000805
Eric Andersen716ccb22004-01-10 11:29:31 +0000806 if ( dt ) {
Robert Griebl1d4ef2a2002-05-28 21:32:10 +0000807 int i;
Eric Andersen3b1a7442003-12-24 20:30:45 +0000808
Rob Landleye9190962005-12-12 19:38:44 +0000809 /* Add all dependable module for that new module */
Robert Griebl1d4ef2a2002-05-28 21:32:10 +0000810 for ( i = 0; i < dt-> m_depcnt; i++ )
811 check_dep ( dt-> m_deparr [i], head, tail );
812 }
Robert Griebl52e8d062002-05-14 23:42:08 +0000813}
814
Robert Griebl236abbf2002-05-22 23:34:35 +0000815static int mod_insert ( char *mod, int argc, char **argv )
Robert Griebl52e8d062002-05-14 23:42:08 +0000816{
817 struct mod_list_t *tail = 0;
Eric Andersen716ccb22004-01-10 11:29:31 +0000818 struct mod_list_t *head = 0;
Eric Andersen908e3622003-06-20 09:56:37 +0000819 int rc;
Eric Andersen3b1a7442003-12-24 20:30:45 +0000820
Robert Griebl52e8d062002-05-14 23:42:08 +0000821 // get dep list for module mod
822 check_dep ( mod, &head, &tail );
Eric Andersen3b1a7442003-12-24 20:30:45 +0000823
Robert Griebl52e8d062002-05-14 23:42:08 +0000824 if ( head && tail ) {
Rob Landleye9190962005-12-12 19:38:44 +0000825 if( argc ) {
Eric Andersen716ccb22004-01-10 11:29:31 +0000826 int i;
Robert Grieblaead70b2002-07-26 15:54:20 +0000827 // append module args
Eric Andersen716ccb22004-01-10 11:29:31 +0000828 for ( i = 0; i < argc; i++ )
Rob Landleye9190962005-12-12 19:38:44 +0000829 head->m_options = append_option( head->m_options, argv[i] );
Robert Griebl52e8d062002-05-14 23:42:08 +0000830 }
Eric Andersen3b1a7442003-12-24 20:30:45 +0000831
Robert Griebl52e8d062002-05-14 23:42:08 +0000832 // process tail ---> head
Rob Landley4b5827a2006-08-22 23:50:11 +0000833 if ((rc = mod_process ( tail, 1 )) != 0) {
834 /*
835 * In case of using udev, multiple instances of modprobe can be
836 * spawned to load the same module (think of two same usb devices,
837 * for example; or cold-plugging at boot time). Thus we shouldn't
838 * fail if the module was loaded, and not by us.
839 */
840 if (already_loaded (mod) )
841 rc = 0;
842 }
Robert Griebl52e8d062002-05-14 23:42:08 +0000843 }
844 else
845 rc = 1;
Eric Andersen3b1a7442003-12-24 20:30:45 +0000846
Robert Griebl52e8d062002-05-14 23:42:08 +0000847 return rc;
848}
849
Eric Andersen908e3622003-06-20 09:56:37 +0000850static int mod_remove ( char *mod )
Robert Griebl52e8d062002-05-14 23:42:08 +0000851{
Eric Andersen908e3622003-06-20 09:56:37 +0000852 int rc;
"Vladimir N. Oleynik"4fc92202006-02-02 14:48:54 +0000853 static struct mod_list_t rm_a_dummy = { "-a", NULL, NULL, NULL, NULL };
Eric Andersen3b1a7442003-12-24 20:30:45 +0000854
Robert Griebl52e8d062002-05-14 23:42:08 +0000855 struct mod_list_t *head = 0;
856 struct mod_list_t *tail = 0;
Eric Andersen3b1a7442003-12-24 20:30:45 +0000857
Robert Griebl52e8d062002-05-14 23:42:08 +0000858 if ( mod )
859 check_dep ( mod, &head, &tail );
860 else // autoclean
861 head = tail = &rm_a_dummy;
Eric Andersen3b1a7442003-12-24 20:30:45 +0000862
Robert Griebl236abbf2002-05-22 23:34:35 +0000863 if ( head && tail )
Eric Andersen908e3622003-06-20 09:56:37 +0000864 rc = mod_process ( head, 0 ); // process head ---> tail
865 else
866 rc = 1;
867 return rc;
Eric Andersen3b1a7442003-12-24 20:30:45 +0000868
Robert Griebl52e8d062002-05-14 23:42:08 +0000869}
870
Rob Landleydfba7412006-03-06 20:47:33 +0000871int modprobe_main(int argc, char** argv)
Eric Andersen0139ca92001-07-22 23:01:03 +0000872{
Rob Landleye9190962005-12-12 19:38:44 +0000873 int rc = EXIT_SUCCESS;
"Vladimir N. Oleynik"4fc92202006-02-02 14:48:54 +0000874 char *unused;
Eric Andersen0139ca92001-07-22 23:01:03 +0000875
Denis Vlasenko67b23e62006-10-03 21:00:06 +0000876 opt_complementary = "?V-:q-v:v-q";
877 main_opts = getopt32(argc, argv, "acdklnqrst:vVC:",
"Vladimir N. Oleynik"4fc92202006-02-02 14:48:54 +0000878 &unused, &unused);
879 if((main_opts & (DUMP_CONF_EXIT | LIST_ALL)))
Eric Andersen3b1a7442003-12-24 20:30:45 +0000880 return EXIT_SUCCESS;
"Vladimir N. Oleynik"4fc92202006-02-02 14:48:54 +0000881 if((main_opts & (RESTRICT_DIR | CONFIG_FILE)))
Eric Andersen3b1a7442003-12-24 20:30:45 +0000882 bb_error_msg_and_die("-t and -C not supported");
Robert Griebl236abbf2002-05-22 23:34:35 +0000883
Eric Andersen716ccb22004-01-10 11:29:31 +0000884 depend = build_dep ( );
Robert Griebl52e8d062002-05-14 23:42:08 +0000885
Eric Andersen716ccb22004-01-10 11:29:31 +0000886 if ( !depend )
Denis Vlasenkoea620772006-10-14 02:23:43 +0000887 bb_error_msg_and_die ( "cannot parse modules.dep" );
Eric Andersen3b1a7442003-12-24 20:30:45 +0000888
Eric Andersen1b064192001-07-25 07:23:38 +0000889 if (remove_opt) {
Eric Andersen0139ca92001-07-22 23:01:03 +0000890 do {
Eric Andersen908e3622003-06-20 09:56:37 +0000891 if (mod_remove ( optind < argc ?
"Vladimir N. Oleynik"4fc92202006-02-02 14:48:54 +0000892 argv [optind] : NULL )) {
Eric Andersen908e3622003-06-20 09:56:37 +0000893 bb_error_msg ("failed to remove module %s",
Eric Andersen3b1a7442003-12-24 20:30:45 +0000894 argv [optind] );
Eric Andersen908e3622003-06-20 09:56:37 +0000895 rc = EXIT_FAILURE;
896 }
Robert Griebl52e8d062002-05-14 23:42:08 +0000897 } while ( ++optind < argc );
Rob Landleye9190962005-12-12 19:38:44 +0000898 } else {
899 if (optind >= argc)
Bernhard Reutner-Fischerdeda6a52006-06-03 19:35:15 +0000900 bb_error_msg_and_die ( "No module or pattern provided" );
Eric Andersen3b1a7442003-12-24 20:30:45 +0000901
"Vladimir N. Oleynik"4fc92202006-02-02 14:48:54 +0000902 if ( mod_insert ( argv [optind], argc - optind - 1, argv + optind + 1 ))
Rob Landleye9190962005-12-12 19:38:44 +0000903 bb_error_msg_and_die ( "failed to load module %s", argv [optind] );
Eric Andersen0139ca92001-07-22 23:01:03 +0000904 }
905
Rob Landleye9190962005-12-12 19:38:44 +0000906 /* Here would be a good place to free up memory allocated during the dependencies build. */
Eric Andersen3b1a7442003-12-24 20:30:45 +0000907
Rob Landleye9190962005-12-12 19:38:44 +0000908 return rc;
Eric Andersen0139ca92001-07-22 23:01:03 +0000909}