depmod: Add checks to strdup()'s return value
[opensuse:module-init-tools.git] / depmod.c
1 /* New simplified depmod without backwards compat stuff and not
2    requiring ksyms.
3
4    (C) 2002 Rusty Russell IBM Corporation
5  */
6 #include <stdarg.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <getopt.h>
10 #include <string.h>
11 #include <errno.h>
12 #include <unistd.h>
13 #include <elf.h>
14 #include <sys/types.h>
15 #include <sys/stat.h>
16 #include <fcntl.h>
17 #include <dirent.h>
18 #include <sys/utsname.h>
19 #include <sys/mman.h>
20
21 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
22
23 #include "zlibsupport.h"
24 #include "depmod.h"
25 #include "moduleops.h"
26 #include "tables.h"
27
28 #include "testing.h"
29
30 #ifndef MODULE_DIR
31 #define MODULE_DIR "/lib/modules/"
32 #endif
33
34 #ifndef MODULE_BUILTIN_KEY
35 #define MODULE_BUILTIN_KEY "built-in"
36 #endif
37
38 struct module_overrides
39 {
40         /* Next override */
41         struct module_overrides *next;
42
43         /* overridden module */
44         char *modfile;
45 };
46
47 struct module_search
48 {
49         /* Next search */
50         struct module_search *next;
51
52         /* search path */
53         char *search_path;
54 };
55
56 static int verbose;
57 static unsigned int skipchars;
58
59 void fatal(const char *fmt, ...)
60 {
61         va_list arglist;
62
63         fprintf(stderr, "FATAL: ");
64
65         va_start(arglist, fmt);
66         vfprintf(stderr, fmt, arglist);
67         va_end(arglist);
68
69         exit(1);
70 }
71
72 void warn(const char *fmt, ...)
73 {
74         va_list arglist;
75
76         fprintf(stderr, "WARNING: ");
77
78         va_start(arglist, fmt);
79         vfprintf(stderr, fmt, arglist);
80         va_end(arglist);
81 }
82
83 void *do_nofail(void *ptr, const char *file, int line, const char *expr)
84 {
85         if (!ptr) {
86                 fatal("Memory allocation failure %s line %d: %s.\n",
87                       file, line, expr);
88         }
89         return ptr;
90 }
91
92 #define SYMBOL_HASH_SIZE 1024
93 struct symbol
94 {
95         struct symbol *next;
96         struct module *owner;
97         char name[0];
98 };
99
100 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
101
102 /* This is based on the hash agorithm from gdbm, via tdb */
103 static inline unsigned int tdb_hash(const char *name)
104 {
105         unsigned value; /* Used to compute the hash value.  */
106         unsigned   i;   /* Used to cycle through random values. */
107
108         /* Set the initial value from the key size. */
109         for (value = 0x238F13AF * strlen(name), i=0; name[i]; i++)
110                 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
111
112         return (1103515243 * value + 12345);
113 }
114
115 void add_symbol(const char *name, struct module *owner)
116 {
117         unsigned int hash;
118         struct symbol *new = NOFAIL(malloc(sizeof *new + strlen(name) + 1));
119
120         new->owner = owner;
121         strcpy(new->name, name);
122
123         hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
124         new->next = symbolhash[hash];
125         symbolhash[hash] = new;
126 }
127
128 static int print_unknown;
129
130 struct module *find_symbol(const char *name, const char *modname, int weak)
131 {
132         struct symbol *s;
133
134         /* For our purposes, .foo matches foo.  PPC64 needs this. */
135         if (name[0] == '.')
136                 name++;
137
138         for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s=s->next) {
139                 if (streq(s->name, name))
140                         return s->owner;
141         }
142
143         if (print_unknown && !weak)
144                 warn("%s needs unknown symbol %s\n", modname, name);
145
146         return NULL;
147 }
148
149 void add_dep(struct module *mod, struct module *depends_on)
150 {
151         unsigned int i;
152
153         for (i = 0; i < mod->num_deps; i++)
154                 if (mod->deps[i] == depends_on)
155                         return;
156
157         mod->deps = NOFAIL(realloc(mod->deps, sizeof(mod->deps[0])*(mod->num_deps+1)));
158         mod->deps[mod->num_deps++] = depends_on;
159 }
160
161 static void load_system_map(const char *filename)
162 {
163         FILE *system_map;
164         char line[10240];
165         const char ksymstr[] = "__ksymtab_";
166         const int ksymstr_len = strlen(ksymstr);
167
168         system_map = fopen(filename, "r");
169         if (!system_map)
170                 fatal("Could not open '%s': %s\n", filename, strerror(errno));
171
172         /* eg. c0294200 R __ksymtab_devfs_alloc_devnum */
173         while (fgets(line, sizeof(line)-1, system_map)) {
174                 char *ptr;
175
176                 /* Snip \n */
177                 ptr = strchr(line, '\n');
178                 if (ptr)
179                         *ptr = '\0';
180
181                 ptr = strchr(line, ' ');
182                 if (!ptr || !(ptr = strchr(ptr + 1, ' ')))
183                         continue;
184
185                 /* Covers gpl-only and normal symbols. */
186                 if (strncmp(ptr+1, ksymstr, ksymstr_len) == 0)
187                         add_symbol(ptr+1+ksymstr_len, NULL);
188         }
189
190         fclose(system_map);
191
192         /* __this_module is magic inserted by kernel loader. */
193         add_symbol("__this_module", NULL);
194         /* On S390, this is faked up too */
195         add_symbol("_GLOBAL_OFFSET_TABLE_", NULL);
196 }
197
198 static struct option options[] = { { "all", 0, NULL, 'a' },
199                                    { "quick", 0, NULL, 'A' },
200                                    { "basedir", 1, NULL, 'b' },
201                                    { "errsyms", 0, NULL, 'e' },
202                                    { "filesyms", 1, NULL, 'F' },
203                                    { "help", 0, NULL, 'h' },
204                                    { "show", 0, NULL, 'n' },
205                                    { "dry-run", 0, NULL, 'n' },
206                                    { "quiet", 0, NULL, 'q' },
207                                    { "root", 0, NULL, 'r' },
208                                    { "unresolved-error", 0, NULL, 'u' },
209                                    { "verbose", 0, NULL, 'v' },
210                                    { "version", 0, NULL, 'V' },
211                                    { "config", 1, NULL, 'C' },
212                                    { NULL, 0, NULL, 0 } };
213
214 /* Version number or module name?  Don't assume extension. */
215 static int is_version_number(const char *version)
216 {
217         unsigned int dummy;
218
219         return (sscanf(version, "%u.%u.%u", &dummy, &dummy, &dummy) == 3);
220 }
221
222 static int old_module_version(const char *version)
223 {
224         /* Expect three part version. */
225         unsigned int major, sub, minor;
226
227         sscanf(version, "%u.%u.%u", &major, &sub, &minor);
228
229         if (major > 2) return 0;
230         if (major < 2) return 1;
231
232         /* 2.x */
233         if (sub > 5) return 0;
234         if (sub < 5) return 1;
235
236         /* 2.5.x */
237         if (minor >= 48) return 0;
238         return 1;
239 }
240
241 static void exec_old_depmod(char *argv[])
242 {
243         char *sep;
244         char pathname[strlen(argv[0])+1];
245         char oldname[strlen("depmod") + strlen(argv[0]) + sizeof(".old")];
246
247         memset(pathname, 0, strlen(argv[0])+1);
248         sep = strrchr(argv[0], '/');
249         if (sep)
250                 memcpy(pathname, argv[0], sep - argv[0]+1);
251         sprintf(oldname, "%s%s.old", pathname, "depmod");
252
253         /* Recursion detection: we need an env var since we can't
254            change argv[0] (as older modutils uses it to determine
255            behavior). */
256         if (getenv("MODULE_RECURSE"))
257                 return;
258         setenv("MODULE_RECURSE", "y", 0);
259
260         execvp(oldname, argv);
261         fprintf(stderr,
262                 "Version requires old depmod, but couldn't run %s: %s\n",
263                 oldname, strerror(errno));
264         exit(2);
265 }
266
267 static void grammar(const char *cmd, const char *filename, unsigned int line)
268 {
269         warn("%s line %u: ignoring bad line starting with '%s'\n",
270                                                 filename, line, cmd);
271 }
272
273
274 static void print_usage(const char *name)
275 {
276         fprintf(stderr,
277         "%s " VERSION " -- part of " PACKAGE "\n"
278         "%s -[aA] [-n -e -v -q -V -r -u]\n"
279         "      [-b basedirectory] [forced_version]\n"
280         "depmod [-n -e -v -q -r -u] [-F kernelsyms] module1.ko module2.ko ...\n"
281         "If no arguments (except options) are given, \"depmod -a\" is assumed\n"
282         "\n"
283         "depmod will output a dependancy list suitable for the modprobe utility.\n"
284         "\n"
285         "\n"
286         "Options:\n"
287         "\t-a, --all            Probe all modules\n"
288         "\t-A, --quick          Only does the work if there's a new module\n"
289         "\t-n, --show           Write the dependency file on stdout only\n"
290         "\t-e, --errsyms        Report not supplied symbols\n"
291         "\t-V, --version        Print the release version\n"
292         "\t-v, --verbose        Enable verbose mode\n"
293         "\t-h, --help           Print this usage message\n"
294         "\n"
295         "The following options are useful for people managing distributions:\n"
296         "\t-b basedirectory\n"
297         "\t    --basedir basedirectory    Use an image of a module tree.\n"
298         "\t-F kernelsyms\n"
299         "\t    --filesyms kernelsyms      Use the file instead of the\n"
300         "\t                               current kernel symbols.\n",
301         "depmod", "depmod");
302 }
303
304 static int ends_in(const char *name, const char *ext)
305 {
306         unsigned int namelen, extlen;
307
308         /* Grab lengths */
309         namelen = strlen(name);
310         extlen = strlen(ext);
311
312         if (namelen < extlen) return 0;
313
314         if (streq(name + namelen - extlen, ext))
315                 return 1;
316         return 0;
317 }
318
319 /* "\177ELF" <byte> where byte = 001 for 32-bit, 002 for 64 */
320 int needconv(const char *elfhdr)
321 {
322         union { short s; char c[2]; } endian_test;
323
324         endian_test.s = 1;
325         if (endian_test.c[1] == 1) return elfhdr[EI_DATA] != ELFDATA2MSB;
326         if (endian_test.c[0] == 1) return elfhdr[EI_DATA] != ELFDATA2LSB;
327         else
328                 abort();
329 }
330
331 static struct module *grab_module(const char *dirname, const char *filename)
332 {
333         struct module *new;
334
335         new = NOFAIL(malloc(sizeof(*new)
336                             + strlen(dirname?:"") + 1 + strlen(filename) + 1));
337         if (dirname)
338                 sprintf(new->pathname, "%s/%s", dirname, filename);
339         else
340                 strcpy(new->pathname, filename);
341
342         INIT_LIST_HEAD(&new->dep_list);
343
344         new->data = grab_file(new->pathname, &new->len);
345         if (!new->data) {
346                 warn("Can't read module %s: %s\n",
347                      new->pathname, strerror(errno));
348                 goto fail_data;
349         }
350
351         /* "\177ELF" <byte> where byte = 001 for 32-bit, 002 for 64 */
352         if (memcmp(new->data, ELFMAG, SELFMAG) != 0) {
353                 warn("Module %s is not an elf object\n", new->pathname);
354                 goto fail;
355         }
356
357         switch (((char *)new->data)[EI_CLASS]) {
358         case ELFCLASS32:
359                 new->ops = &mod_ops32;
360                 break;
361         case ELFCLASS64:
362                 new->ops = &mod_ops64;
363                 break;
364         default:
365                 warn("Module %s has elf unknown identifier %i\n",
366                      new->pathname, ((char *)new->data)[EI_CLASS]);
367                 goto fail;
368         }
369         new->conv = needconv(new->data);
370         return new;
371
372 fail:
373         release_file(new->data, new->len);
374 fail_data:
375         free(new);
376         return NULL;
377 }
378
379 struct module_traverse
380 {
381         struct module_traverse *prev;
382         struct module *mod;
383 };
384
385 static int in_loop(struct module *mod, const struct module_traverse *traverse)
386 {
387         const struct module_traverse *i;
388
389         for (i = traverse; i; i = i->prev) {
390                 if (i->mod == mod)
391                         return 1;
392         }
393         return 0;
394 }
395
396 static char *basename(const char *name)
397 {
398         const char *base = strrchr(name, '/');
399         if (base) return (char *)base + 1;
400         return (char *)name;
401 }
402
403 /* Assume we are doing all the modules, so only report each loop once. */
404 static void report_loop(const struct module *mod,
405                         const struct module_traverse *traverse)
406 {
407         const struct module_traverse *i;
408
409         /* Check that start is least alphabetically.  eg.  a depends
410            on b depends on a will get reported for a, not b.  */
411         for (i = traverse->prev; i->prev; i = i->prev) {
412                 if (strcmp(mod->pathname, i->mod->pathname) > 0)
413                         return;
414         }
415
416         /* Is start in the loop?  If not, don't report now. eg. a
417            depends on b which depends on c which depends on b.  Don't
418            report when generating depends for a. */
419         if (mod != i->mod)
420                 return;
421
422         warn("Loop detected: %s ", mod->pathname);
423         for (i = traverse->prev; i->prev; i = i->prev)
424                 fprintf(stderr, "needs %s ", basename(i->mod->pathname));
425         fprintf(stderr, "which needs %s again!\n", basename(mod->pathname));
426 }
427
428 /* This is damn slow, but loops actually happen, and we don't want to
429    just exit() and leave the user without any modules. */
430 static int has_dep_loop(struct module *module, struct module_traverse *prev)
431 {
432         unsigned int i;
433         struct module_traverse traverse = { .prev = prev, .mod = module };
434
435         if (in_loop(module, prev)) {
436                 report_loop(module, &traverse);
437                 return 1;
438         }
439
440         for (i = 0; i < module->num_deps; i++)
441                 if (has_dep_loop(module->deps[i], &traverse))
442                         return 1;
443         return 0;
444 }
445
446 /* Uniquifies and orders a dependency list. */
447 static void order_dep_list(struct module *start, struct module *mod)
448 {
449         unsigned int i;
450
451         for (i = 0; i < mod->num_deps; i++) {
452                 /* If it was previously depended on, move it to the
453                    tail.  ie. if a needs b and c, and c needs b, we
454                    must order b after c. */
455                 list_del(&mod->deps[i]->dep_list);
456                 list_add_tail(&mod->deps[i]->dep_list, &start->dep_list);
457                 order_dep_list(start, mod->deps[i]);
458         }
459 }
460
461 static void del_module(struct module **modules, struct module *delme)
462 {
463         struct module **i;
464
465         /* Find pointer to it. */ 
466         for (i = modules; *i != delme; i = &(*i)->next);
467
468         *i = delme->next;
469 }
470
471 static void output_deps(struct module *modules,
472                         FILE *out)
473 {
474         struct module *i;
475
476         for (i = modules; i; i = i->next)
477                 i->ops->calculate_deps(i, verbose);
478
479         /* Strip out loops. */
480  again:
481         for (i = modules; i; i = i->next) {
482                 if (has_dep_loop(i, NULL)) {
483                         warn("Module %s ignored, due to loop\n",
484                              i->pathname + skipchars);
485                         del_module(&modules, i);
486                         goto again;
487                 }
488         }
489
490         /* Now dump them out. */
491         for (i = modules; i; i = i->next) {
492                 struct list_head *j, *tmp;
493                 order_dep_list(i, i);
494
495                 fprintf(out, "%s:", i->pathname + skipchars);
496                 list_for_each_safe(j, tmp, &i->dep_list) {
497                         struct module *dep
498                                 = list_entry(j, struct module, dep_list);
499                         fprintf(out, " %s", dep->pathname + skipchars);
500                         list_del_init(j);
501                 }
502                 fprintf(out, "\n");
503         }
504 }
505
506 static int smells_like_module(const char *name)
507 {
508         return ends_in(name,".ko") || ends_in(name, ".ko.gz");
509 }
510
511 typedef struct module *(*do_module_t)(const char *dirname,
512                                       const char *filename,
513                                       struct module *next,
514                                       struct module_search *search,
515                                       struct module_overrides *overrides);
516
517 static int is_higher_priority(const char *newpath, const char *oldpath,
518                               struct module_search *search,
519                               struct module_overrides *overrides)
520 {
521         char *p, *q, *s;
522         struct module_search *tmp;
523         struct module_overrides *ovtmp;
524         int i = 0;
525         int prio_builtin = -1;
526         int prio_new = -1;
527         int prio_old = -1;
528
529 /* The names already match, now we check for wildcard overrides and other
530  * high priority overrides we added to the config.
531  */
532         for (ovtmp=overrides;ovtmp!=NULL;ovtmp=ovtmp->next) {
533
534                 p = strstr(ovtmp->modfile,newpath);
535                 if (p)
536                         return 1;
537
538                 q = strstr(ovtmp->modfile,"*");
539                 if (q) {
540                         p = strstr(newpath, q+1);
541                         if (p)
542                                 return 1;
543
544                         p = strstr(oldpath, q+1);
545                         if (p)
546                                 return 0;
547                 }
548
549                 p = strstr(ovtmp->modfile,oldpath);
550                 if (p)
551                         return 0;
552         }
553         
554         for (i=0,tmp=search;tmp!=NULL;tmp=tmp->next,i++) {
555
556                 s = NOFAIL(malloc(strlen(tmp->search_path)+2));
557                 s[0] = '/';
558                 strncpy(s+1,tmp->search_path, strlen(tmp->search_path)+1);
559
560                 if (0 == strncmp(tmp->search_path,MODULE_BUILTIN_KEY,
561                                  strlen(MODULE_BUILTIN_KEY)))
562                         prio_builtin = i;
563                         
564                 p = strstr(newpath,s);
565                 if ((p) && ((p[strlen(s)] == '/')
566                         ||  (p[strlen(s)] == '\0')))
567                         prio_new = i;
568
569                 p = strstr(oldpath,s);
570                 if ((p) && ((p[strlen(s)] == '/')
571                         ||  (p[strlen(s)] == '\0')))
572                         prio_old = i;
573         
574                 free(s);
575                 
576         }
577
578         if (prio_new < 0)
579                 prio_new = prio_builtin;
580         
581         if (prio_old < 0)
582                 prio_old = prio_builtin;
583
584         return prio_new > prio_old;
585         
586 }
587
588
589 static struct module *do_module(const char *dirname,
590                                        const char *filename,
591                                        struct module *list,
592                                        struct module_search *search,
593                                        struct module_overrides *overrides)
594 {
595         struct module *new, **i;
596         
597         new = grab_module(dirname, filename);
598         if (!new)
599                 return list;
600         
601         /* Check if module is already in the list. */
602         for (i = &list; *i; i = &(*i)->next) {
603
604                 if (streq(basename((*i)->pathname), filename)) {
605
606                         char *newpath = NOFAIL(malloc(strlen(dirname)
607                                               + strlen("/")
608                                               + strlen(filename)
609                                               + 1));
610                         sprintf(newpath, "%s/%s", dirname, filename);
611
612                         if (is_higher_priority(newpath, (*i)->pathname,search,
613                                                overrides)) {
614                                 new->next = (*i)->next;
615
616                                 release_file((*i)->data, (*i)->len);
617                                 free(*i);
618
619                                 *i = new;
620                         } else
621                                 free(new);
622
623                         free(newpath);
624                         return list;
625                 }
626         }
627         
628         /* Not in the list already. Just prepend. */
629         
630         new->next = list;
631         return new;
632 }
633
634 static struct module *grab_dir(const char *dirname,
635                                DIR *dir,
636                                struct module *next,
637                                do_module_t do_mod,
638                                struct module_search *search,
639                                struct module_overrides *overrides)
640 {
641         struct dirent *dirent;
642
643         while ((dirent = readdir(dir)) != NULL) {
644                 if (smells_like_module(dirent->d_name))
645                         next = do_mod(dirname, dirent->d_name, next,
646                                       search, overrides);
647                 else if (!streq(dirent->d_name, ".")
648                          && !streq(dirent->d_name, "..")
649                          && !streq(dirent->d_name, "source")
650                          && !streq(dirent->d_name, "build")) {
651
652                         DIR *sub;
653                         char subdir[strlen(dirname) + 1
654                                    + strlen(dirent->d_name) + 1];
655                         sprintf(subdir, "%s/%s", dirname, dirent->d_name);
656                         sub = opendir(subdir);
657                         if (sub) {
658                                 next = grab_dir(subdir, sub, next, do_mod,
659                                                 search, overrides);
660                                 closedir(sub);
661                         }
662                 }
663         }
664         return next;
665 }
666
667 static struct module *grab_basedir(const char *dirname,
668                                    struct module_search *search,
669                                    struct module_overrides *overrides)
670 {
671         DIR *dir;
672         struct module *list;
673
674         dir = opendir(dirname);
675         if (!dir) {
676                 warn("Couldn't open directory %s: %s\n",
677                      dirname, strerror(errno));
678                 return NULL;
679         }
680         list = grab_dir(dirname, dir, NULL, do_module, search, overrides);
681         closedir(dir);
682
683         return list;
684 }
685
686 static void parse_modules(struct module *list)
687 {
688         struct module *i;
689
690         for (i = list; i; i = i->next) {
691                 i->ops->load_symbols(i);
692                 i->ops->fetch_tables(i);
693         }
694 }
695
696 /* Convert filename to the module name.  Works if filename == modname, too. */
697 static void filename2modname(char *modname, const char *filename)
698 {
699         const char *afterslash;
700         unsigned int i;
701
702         afterslash = strrchr(filename, '/');
703         if (!afterslash)
704                 afterslash = filename;
705         else
706                 afterslash++;
707
708         /* Convert to underscores, stop at first . */
709         for (i = 0; afterslash[i] && afterslash[i] != '.'; i++) {
710                 if (afterslash[i] == '-')
711                         modname[i] = '_';
712                 else
713                         modname[i] = afterslash[i];
714         }
715         modname[i] = '\0';
716 }
717
718 /* Simply dump hash table. */
719 static void output_symbols(struct module *unused, FILE *out)
720 {
721         unsigned int i;
722
723         fprintf(out, "# Aliases for symbols, used by symbol_request().\n");
724         for (i = 0; i < SYMBOL_HASH_SIZE; i++) {
725                 struct symbol *s;
726
727                 for (s = symbolhash[i]; s; s = s->next) {
728                         if (s->owner) {
729                                 char modname[strlen(s->owner->pathname)+1];
730                                 filename2modname(modname, s->owner->pathname);
731                                 fprintf(out, "alias symbol:%s %s\n",
732                                         s->name, modname);
733                         }
734                 }
735         }
736 }
737
738 static const char *next_string(const char *string, unsigned long *secsize)
739 {
740         /* Skip non-zero chars */
741         while (string[0]) {
742                 string++;
743                 if ((*secsize)-- <= 1)
744                         return NULL;
745         }
746
747         /* Skip any zero padding. */
748         while (!string[0]) {
749                 string++;
750                 if ((*secsize)-- <= 1)
751                         return NULL;
752         }
753         return string;
754 }
755
756 static void output_aliases(struct module *modules, FILE *out)
757 {
758         struct module *i;
759         const char *p;
760         unsigned long size;
761
762         fprintf(out, "# Aliases extracted from modules themselves.\n");
763         for (i = modules; i; i = i->next) {
764                 char modname[strlen(i->pathname)+1];
765
766                 filename2modname(modname, i->pathname);
767
768                 /* Grab from old-style .modalias section. */
769                 for (p = i->ops->get_aliases(i, &size);
770                      p;
771                      p = next_string(p, &size))
772                         fprintf(out, "alias %s %s\n", p, modname);
773
774                 /* Grab form new-style .modinfo section. */
775                 for (p = i->ops->get_modinfo(i, &size);
776                      p;
777                      p = next_string(p, &size)) {
778                         if (strncmp(p, "alias=", strlen("alias=")) == 0)
779                                 fprintf(out, "alias %s %s\n",
780                                         p + strlen("alias="), modname);
781                 }
782         }
783 }
784
785 struct depfile {
786         char *name;
787         void (*func)(struct module *, FILE *);
788 };
789
790 static struct depfile depfiles[] = {
791         { "modules.dep", output_deps }, /* This is what we check for '-A'. */
792         { "modules.pcimap", output_pci_table },
793         { "modules.usbmap", output_usb_table },
794         { "modules.ccwmap", output_ccw_table },
795         { "modules.ieee1394map", output_ieee1394_table },
796         { "modules.isapnpmap", output_isapnp_table },
797         { "modules.inputmap", output_input_table },
798         { "modules.ofmap", output_of_table },
799         { "modules.seriomap", output_serio_table },
800         { "modules.alias", output_aliases },
801         { "modules.symbols", output_symbols },
802 };
803
804 /* If we can't figure it out, it's safe to say "true". */
805 static int any_modules_newer(const char *dirname, time_t mtime)
806 {
807         DIR *dir;
808         struct dirent *dirent;
809
810         dir = opendir(dirname);
811         if (!dir)
812                 return 1;
813
814         while ((dirent = readdir(dir)) != NULL) {
815                 struct stat st;
816                 char file[strlen(dirname) + 1 + strlen(dirent->d_name) + 1];
817
818                 if (streq(dirent->d_name, ".") || streq(dirent->d_name, ".."))
819                         continue;
820
821                 sprintf(file, "%s/%s", dirname, dirent->d_name);
822                 if (lstat(file, &st) != 0)
823                         return 1;
824
825                 if (smells_like_module(dirent->d_name)) {
826                         if (st.st_mtime > mtime)
827                                 return 1;
828                 } else if (S_ISDIR(st.st_mode)) {
829                         if (any_modules_newer(file, mtime))
830                                 return 1;
831                 }
832         }
833         closedir(dir);
834         return 0;
835 }
836
837 static int depfile_out_of_date(const char *dirname)
838 {
839         struct stat st;
840         char depfile[strlen(dirname) + 1 + strlen(depfiles[0].name) + 1];
841
842         sprintf(depfile, "%s/%s", dirname, depfiles[0].name);
843
844         if (stat(depfile, &st) != 0)
845                 return 1;
846
847         return any_modules_newer(dirname, st.st_mtime);
848 }
849
850 static int fgetc_wrapped(FILE *file, unsigned int *linenum)
851 {
852         for (;;) {
853                 int ch = fgetc(file);
854                 if (ch != '\\')
855                         return ch;
856                 ch = fgetc(file);
857                 if (ch != '\n')
858                         return ch;
859                 if (linenum)
860                         (*linenum)++;
861         }
862 }
863
864 static char *getline_wrapped(FILE *file, unsigned int *linenum)
865 {
866         int size = 1024;
867         int i = 0;
868         char *buf = NOFAIL(malloc(size));
869         for(;;) {
870                 int ch = fgetc_wrapped(file, linenum);
871                 if (i == size) {
872                         size *= 2;
873                         buf = NOFAIL(realloc(buf, size));
874                 }
875                 if (ch < 0 && i == 0) {
876                         free(buf);
877                         return NULL;
878                 }
879                 if (ch < 0 || ch == '\n') {
880                         if (linenum)
881                                 (*linenum)++;
882                         buf[i] = '\0';
883                         return NOFAIL(realloc(buf, i+1));
884                 }
885                 buf[i++] = ch;
886         }
887 }
888
889
890 static char *strsep_skipspace(char **string, char *delim)
891 {
892         if (!*string)
893                 return NULL;
894         *string += strspn(*string, delim);
895         return strsep(string, delim);
896 }
897
898 static struct module_search *add_search(const char *search_path,
899                                         struct module_search *search)
900 {
901
902         struct module_search *new;
903         
904         new = NOFAIL(malloc(sizeof(*new)));
905         new->search_path = NOFAIL(strdup(search_path));
906         new->next = search;
907
908         return new;
909         
910 }
911
912 static struct module_overrides *add_override(const char *modfile,
913                                              struct module_overrides *overrides)
914 {
915
916         struct module_overrides *new;
917         
918         new = NOFAIL(malloc(sizeof(*new)));
919         new->modfile = NOFAIL(strdup(modfile));
920         new->next = overrides;
921
922         return new;
923         
924 }
925
926 /* Recursion */
927 static int read_config(const char *filename,
928                        const char *basedir,
929                        struct module_search **search,
930                        struct module_overrides **overrides);
931
932 static int read_config_file(const char *filename,
933                             const char *basedir,
934                             struct module_search **search,
935                             struct module_overrides **overrides)
936 {
937         char *line;
938         unsigned int linenum = 0;
939         FILE *cfile;
940
941         cfile = fopen(filename, "r");
942         if (!cfile) {
943                 if (errno != ENOENT)
944                         fatal("could not open '%s', reason: %s\n", filename,
945                               strerror(errno));
946                 return 0;
947         }
948
949         while ((line = getline_wrapped(cfile, &linenum)) != NULL) {
950                 char *ptr = line;
951                 char *cmd, *modname;
952
953                 cmd = strsep_skipspace(&ptr, "\t ");
954
955                 if (cmd == NULL || cmd[0] == '#' || cmd[0] == '\0')
956                         continue;
957
958                 if (strcmp(cmd, "search") == 0) {
959                         char *search_path;
960                         
961                         while ((search_path = strsep_skipspace(&ptr, "\t ")))
962                                 *search = add_search(search_path, *search);
963                 } else if (strcmp(cmd, "override") == 0) {
964                         char *pathname = NULL;
965                         modname = strsep_skipspace(&ptr, "\t ");
966                         char * version = strsep_skipspace(&ptr, "\t ");
967                         char * subdir = strsep_skipspace(&ptr, "\t ");
968
969                         pathname = NOFAIL(malloc(strlen(basedir)
970                                                + strlen(MODULE_DIR)
971                                                + strlen(version)
972                                                + strlen(subdir)
973                                                + strlen(modname)
974                                                + strlen(".ko")
975                                                + 3));
976                         sprintf(pathname, "%s%s%s/%s/%s.ko", basedir,
977                                 MODULE_DIR, version, subdir, modname);
978
979                         *overrides = add_override(pathname, *overrides);
980                 } else if (strcmp(cmd, "include") == 0) {
981                         char *newfilename;
982
983                         newfilename = strsep_skipspace(&ptr, "\t ");
984                         if (!newfilename)
985                                 grammar(cmd, filename, linenum);
986                         else {
987                                 if (!read_config(newfilename, basedir,
988                                                  search, overrides))
989                                         warn("Failed to open included"
990                                              " config file %s: %s\n",
991                                              newfilename, strerror(errno));
992                         }
993                 } else
994                         grammar(cmd, filename, linenum);
995
996                 free(line);
997         }
998         fclose(cfile);
999         return 1;
1000 }
1001
1002 /* Simple format, ignore lines starting with #, one command per line.
1003    Returns true or false. */
1004 static int read_config(const char *filename,
1005                        const char *basedir,
1006                        struct module_search **search,
1007                        struct module_overrides **overrides)
1008 {
1009         DIR *dir;
1010         int ret = 0;
1011
1012         dir = opendir(filename);
1013         if (dir) {
1014                 struct dirent *i;
1015                 while ((i = readdir(dir)) != NULL) {
1016                         if (!streq(i->d_name,".") && !streq(i->d_name,"..")) {
1017                                 char sub[strlen(filename) + 1
1018                                        + strlen(i->d_name) + 1];
1019
1020                                 sprintf(sub, "%s/%s", filename, i->d_name);
1021                                 if (!read_config(sub, basedir, search,
1022                                                  overrides))
1023                                         warn("Failed to open"
1024                                              " config file %s: %s\n",
1025                                              sub, strerror(errno));
1026                         }
1027                 }
1028                 closedir(dir);
1029                 ret = 1;
1030         } else {
1031                 if (read_config_file(filename, basedir, search, overrides))
1032                         ret = 1;
1033         }
1034
1035         return ret;
1036 }
1037
1038 static const char *default_configs[] =
1039 {
1040         "/etc/depmod.conf",
1041         "/etc/depmod.d",
1042 };
1043
1044 static void read_toplevel_config(const char *filename,
1045                                  const char *basedir,
1046                                  struct module_search **search,
1047                                  struct module_overrides **overrides)
1048 {
1049         unsigned int i;
1050
1051         if (filename) {
1052                 if (!read_config(filename, basedir, search, overrides))
1053                         fatal("Failed to open config file %s: %s\n",
1054                               filename, strerror(errno));
1055                 return;
1056         }
1057
1058         /* Try defaults. */
1059         for (i = 0; i < ARRAY_SIZE(default_configs); i++) {
1060                 if (read_config(default_configs[i], basedir, search, overrides))
1061                         return;
1062         }
1063 }
1064
1065
1066 int main(int argc, char *argv[])
1067 {
1068         int opt, all = 0, maybe_all = 0, doing_stdout = 0;
1069         char *basedir = "", *dirname, *version, *badopt = NULL,
1070                 *system_map = NULL;
1071         struct module *list = NULL;
1072         int i;
1073         const char *config = NULL;
1074         struct module_search *search = NULL;
1075         struct module_overrides *overrides = NULL;
1076
1077         /* Don't print out any errors just yet, we might want to exec
1078            backwards compat version. */
1079         opterr = 0;
1080         while ((opt = getopt_long(argc, argv, "ab:ArehnqruvVF:C:", options, NULL))
1081                != -1) {
1082                 switch (opt) {
1083                 case 'a':
1084                         all = 1;
1085                         break;
1086                 case 'b':
1087                         basedir = optarg;
1088                         skipchars = strlen(basedir);
1089                         break;
1090                 case 'A':
1091                         maybe_all = 1;
1092                         break;
1093                 case 'F':
1094                         system_map = optarg;
1095                         break;
1096                 case 'e':
1097                         print_unknown = 1;
1098                         break;
1099                 case 'v':
1100                         verbose = 1;
1101                         break;
1102                 case 'u':
1103                 case 'q':
1104                 case 'r':
1105                         break;
1106                 case 'C':
1107                         config = optarg;
1108                         break;
1109                 case 'h':
1110                         print_usage(argv[0]);
1111                         exit(0);
1112                         break;
1113                 case 'n':
1114                         doing_stdout = 1;
1115                         break;
1116                 case 'V':
1117                         printf("%s %s\n", PACKAGE, VERSION);
1118                         exit(0);
1119                 default:
1120                         badopt = argv[optind-1];
1121                 }
1122         }
1123
1124         /* We can't print unknowns without a System.map */
1125         if (!system_map)
1126                 print_unknown = 0;
1127         else
1128                 load_system_map(system_map);
1129
1130         /* They can specify the version naked on the command line */
1131         if (optind < argc && is_version_number(argv[optind])) {
1132                 version = NOFAIL(strdup(argv[optind]));
1133                 optind++;
1134         } else {
1135                 struct utsname buf;
1136                 uname(&buf);
1137                 version = NOFAIL(strdup(buf.release));
1138         }
1139
1140         /* Run old version if required. */
1141         if (old_module_version(version))
1142                 exec_old_depmod(argv);
1143
1144         if (badopt) {
1145                 fprintf(stderr, "%s: malformed/unrecognized option '%s'\n",
1146                         argv[0], badopt);
1147                 print_usage(argv[0]);
1148                 exit(1);
1149         }
1150
1151         /* Depmod -a by default if no names. */
1152         if (optind == argc)
1153                 all = 1;
1154
1155         dirname = NOFAIL(malloc(strlen(basedir)
1156                          + strlen(MODULE_DIR)
1157                          + strlen(version) + 1));
1158         sprintf(dirname, "%s%s%s", basedir, MODULE_DIR, version);
1159
1160         if (maybe_all) {
1161                 if (!doing_stdout && !depfile_out_of_date(dirname))
1162                         exit(0);
1163                 all = 1;
1164         }
1165
1166         read_toplevel_config(config, basedir, &search, &overrides);
1167
1168         /* For backward compatibility add "updates" to the head of the search
1169          * list here. But only if there was no "search" option specified.
1170          */
1171
1172         if (!search)
1173                 search = add_search("updates",search);
1174         
1175         if (!all) {
1176                 /* Do command line args. */
1177                 for (opt = optind; opt < argc; opt++) {
1178                         struct module *new = grab_module(NULL, argv[opt]);
1179                         if (new) {
1180                                 new->next = list;
1181                                 list = new;
1182                         }
1183                 }
1184         } else {
1185                 list = grab_basedir(dirname,search,overrides);
1186         }
1187         parse_modules(list);
1188
1189         for (i = 0; i < sizeof(depfiles)/sizeof(depfiles[0]); i++) {
1190                 FILE *out;
1191                 struct depfile *d = &depfiles[i];
1192                 char depname[strlen(dirname) + 1 + strlen(d->name) + 1];
1193                 char tmpname[strlen(dirname) + 1 + strlen(d->name) +
1194                                                 strlen(".temp") + 1];
1195
1196                 sprintf(depname, "%s/%s", dirname, d->name);
1197                 sprintf(tmpname, "%s/%s.temp", dirname, d->name);
1198                 if (!doing_stdout) {
1199                         out = fopen(tmpname, "w");
1200                         if (!out)
1201                                 fatal("Could not open %s for writing: %s\n",
1202                                         tmpname, strerror(errno));
1203                 } else
1204                         out = stdout;
1205                 d->func(list, out);
1206                 if (!doing_stdout) {
1207                         fclose(out);
1208                         if (rename(tmpname, depname) < 0)
1209                                 fatal("Could not rename %s into %s: %s\n",
1210                                         tmpname, depname, strerror(errno));
1211                 }
1212         }
1213
1214         free(dirname);
1215         free(version);
1216         
1217         return 0;
1218 }