ldetect/trunk/modalias.c

#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/utsname.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <modprobe.h>
#include <dirent.h>
#include "common.h"

static char *aliasdefault = NULL;

static void free_aliases(struct module_alias *aliases) {
        if (aliases == NULL) 
                return;
        while (aliases->next) {
                struct module_alias *next;
                next = aliases->next;
                free(aliases->module);
                free(aliases);
                aliases = next;
        }
        free(aliases);
}

static void free_options(struct module_options *modoptions) {
        if (modoptions == NULL) 
                return;
        while (modoptions->next) {
                struct module_options *next;
                next = modoptions->next;
                free(modoptions->modulename);
                free(modoptions->options);
                free(modoptions);
                modoptions = next;
        }
        free(modoptions);
}

static void free_commands(struct module_command *commands) {
        if (commands == NULL) 
                return;
        while (commands->next) {
                struct module_command *next;
                next = commands->next;
                free(commands->modulename);
                free(commands->command);
                free(commands);
                commands = next;
        }
        free(commands);
}

static void free_blacklist(struct module_blacklist *blacklist) {
        if (blacklist == NULL) 
                return;
        while (blacklist->next) {
                struct module_blacklist *next;
                next = blacklist->next;
                free(blacklist->modulename);
                free(blacklist);
                blacklist = next;
        }
        free(blacklist);
}

static void set_default_alias_file(void) {
        struct utsname rel_buf;
        if (!aliasdefault) {
                char *dirname;
                char *fallback_aliases = table_name_to_file("fallback-modules.alias");
                char *aliasfilename;
                struct stat st_alias, st_fallback;

                uname(&rel_buf);
                asprintf(&dirname, "%s/%s", MODULE_DIR, rel_buf.release);
                asprintf(&aliasfilename, "%s/modules.alias", dirname);
                free(dirname);

                /* fallback on ldetect-lst's modules.alias and prefer it if more recent */
                if (stat(aliasfilename, &st_alias) ||
                    (!stat(fallback_aliases, &st_fallback) && st_fallback.st_mtime > st_alias.st_mtime)) {
                        free(aliasfilename);
                        aliasdefault = fallback_aliases;
                } else {
                        aliasdefault = aliasfilename;
                }
        }
}

char *modalias_resolve_module(const char *modalias) {
        struct module_command *commands = NULL;
        struct module_options *modoptions = NULL;
        struct module_alias *aliases = NULL;
        struct module_blacklist *blacklist = NULL;
        const char *config = NULL;

        if (!aliasdefault)
                set_default_alias_file();

        /* Returns the resolved alias, options */
        read_toplevel_config(config, modalias, 0,
                             0, &modoptions, &commands, &aliases, &blacklist);

        if (!aliases) {
                /* We only use canned aliases as last resort. */
                char *dkms_file = table_name_to_file("dkms-modules.alias");
                char *alias_filelist[] = {
                        "/lib/module-init-tools/ldetect-lst-modules.alias",
                        aliasdefault,
                        dkms_file,
                        NULL,
                };
                char **alias_file = alias_filelist;
                while (!aliases && *alias_file) {
                        read_config(*alias_file, modalias, 0,
                                    0, &modoptions, &commands,
                                    &aliases, &blacklist);
                        aliases = apply_blacklist(aliases, blacklist);
                        alias_file++;
                }
                free(dkms_file);
        }
        free_blacklist(blacklist);
        free_commands(commands);
        free_options(modoptions);
        if (aliases) {
                char *result;
                // take the last one because we find eg: generic/ata_generic/sata_sil
                struct module_alias *it = aliases;
                while (it->next)
                        it = it->next;

                result = strdup(it->module);
                free_aliases(aliases);
                return result;
        }

        return NULL;
}

void modalias_cleanup(void) {
    ifree(aliasdefault);
}
1	dmorgan	1357	#define _GNU_SOURCE
2			#include <sys/types.h>
3			#include <sys/stat.h>
4			#include <sys/wait.h>
5			#include <sys/utsname.h>
6			#include <fcntl.h>
7			#include <unistd.h>
8			#include <stdio.h>
9			#include <stdlib.h>
10			#include <string.h>
11			#include <modprobe.h>
12			#include <dirent.h>
13			#include "common.h"
14
15			static char *aliasdefault = NULL;
16
17			static void free_aliases(struct module_alias *aliases) {
18			if (aliases == NULL)
19			return;
20			while (aliases->next) {
21			struct module_alias *next;
22			next = aliases->next;
23			free(aliases->module);
24			free(aliases);
25			aliases = next;
26			}
27			free(aliases);
28			}
29
30			static void free_options(struct module_options *modoptions) {
31			if (modoptions == NULL)
32			return;
33			while (modoptions->next) {
34			struct module_options *next;
35			next = modoptions->next;
36			free(modoptions->modulename);
37			free(modoptions->options);
38			free(modoptions);
39			modoptions = next;
40			}
41			free(modoptions);
42			}
43
44			static void free_commands(struct module_command *commands) {
45			if (commands == NULL)
46			return;
47			while (commands->next) {
48			struct module_command *next;
49			next = commands->next;
50			free(commands->modulename);
51			free(commands->command);
52			free(commands);
53			commands = next;
54			}
55			free(commands);
56			}
57
58			static void free_blacklist(struct module_blacklist *blacklist) {
59			if (blacklist == NULL)
60			return;
61			while (blacklist->next) {
62			struct module_blacklist *next;
63			next = blacklist->next;
64			free(blacklist->modulename);
65			free(blacklist);
66			blacklist = next;
67			}
68			free(blacklist);
69			}
70
71			static void set_default_alias_file(void) {
72			struct utsname rel_buf;
73			if (!aliasdefault) {
74			char *dirname;
75			char *fallback_aliases = table_name_to_file("fallback-modules.alias");
76			char *aliasfilename;
77			struct stat st_alias, st_fallback;
78
79			uname(&rel_buf);
80			asprintf(&dirname, "%s/%s", MODULE_DIR, rel_buf.release);
81			asprintf(&aliasfilename, "%s/modules.alias", dirname);
82			free(dirname);
83
84			/* fallback on ldetect-lst's modules.alias and prefer it if more recent */
85			if (stat(aliasfilename, &st_alias) \|\|
86			(!stat(fallback_aliases, &st_fallback) && st_fallback.st_mtime > st_alias.st_mtime)) {
87			free(aliasfilename);
88			aliasdefault = fallback_aliases;
89			} else {
90			aliasdefault = aliasfilename;
91			}
92			}
93			}
94
95			char modalias_resolve_module(const char modalias) {
96			struct module_command *commands = NULL;
97			struct module_options *modoptions = NULL;
98			struct module_alias *aliases = NULL;
99			struct module_blacklist *blacklist = NULL;
100			const char *config = NULL;
101
102			if (!aliasdefault)
103			set_default_alias_file();
104
105			/* Returns the resolved alias, options */
106			read_toplevel_config(config, modalias, 0,
107			0, &modoptions, &commands, &aliases, &blacklist);
108
109			if (!aliases) {
110			/* We only use canned aliases as last resort. */
111			char *dkms_file = table_name_to_file("dkms-modules.alias");
112			char *alias_filelist[] = {
113			"/lib/module-init-tools/ldetect-lst-modules.alias",
114			aliasdefault,
115			dkms_file,
116			NULL,
117			};
118			char **alias_file = alias_filelist;
119			while (!aliases && *alias_file) {
120			read_config(*alias_file, modalias, 0,
121			0, &modoptions, &commands,
122			&aliases, &blacklist);
123			aliases = apply_blacklist(aliases, blacklist);
124			alias_file++;
125			}
126			free(dkms_file);
127			}
128			free_blacklist(blacklist);
129			free_commands(commands);
130			free_options(modoptions);
131			if (aliases) {
132			char *result;
133			// take the last one because we find eg: generic/ata_generic/sata_sil
134			struct module_alias *it = aliases;
135			while (it->next)
136			it = it->next;
137
138			result = strdup(it->module);
139			free_aliases(aliases);
140			return result;
141			}
142
143			return NULL;
144			}
145
146			void modalias_cleanup(void) {
147			ifree(aliasdefault);
148			}