ldetect/trunk/dmi.c

/* DMI (Desktop Management Interface)
   also called
   SMBIOS (System Management BIOS)
*/

#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "common.h"

char *dmidecode_file = NULL;


static const char *cat_BIOS[] = { "Vendor", "Version" };
static const char *cat_System[] = { "Manufacturer", "Product Name", "Version" };
static const char *cat_Base_Board[] = { "Manufacturer", "Product Name", "Version" };

struct category {
        const char *cat_name;
        unsigned int nb_fields;
        const char **fields;
};

static const struct category categories[] = {
        { "BIOS", psizeof(cat_BIOS), cat_BIOS },
        { "System", psizeof(cat_System), cat_System },
        { "Base Board", psizeof(cat_Base_Board), cat_Base_Board },

};
static int nb_categories = psizeof(categories);

struct criterion {
        char *name;
        char *val;
};
struct criteria {
        unsigned int nb;
        struct criterion *criteria;
};

/*********************************************************************************/
static int streq(const char *s1, const char *s2) {
        return strcmp(s1, s2) == 0;
}
static int str_begins_with(const char *s, const char *prefix) {
        return strncmp(s, prefix, strlen(prefix)) == 0;
}
static int remove_suffix_in_place(char *s, const char *suffix) {
        unsigned int l = strlen(s);
        unsigned int l_suffix = strlen(suffix);
        if (l >= l_suffix && streq(s + l - l_suffix, suffix)) {
                s[l - l_suffix] = '\0';
                return 1;
        } else
                return 0;
}
static void remove_ending_spaces(char *s) {
        char *p;
        for (p = s + strlen(s) - 1; p >= s; p--) {
                if (*p != '\n' && *p != '\r' && *p != ' ' && *p != '\t')
                        break;
                *p = '\0';
        }
}
static char *skip_leading_spaces(char *s) {
        for (; *s; s++)
                if (*s != '\n' && *s != '\r' && *s != ' ' && *s != '\t')
                        break;
        return s;
}

/*********************************************************************************/
static char *get_after_colon(char *s) {
        char *p = strchr(s, ':');
        if (p) {
                *p = '\0';
                return p + (p[1] == ' ' ? 2 : 1);
        } else return NULL;
}

static const struct category *lookup_category(const char *cat_name) {
        int i;
        for (i = 0; i < nb_categories; i++)
                if (streq(categories[i].cat_name, cat_name))
                        return &categories[i];
        return NULL;
}

static int lookup_field(const struct category *category, const char *field_name) {
        unsigned int i;
        for (i = 0; i < category->nb_fields; i++)
                if (streq(category->fields[i], field_name))
                        return 1;
        return 0;
}

static char *lookup_criteria(struct criteria criteria, const char *field) {
        unsigned int i;
        for (i = 0; i < criteria.nb; i++)
                if (streq(criteria.criteria[i].name, field))
                        return criteria.criteria[i].val;
        return NULL;
}

/*********************************************************************************/
static struct criteria criteria_from_dmidecode(void) {
        FILE *f;
        char buf[BUF_SIZE];

        struct criteria r = {0, NULL};
        size_t allocated = MAX_DEVICES;

        if (!(f = dmidecode_file ? fopen(dmidecode_file, "r") : popen("dmidecode", "r"))) {
                perror("dmidecode");
                return r;
        }

        r.criteria = malloc(sizeof(*r.criteria) * MAX_DEVICES);

        const struct category *category = NULL;

        /* dmidecode output is less indented as of 2.7 */
        int tab_level = 1;
        if (fgets(buf, sizeof(buf) - 1, f)) {
                int major, minor;
                if (sscanf(buf, "# dmidecode %d.%d", &major, &minor) == 2 && major >= 2 && minor >= 7)
                        tab_level = 0;
        }

        while (fgets(buf, sizeof(buf) - 1, f)) {
                if (!buf[0] || !buf[1] || (tab_level && buf[0] != '\t'))
                        ; /* don't care */
                else if (buf[tab_level] != '\t') {
                        char *s = buf + tab_level;
                        if (!str_begins_with(s, "DMI type ")) {
                                remove_ending_spaces(s);
                                remove_suffix_in_place(s, " Information");
                                category = lookup_category(s);
                        }
                } else if (category) {
                        /* don't even look if we don't have an interesting category */
                        char *s = buf + tab_level + 1;
                        char *val = get_after_colon(s);
                        if (val && lookup_field(category, s)) {
                                if (r.nb >= allocated) {
                                    allocated = r.nb*2;
                                    r.criteria = realloc(r.criteria, sizeof(struct criterion) * allocated);
                                }
                                struct criterion *criterion = &r.criteria[r.nb++];
                                asprintf(&criterion->name, "%s/%s", category->cat_name, s);
                                remove_ending_spaces(val);
                                criterion->val = strdup(skip_leading_spaces(val));
                        }
                }
        }
        if (dmidecode_file ? fclose(f) != 0 : pclose(f) == -1) {
                r.nb = 0;
                return r;
        }
        r.criteria = realloc(r.criteria, sizeof(*r.criteria) * r.nb);

        return r;
}

static void free_criteria(struct criteria criteria) {
        unsigned int i;
        for (i = 0; i < criteria.nb; i++) {
                free(criteria.criteria[i].name);
                free(criteria.criteria[i].val);
        }
        if (criteria.nb) free(criteria.criteria);
        criteria.nb = 0;
}

static struct dmi_entries entries_matching_criteria(struct criteria criteria) {
        fh f;
        char buf[2048];
        int line;
        struct dmi_entries r;
        #define MAX_INDENT 20
        int valid[MAX_INDENT];
        char *constraints[MAX_INDENT];

        enum state { in_constraints, in_implies } state = in_implies;
        int was_a_blank_line = 1;
        size_t allocated = MAX_DEVICES;

        r.nb = 0;
        f = fh_open("dmitable");

#define die(err) do { fprintf(stderr, "%s %d: " err "\n", "dmitable", line); exit(1); } while (0)

        r.entries = malloc(sizeof(*r.entries) * MAX_DEVICES);

#define foreach_indent(min, action) do { int i; for (i = min; i < MAX_INDENT; i++) { action; } } while (0)
        
        foreach_indent(0, valid[i] = 1; constraints[i] = NULL);

        int previous_refine = 0;

        for (line = 1; fh_gets(buf, sizeof(buf) - 1, &f); line++) {
                char *s = skip_leading_spaces(buf);
                if (*s == '#') continue; // skip comments

                if (!*s) {
                        was_a_blank_line = 1;
                } else {
                        int refine = s - buf;
                        if (refine > MAX_INDENT) die("too indented constraints");

                        remove_ending_spaces(s);
                        if (str_begins_with(s, "=> ")) {
                                if (refine != previous_refine) die("\"=>\" must not be indented");
                                state = in_implies;
                                was_a_blank_line = 0;
                                
                                if (valid[refine]) {
                                        if (r.nb >= allocated) {
                                            allocated = r.nb*2;
                                            r.entries = realloc(r.entries, sizeof(struct criterion) * allocated);
                                        }
                                        struct dmi_entry *entry = &r.entries[r.nb++];

                                        s += strlen("=> ");
                                        char *val = get_after_colon(s);
                                        if (!val) die("invalid value");
                                        asprintf(&entry->module, "%s:%s", s, val);

                                        char tmp[BUF_SIZE];
                                        tmp[0] = '\0';

                                        int i;
                                        for (i = 0; i <= refine; i++)
                                                if (constraints[i]) {
                                                        if (i) strncat(tmp, "|", BUF_SIZE);
                                                        strncat(tmp, constraints[i], BUF_SIZE);
                                                }
                                        entry->constraints = strdup(tmp);
                                }
                        } else {
                                if (state == in_constraints && refine == previous_refine) die("to refine, indent");
                                if (!was_a_blank_line) die("missing empty line");
                                state = in_constraints;
                                previous_refine = refine;
                                was_a_blank_line = 0;

                                if (refine == 0 || valid[refine - 1]) {

                                        char *wanted_val = get_after_colon(s);
                                        if (!wanted_val) die("bad format");

                                        char *wanted_val_orig = strdup(wanted_val);
                                        char *val = lookup_criteria(criteria, s);

                                        int ok = wanted_val && val && (
                                                remove_suffix_in_place(wanted_val, ".*") ?
                                                str_begins_with(val, wanted_val) :
                                                streq(val, wanted_val));
                                
                                        foreach_indent(refine, valid[i] = ok; ifree(constraints[i]));
                                        if (ok) 
                                                constraints[refine] = wanted_val_orig;
                                        else
                                                free(wanted_val_orig);

                                } /* otherwise no need checking */                              
                        }                       
                }
        }
        foreach_indent(0, ifree(constraints[i]));
        fh_close(&f);

        r.entries = realloc(r.entries, sizeof(*r.entries) * r.nb);
        return r;
}

extern void dmi_entries_free(struct dmi_entries entries) {
        unsigned int i;
        for (i = 0; i < entries.nb; i++) {
                free(entries.entries[i].constraints);
                free(entries.entries[i].module);
        }
        if (entries.nb) free(entries.entries);
        entries.nb = 0;
}

extern struct dmi_entries dmi_probe(void) {
        struct criteria criteria = criteria_from_dmidecode();
        struct dmi_entries entries = entries_matching_criteria(criteria);
        free_criteria(criteria);

        return entries;
}

1	/* DMI (Desktop Management Interface)
2	also called
3	SMBIOS (System Management BIOS)
4	*/
5
6	#define _GNU_SOURCE
7	#include <stdio.h>
8	#include <string.h>
9	#include <stdlib.h>
10	#include "common.h"
11
12	char *dmidecode_file = NULL;
13
14
15	static const char *cat_BIOS[] = { "Vendor", "Version" };
16	static const char *cat_System[] = { "Manufacturer", "Product Name", "Version" };
17	static const char *cat_Base_Board[] = { "Manufacturer", "Product Name", "Version" };
18
19	struct category {
20	const char *cat_name;
21	unsigned int nb_fields;
22	const char **fields;
23	};
24
25	static const struct category categories[] = {
26	{ "BIOS", psizeof(cat_BIOS), cat_BIOS },
27	{ "System", psizeof(cat_System), cat_System },
28	{ "Base Board", psizeof(cat_Base_Board), cat_Base_Board },
29
30	};
31	static int nb_categories = psizeof(categories);
32
33	struct criterion {
34	char *name;
35	char *val;
36	};
37	struct criteria {
38	unsigned int nb;
39	struct criterion *criteria;
40	};
41
42	/*********************************************************************************/
43	static int streq(const char s1, const char s2) {
44	return strcmp(s1, s2) == 0;
45	}
46	static int str_begins_with(const char s, const char prefix) {
47	return strncmp(s, prefix, strlen(prefix)) == 0;
48	}
49	static int remove_suffix_in_place(char s, const char suffix) {
50	unsigned int l = strlen(s);
51	unsigned int l_suffix = strlen(suffix);
52	if (l >= l_suffix && streq(s + l - l_suffix, suffix)) {
53	s[l - l_suffix] = '\0';
54	return 1;
55	} else
56	return 0;
57	}
58	static void remove_ending_spaces(char *s) {
59	char *p;
60	for (p = s + strlen(s) - 1; p >= s; p--) {
61	if (p != '\n' && p != '\r' && p != ' ' && p != '\t')
62	break;
63	*p = '\0';
64	}
65	}
66	static char skip_leading_spaces(char s) {
67	for (; *s; s++)
68	if (s != '\n' && s != '\r' && s != ' ' && s != '\t')
69	break;
70	return s;
71	}
72
73	/*********************************************************************************/
74	static char get_after_colon(char s) {
75	char *p = strchr(s, ':');
76	if (p) {
77	*p = '\0';
78	return p + (p[1] == ' ' ? 2 : 1);
79	} else return NULL;
80	}
81
82	static const struct category lookup_category(const char cat_name) {
83	int i;
84	for (i = 0; i < nb_categories; i++)
85	if (streq(categories[i].cat_name, cat_name))
86	return &categories[i];
87	return NULL;
88	}
89
90	static int lookup_field(const struct category category, const char field_name) {
91	unsigned int i;
92	for (i = 0; i < category->nb_fields; i++)
93	if (streq(category->fields[i], field_name))
94	return 1;
95	return 0;
96	}
97
98	static char lookup_criteria(struct criteria criteria, const char field) {
99	unsigned int i;
100	for (i = 0; i < criteria.nb; i++)
101	if (streq(criteria.criteria[i].name, field))
102	return criteria.criteria[i].val;
103	return NULL;
104	}
105
106	/*********************************************************************************/
107	static struct criteria criteria_from_dmidecode(void) {
108	FILE *f;
109	char buf[BUF_SIZE];
110
111	struct criteria r = {0, NULL};
112	size_t allocated = MAX_DEVICES;
113
114	if (!(f = dmidecode_file ? fopen(dmidecode_file, "r") : popen("dmidecode", "r"))) {
115	perror("dmidecode");
116	return r;
117	}
118
119	r.criteria = malloc(sizeof(r.criteria) MAX_DEVICES);
120
121	const struct category *category = NULL;
122
123	/* dmidecode output is less indented as of 2.7 */
124	int tab_level = 1;
125	if (fgets(buf, sizeof(buf) - 1, f)) {
126	int major, minor;
127	if (sscanf(buf, "# dmidecode %d.%d", &major, &minor) == 2 && major >= 2 && minor >= 7)
128	tab_level = 0;
129	}
130
131	while (fgets(buf, sizeof(buf) - 1, f)) {
132	if (!buf[0] \|\| !buf[1] \|\| (tab_level && buf[0] != '\t'))
133	; /* don't care */
134	else if (buf[tab_level] != '\t') {
135	char *s = buf + tab_level;
136	if (!str_begins_with(s, "DMI type ")) {
137	remove_ending_spaces(s);
138	remove_suffix_in_place(s, " Information");
139	category = lookup_category(s);
140	}
141	} else if (category) {
142	/* don't even look if we don't have an interesting category */
143	char *s = buf + tab_level + 1;
144	char *val = get_after_colon(s);
145	if (val && lookup_field(category, s)) {
146	if (r.nb >= allocated) {
147	allocated = r.nb*2;
148	r.criteria = realloc(r.criteria, sizeof(struct criterion) * allocated);
149	}
150	struct criterion *criterion = &r.criteria[r.nb++];
151	asprintf(&criterion->name, "%s/%s", category->cat_name, s);
152	remove_ending_spaces(val);
153	criterion->val = strdup(skip_leading_spaces(val));
154	}
155	}
156	}
157	if (dmidecode_file ? fclose(f) != 0 : pclose(f) == -1) {
158	r.nb = 0;
159	return r;
160	}
161	r.criteria = realloc(r.criteria, sizeof(r.criteria) r.nb);
162
163	return r;
164	}
165
166	static void free_criteria(struct criteria criteria) {
167	unsigned int i;
168	for (i = 0; i < criteria.nb; i++) {
169	free(criteria.criteria[i].name);
170	free(criteria.criteria[i].val);
171	}
172	if (criteria.nb) free(criteria.criteria);
173	criteria.nb = 0;
174	}
175
176	static struct dmi_entries entries_matching_criteria(struct criteria criteria) {
177	fh f;
178	char buf[2048];
179	int line;
180	struct dmi_entries r;
181	#define MAX_INDENT 20
182	int valid[MAX_INDENT];
183	char *constraints[MAX_INDENT];
184
185	enum state { in_constraints, in_implies } state = in_implies;
186	int was_a_blank_line = 1;
187	size_t allocated = MAX_DEVICES;
188
189	r.nb = 0;
190	f = fh_open("dmitable");
191
192	#define die(err) do { fprintf(stderr, "%s %d: " err "\n", "dmitable", line); exit(1); } while (0)
193
194	r.entries = malloc(sizeof(r.entries) MAX_DEVICES);
195
196	#define foreach_indent(min, action) do { int i; for (i = min; i < MAX_INDENT; i++) { action; } } while (0)
197
198	foreach_indent(0, valid[i] = 1; constraints[i] = NULL);
199
200	int previous_refine = 0;
201
202	for (line = 1; fh_gets(buf, sizeof(buf) - 1, &f); line++) {
203	char *s = skip_leading_spaces(buf);
204	if (*s == '#') continue; // skip comments
205
206	if (!*s) {
207	was_a_blank_line = 1;
208	} else {
209	int refine = s - buf;
210	if (refine > MAX_INDENT) die("too indented constraints");
211
212	remove_ending_spaces(s);
213	if (str_begins_with(s, "=> ")) {
214	if (refine != previous_refine) die("\"=>\" must not be indented");
215	state = in_implies;
216	was_a_blank_line = 0;
217
218	if (valid[refine]) {
219	if (r.nb >= allocated) {
220	allocated = r.nb*2;
221	r.entries = realloc(r.entries, sizeof(struct criterion) * allocated);
222	}
223	struct dmi_entry *entry = &r.entries[r.nb++];
224
225	s += strlen("=> ");
226	char *val = get_after_colon(s);
227	if (!val) die("invalid value");
228	asprintf(&entry->module, "%s:%s", s, val);
229
230	char tmp[BUF_SIZE];
231	tmp[0] = '\0';
232
233	int i;
234	for (i = 0; i <= refine; i++)
235	if (constraints[i]) {
236	if (i) strncat(tmp, "\|", BUF_SIZE);
237	strncat(tmp, constraints[i], BUF_SIZE);
238	}
239	entry->constraints = strdup(tmp);
240	}
241	} else {
242	if (state == in_constraints && refine == previous_refine) die("to refine, indent");
243	if (!was_a_blank_line) die("missing empty line");
244	state = in_constraints;
245	previous_refine = refine;
246	was_a_blank_line = 0;
247
248	if (refine == 0 \|\| valid[refine - 1]) {
249
250	char *wanted_val = get_after_colon(s);
251	if (!wanted_val) die("bad format");
252
253	char *wanted_val_orig = strdup(wanted_val);
254	char *val = lookup_criteria(criteria, s);
255
256	int ok = wanted_val && val && (
257	remove_suffix_in_place(wanted_val, ".*") ?
258	str_begins_with(val, wanted_val) :
259	streq(val, wanted_val));
260
261	foreach_indent(refine, valid[i] = ok; ifree(constraints[i]));
262	if (ok)
263	constraints[refine] = wanted_val_orig;
264	else
265	free(wanted_val_orig);
266
267	} /* otherwise no need checking */
268	}
269	}
270	}
271	foreach_indent(0, ifree(constraints[i]));
272	fh_close(&f);
273
274	r.entries = realloc(r.entries, sizeof(r.entries) r.nb);
275	return r;
276	}
277
278	extern void dmi_entries_free(struct dmi_entries entries) {
279	unsigned int i;
280	for (i = 0; i < entries.nb; i++) {
281	free(entries.entries[i].constraints);
282	free(entries.entries[i].module);
283	}
284	if (entries.nb) free(entries.entries);
285	entries.nb = 0;
286	}
287
288	extern struct dmi_entries dmi_probe(void) {
289	struct criteria criteria = criteria_from_dmidecode();
290	struct dmi_entries entries = entries_matching_criteria(criteria);
291	free_criteria(criteria);
292
293	return entries;
294	}
295