blob: 716b41780c4004d4446561ab30b235257ef63fdd [file] [log] [blame]
Michael Karcher6701ee82010-01-20 14:14:11 +00001/*
2 * This file is part of the flashrom project.
3 *
Sean Nelson4c6d3a42013-09-11 23:35:03 +00004 * Copyright (C) 2000-2002 Alan Cox <alan@redhat.com>
5 * Copyright (C) 2002-2010 Jean Delvare <khali@linux-fr.org>
Michael Karcher6701ee82010-01-20 14:14:11 +00006 * Copyright (C) 2009,2010 Michael Karcher
Sean Nelson4c6d3a42013-09-11 23:35:03 +00007 * Copyright (C) 2011-2013 Stefan Tauner
Michael Karcher6701ee82010-01-20 14:14:11 +00008 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
Michael Karcher6701ee82010-01-20 14:14:11 +000018 */
19
Stefan Taunerdc627932015-01-27 18:07:50 +000020/* strnlen is in POSIX but was a GNU extension up to glibc 2.10 */
21#if (__GLIBC__ == 2 && __GLIBC_MINOR__ < 10) || __GLIBC__ < 2
22#define _GNU_SOURCE
23#else
24#define _POSIX_C_SOURCE 200809L
25#endif
26
Carl-Daniel Hailfinger1c6d2ff2012-08-27 00:44:42 +000027#include <strings.h>
Michael Karcher6701ee82010-01-20 14:14:11 +000028#include <string.h>
Stefan Tauner9972d152014-07-13 12:52:15 +000029#include <ctype.h>
Felix Singerdd5f6932022-08-19 03:33:27 +020030#include <stdbool.h>
Michael Karcher6701ee82010-01-20 14:14:11 +000031#include <stdio.h>
32#include <stdlib.h>
33
Stefan Tauner4f444792011-06-27 11:44:03 +000034#include "platform.h"
Michael Karcher6701ee82010-01-20 14:14:11 +000035#include "flash.h"
Thomas Heijligencce1e5b2021-11-02 20:33:35 +010036#include "hwaccess.h"
Carl-Daniel Hailfinger5b997c32010-07-27 22:41:39 +000037#include "programmer.h"
Michael Karcher6701ee82010-01-20 14:14:11 +000038
Sean Nelson4c6d3a42013-09-11 23:35:03 +000039/* Enable SMBIOS decoding. Currently legacy DMI decoding is enough. */
40#define SM_SUPPORT 0
41
42/* Strings longer than 4096 in DMI are just insane. */
43#define DMI_MAX_ANSWER_LEN 4096
44
Carl-Daniel Hailfingere1fdff42010-06-23 23:14:44 +000045int has_dmi_support = 0;
46
Sean Nelson4c6d3a42013-09-11 23:35:03 +000047static struct {
48 const char *const keyword;
49 const uint8_t type;
50 const uint8_t offset;
51 char *value;
52} dmi_strings[] = {
53 { "system-manufacturer", 1, 0x04, NULL },
54 { "system-product-name", 1, 0x05, NULL },
55 { "system-version", 1, 0x06, NULL },
56 { "baseboard-manufacturer", 2, 0x04, NULL },
57 { "baseboard-product-name", 2, 0x05, NULL },
58 { "baseboard-version", 2, 0x06, NULL },
Michael Karcher6701ee82010-01-20 14:14:11 +000059};
60
Stefan Taunera34d7192011-07-26 00:54:42 +000061/* This list is used to identify supposed laptops. The is_laptop field has the
62 * following meaning:
Elyes HAOUASac01baa2018-05-28 16:52:21 +020063 * - 0: in all likelihood not a laptop
64 * - 1: in all likelihood a laptop
65 * - 2: chassis-type is not specific enough
Stefan Taunera34d7192011-07-26 00:54:42 +000066 * A full list of chassis types can be found in the System Management BIOS
Carl-Daniel Hailfingercb3eb052010-09-26 21:43:53 +000067 * (SMBIOS) Reference Specification 2.7.0 section 7.4.1 "Chassis Types" at
68 * http://www.dmtf.org/sites/default/files/standards/documents/DSP0134_2.7.0.pdf
69 * The types below are the most common ones.
70 */
71static const struct {
Sean Nelson4c6d3a42013-09-11 23:35:03 +000072 uint8_t type;
73 uint8_t is_laptop;
Jacob Garber4a84ec22019-07-25 19:12:31 -060074 const char *name;
Carl-Daniel Hailfingercb3eb052010-09-26 21:43:53 +000075} dmi_chassis_types[] = {
Stefan Taunera34d7192011-07-26 00:54:42 +000076 {0x01, 2, "Other"},
77 {0x02, 2, "Unknown"},
Stefan Tauner4c5665f2012-02-17 20:03:37 +000078 {0x03, 0, "Desktop"},
79 {0x04, 0, "Low Profile Desktop"},
Stefan Taunera34d7192011-07-26 00:54:42 +000080 {0x06, 0, "Mini Tower"},
81 {0x07, 0, "Tower"},
Carl-Daniel Hailfingercb3eb052010-09-26 21:43:53 +000082 {0x08, 1, "Portable"},
83 {0x09, 1, "Laptop"},
84 {0x0a, 1, "Notebook"},
85 {0x0b, 1, "Hand Held"},
86 {0x0e, 1, "Sub Notebook"},
Stefan Taunera34d7192011-07-26 00:54:42 +000087 {0x11, 0, "Main Server Chassis"},
88 {0x17, 0, "Rack Mount Chassis"},
Sylvain "ythier" Hitier3093f8f2011-09-03 11:22:27 +000089 {0x18, 0, "Sealed-case PC"}, /* used by Supermicro (X8SIE) */
Stefan Tauner23e10b82016-01-23 16:16:49 +000090 {0x19, 0, "Multi-system"}, /* used by Supermicro (X7DWT) */
Carl-Daniel Hailfingercb3eb052010-09-26 21:43:53 +000091};
92
Sean Nelson4c6d3a42013-09-11 23:35:03 +000093#if CONFIG_INTERNAL_DMI == 1
Sean Nelson4c6d3a42013-09-11 23:35:03 +000094static bool dmi_checksum(const uint8_t * const buf, size_t len)
95{
96 uint8_t sum = 0;
97 size_t a;
98
99 for (a = 0; a < len; a++)
100 sum += buf[a];
101 return (sum == 0);
102}
103
Stefan Tauner9972d152014-07-13 12:52:15 +0000104/** Retrieve a DMI string.
105 *
106 * See SMBIOS spec. section 6.1.3 "Text strings".
107 * The table will be unmapped ASAP, hence return a duplicated & sanitized string that needs to be freed later.
108 *
109 * \param buf the buffer to search through (usually appended directly to a DMI structure)
110 * \param string_id index of the string to look for
111 * \param limit pointer to the first byte beyond \em buf
112 */
113static char *dmi_string(const char *buf, uint8_t string_id, const char *limit)
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000114{
115 size_t i, len;
116
117 if (string_id == 0)
Stefan Tauner778c6d82014-09-05 16:14:11 +0000118 return strdup("Not Specified");
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000119
120 while (string_id > 1 && string_id--) {
Stefan Tauner9972d152014-07-13 12:52:15 +0000121 if (buf >= limit) {
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000122 msg_perr("DMI table is broken (string portion out of bounds)!\n");
Stefan Tauner778c6d82014-09-05 16:14:11 +0000123 return strdup("<OUT OF BOUNDS>");
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000124 }
Stefan Tauner9972d152014-07-13 12:52:15 +0000125 buf += strnlen(buf, limit - buf) + 1;
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000126 }
127
128 if (!*buf) /* as long as the current byte we're on isn't null */
Stefan Tauner778c6d82014-09-05 16:14:11 +0000129 return strdup("<BAD INDEX>");
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000130
Stefan Tauner9972d152014-07-13 12:52:15 +0000131 len = strnlen(buf, limit - buf);
132 char *newbuf = malloc(len + 1);
133 if (newbuf == NULL) {
134 msg_perr("Out of memory!\n");
135 return NULL;
136 }
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000137
138 /* fix junk bytes in the string */
Stefan Tauner9972d152014-07-13 12:52:15 +0000139 for (i = 0; i < len && buf[i] != '\0'; i++) {
Stefan Taunerff9e6c32014-10-19 07:54:27 +0000140 if (isprint((unsigned char)buf[i]))
Stefan Tauner9972d152014-07-13 12:52:15 +0000141 newbuf[i] = buf[i];
142 else
143 newbuf[i] = ' ';
144 }
145 newbuf[i] = '\0';
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000146
Stefan Tauner9972d152014-07-13 12:52:15 +0000147 return newbuf;
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000148}
149
150static void dmi_chassis_type(uint8_t code)
151{
Nico Huber519be662018-12-23 20:03:35 +0100152 unsigned int i;
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000153 code &= 0x7f; /* bits 6:0 are chassis type, 7th bit is the lock bit */
154 is_laptop = 2;
155 for (i = 0; i < ARRAY_SIZE(dmi_chassis_types); i++) {
156 if (code == dmi_chassis_types[i].type) {
157 msg_pdbg("DMI string chassis-type: \"%s\"\n", dmi_chassis_types[i].name);
158 is_laptop = dmi_chassis_types[i].is_laptop;
159 break;
160 }
161 }
162}
163
164static void dmi_table(uint32_t base, uint16_t len, uint16_t num)
165{
Nico Huber519be662018-12-23 20:03:35 +0100166 unsigned int i = 0, j = 0;
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000167
Carl-Daniel Hailfinger43eac032014-03-05 00:16:16 +0000168 uint8_t *dmi_table_mem = physmap_ro("DMI Table", base, len);
Nico Huber245e5402022-03-06 00:21:52 +0100169 if (dmi_table_mem == ERROR_PTR) {
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000170 msg_perr("Unable to access DMI Table\n");
171 return;
172 }
173
174 uint8_t *data = dmi_table_mem;
175 uint8_t *limit = dmi_table_mem + len;
176
177 /* SMBIOS structure header is always 4 B long and contains:
178 * - uint8_t type; // see dmi_chassis_types's type
179 * - uint8_t length; // data section w/ header w/o strings
180 * - uint16_t handle;
181 */
Stefan Tauner9972d152014-07-13 12:52:15 +0000182 while (i < num && data + 4 < limit) {
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000183 /* - If a short entry is found (less than 4 bytes), not only it
184 * is invalid, but we cannot reliably locate the next entry.
185 * - If the length value indicates that this structure spreads
Stefan Tauner6697f712014-08-06 15:09:15 +0000186 * across the table border, something is fishy too.
Angel Pons0be623c2021-04-17 17:08:44 +0200187 * Better stop at this point, and let the user know their
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000188 * table is broken.
189 */
Stefan Tauner9972d152014-07-13 12:52:15 +0000190 if (data[1] < 4 || data + data[1] >= limit) {
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000191 msg_perr("DMI table is broken (bogus header)!\n");
192 break;
193 }
194
195 if(data[0] == 3) {
Stefan Tauner9972d152014-07-13 12:52:15 +0000196 if (data + 5 < limit)
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000197 dmi_chassis_type(data[5]);
Stefan Tauner9972d152014-07-13 12:52:15 +0000198 else /* the table is broken, but laptop detection is optional, hence continue. */
199 msg_pwarn("DMI table is broken (chassis_type out of bounds)!\n");
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000200 } else
201 for (j = 0; j < ARRAY_SIZE(dmi_strings); j++) {
202 uint8_t offset = dmi_strings[j].offset;
203 uint8_t type = dmi_strings[j].type;
204
205 if (data[0] != type)
206 continue;
207
Stefan Tauner9972d152014-07-13 12:52:15 +0000208 if (data[1] <= offset || data + offset >= limit) {
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000209 msg_perr("DMI table is broken (offset out of bounds)!\n");
210 goto out;
211 }
212
Stefan Tauner9972d152014-07-13 12:52:15 +0000213 dmi_strings[j].value = dmi_string((const char *)(data + data[1]), data[offset],
214 (const char *)limit);
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000215 }
216 /* Find next structure by skipping data and string sections */
217 data += data[1];
218 while (data + 1 <= limit) {
219 if (data[0] == 0 && data[1] == 0)
220 break;
221 data++;
222 }
223 data += 2;
224 i++;
225 }
226out:
227 physunmap(dmi_table_mem, len);
228}
229
230#if SM_SUPPORT
231static int smbios_decode(uint8_t *buf)
232{
233 /* TODO: other checks mentioned in the conformance guidelines? */
234 if (!dmi_checksum(buf, buf[0x05]) ||
235 (memcmp(buf + 0x10, "_DMI_", 5) != 0) ||
236 !dmi_checksum(buf + 0x10, 0x0F))
237 return 0;
238
239 dmi_table(mmio_readl(buf + 0x18), mmio_readw(buf + 0x16), mmio_readw(buf + 0x1C));
240
241 return 1;
242}
243#endif
244
245static int legacy_decode(uint8_t *buf)
246{
247 if (!dmi_checksum(buf, 0x0F))
248 return 1;
249
250 dmi_table(mmio_readl(buf + 0x08), mmio_readw(buf + 0x06), mmio_readw(buf + 0x0C));
251
252 return 0;
253}
254
Jacob Garberbeeb8bc2019-06-21 15:24:17 -0600255static int dmi_fill(void)
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000256{
257 size_t fp;
258 uint8_t *dmi_mem;
259 int ret = 1;
260
261 msg_pdbg("Using Internal DMI decoder.\n");
262 /* There are two ways specified to gain access to the SMBIOS table:
263 * - EFI's configuration table contains a pointer to the SMBIOS table. On linux it can be obtained from
264 * sysfs. EFI's SMBIOS GUID is: {0xeb9d2d31,0x2d88,0x11d3,0x9a,0x16,0x0,0x90,0x27,0x3f,0xc1,0x4d}
265 * - Scanning physical memory address range 0x000F0000h to 0x000FFFFF for the anchor-string(s). */
Niklas Söderlund5d307202013-09-14 09:02:27 +0000266 dmi_mem = physmap_ro("DMI", 0xF0000, 0x10000);
267 if (dmi_mem == ERROR_PTR)
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000268 return ret;
269
270 for (fp = 0; fp <= 0xFFF0; fp += 16) {
271#if SM_SUPPORT
272 if (memcmp(dmi_mem + fp, "_SM_", 4) == 0 && fp <= 0xFFE0) {
273 if (smbios_decode(dmi_mem + fp)) // FIXME: length check
274 goto out;
275 } else
276#endif
277 if (memcmp(dmi_mem + fp, "_DMI_", 5) == 0)
278 if (legacy_decode(dmi_mem + fp) == 0) {
279 ret = 0;
280 goto out;
281 }
282 }
283 msg_pinfo("No DMI table found.\n");
284out:
285 physunmap(dmi_mem, 0x10000);
286 return ret;
287}
288
289#else /* CONFIG_INTERNAL_DMI */
290
291#define DMI_COMMAND_LEN_MAX 300
Stefan Tauner4f444792011-06-27 11:44:03 +0000292#if IS_WINDOWS
293static const char *dmidecode_command = "dmidecode.exe 2>NUL";
294#else
295static const char *dmidecode_command = "dmidecode 2>/dev/null";
296#endif
Michael Karcher6701ee82010-01-20 14:14:11 +0000297
Michael Karcher0d7fb7c2010-02-26 09:51:16 +0000298static char *get_dmi_string(const char *string_name)
Michael Karcher6701ee82010-01-20 14:14:11 +0000299{
300 FILE *dmidecode_pipe;
Michael Karcher0d7fb7c2010-02-26 09:51:16 +0000301 char *result;
302 char answerbuf[DMI_MAX_ANSWER_LEN];
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000303 char commandline[DMI_COMMAND_LEN_MAX];
Uwe Hermann43959702010-03-13 17:28:29 +0000304
Michael Karcher0d7fb7c2010-02-26 09:51:16 +0000305 snprintf(commandline, sizeof(commandline),
306 "%s -s %s", dmidecode_command, string_name);
307 dmidecode_pipe = popen(commandline, "r");
308 if (!dmidecode_pipe) {
Stefan Taunerc6fa32d2013-01-04 22:54:07 +0000309 msg_perr("Opening DMI pipe failed!\n");
Michael Karcher0d7fb7c2010-02-26 09:51:16 +0000310 return NULL;
Michael Karcher6701ee82010-01-20 14:14:11 +0000311 }
Michael Karcherd9f266d2010-08-08 21:56:52 +0000312
313 /* Kill lines starting with '#', as recent dmidecode versions
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000314 * have the quirk to emit a "# SMBIOS implementations newer..."
315 * message even on "-s" if the SMBIOS declares a
316 * newer-than-supported version number, while it *should* only print
317 * the requested string.
318 */
Michael Karcherd9f266d2010-08-08 21:56:52 +0000319 do {
320 if (!fgets(answerbuf, DMI_MAX_ANSWER_LEN, dmidecode_pipe)) {
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000321 if (ferror(dmidecode_pipe)) {
Michael Karcherd9f266d2010-08-08 21:56:52 +0000322 msg_perr("DMI pipe read error\n");
323 pclose(dmidecode_pipe);
324 return NULL;
Michael Karcherd9f266d2010-08-08 21:56:52 +0000325 }
Elyes HAOUASa67ac582019-06-09 17:06:50 +0200326 answerbuf[0] = 0; /* Hit EOF */
Michael Karcher45f79cb2010-03-24 17:55:04 +0000327 }
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000328 } while (answerbuf[0] == '#');
Michael Karcherd9f266d2010-08-08 21:56:52 +0000329
Stefan Taunerc6fa32d2013-01-04 22:54:07 +0000330 /* Discard all output exceeding DMI_MAX_ANSWER_LEN to prevent deadlock on pclose. */
Michael Karcher0d7fb7c2010-02-26 09:51:16 +0000331 while (!feof(dmidecode_pipe))
332 getc(dmidecode_pipe);
333 if (pclose(dmidecode_pipe) != 0) {
Stefan Taunerc6fa32d2013-01-04 22:54:07 +0000334 msg_pwarn("dmidecode execution unsuccessful - continuing without DMI info\n");
Michael Karcher0d7fb7c2010-02-26 09:51:16 +0000335 return NULL;
336 }
Michael Karcher6701ee82010-01-20 14:14:11 +0000337
Uwe Hermann43959702010-03-13 17:28:29 +0000338 /* Chomp trailing newline. */
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000339 if (answerbuf[0] != 0 && answerbuf[strlen(answerbuf) - 1] == '\n')
Michael Karcher0d7fb7c2010-02-26 09:51:16 +0000340 answerbuf[strlen(answerbuf) - 1] = 0;
Michael Karcher0d7fb7c2010-02-26 09:51:16 +0000341
342 result = strdup(answerbuf);
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000343 if (result == NULL)
Stefan Taunerc6fa32d2013-01-04 22:54:07 +0000344 msg_pwarn("Warning: Out of memory - DMI support fails");
Michael Karcher0d7fb7c2010-02-26 09:51:16 +0000345
346 return result;
347}
348
Jacob Garberbeeb8bc2019-06-21 15:24:17 -0600349static int dmi_fill(void)
Michael Karcher0d7fb7c2010-02-26 09:51:16 +0000350{
Nico Huber519be662018-12-23 20:03:35 +0100351 unsigned int i;
Michael Karcher8c1df282010-02-26 09:51:20 +0000352 char *chassis_type;
Uwe Hermann43959702010-03-13 17:28:29 +0000353
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000354 msg_pdbg("Using External DMI decoder.\n");
355 for (i = 0; i < ARRAY_SIZE(dmi_strings); i++) {
356 dmi_strings[i].value = get_dmi_string(dmi_strings[i].keyword);
357 if (dmi_strings[i].value == NULL)
358 return 1;
Michael Karcher0d7fb7c2010-02-26 09:51:16 +0000359 }
Michael Karcher8c1df282010-02-26 09:51:20 +0000360
361 chassis_type = get_dmi_string("chassis-type");
Stefan Taunera34d7192011-07-26 00:54:42 +0000362 if (chassis_type == NULL)
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000363 return 0; /* chassis-type handling is optional anyway */
Stefan Taunera34d7192011-07-26 00:54:42 +0000364
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000365 msg_pdbg("DMI string chassis-type: \"%s\"\n", chassis_type);
Stefan Taunera34d7192011-07-26 00:54:42 +0000366 is_laptop = 2;
367 for (i = 0; i < ARRAY_SIZE(dmi_chassis_types); i++) {
368 if (strcasecmp(chassis_type, dmi_chassis_types[i].name) == 0) {
369 is_laptop = dmi_chassis_types[i].is_laptop;
370 break;
Carl-Daniel Hailfingercb3eb052010-09-26 21:43:53 +0000371 }
Michael Karcher8c1df282010-02-26 09:51:20 +0000372 }
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000373 free(chassis_type);
374 return 0;
375}
376
377#endif /* CONFIG_INTERNAL_DMI */
378
379static int dmi_shutdown(void *data)
380{
Nico Huber519be662018-12-23 20:03:35 +0100381 unsigned int i;
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000382 for (i = 0; i < ARRAY_SIZE(dmi_strings); i++) {
383 free(dmi_strings[i].value);
384 dmi_strings[i].value = NULL;
385 }
386 return 0;
387}
388
389void dmi_init(void)
390{
391 /* Register shutdown function before we allocate anything. */
392 if (register_shutdown(dmi_shutdown, NULL)) {
393 msg_pwarn("Warning: Could not register DMI shutdown function - continuing without DMI info.\n");
394 return;
395 }
396
397 /* dmi_fill fills the dmi_strings array, and if possible sets the global is_laptop variable. */
398 if (dmi_fill() != 0)
399 return;
Stefan Taunera34d7192011-07-26 00:54:42 +0000400
401 switch (is_laptop) {
402 case 1:
403 msg_pdbg("Laptop detected via DMI.\n");
404 break;
405 case 2:
406 msg_pdbg("DMI chassis-type is not specific enough.\n");
407 break;
408 }
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000409
410 has_dmi_support = 1;
Nico Huber519be662018-12-23 20:03:35 +0100411 unsigned int i;
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000412 for (i = 0; i < ARRAY_SIZE(dmi_strings); i++) {
413 msg_pdbg("DMI string %s: \"%s\"\n", dmi_strings[i].keyword,
414 (dmi_strings[i].value == NULL) ? "" : dmi_strings[i].value);
415 }
Michael Karcher6701ee82010-01-20 14:14:11 +0000416}
417
418/**
419 * Does an substring/prefix/postfix/whole-string match.
420 *
421 * The pattern is matched as-is. The only metacharacters supported are '^'
422 * at the beginning and '$' at the end. So you can look for "^prefix",
423 * "suffix$", "substring" or "^complete string$".
424 *
Stefan Taunerd1045d82013-10-29 01:38:45 +0000425 * @param value The non-NULL string to check.
426 * @param pattern The non-NULL pattern.
Michael Karcher6701ee82010-01-20 14:14:11 +0000427 * @return Nonzero if pattern matches.
428 */
429static int dmi_compare(const char *value, const char *pattern)
430{
Felix Singerdd5f6932022-08-19 03:33:27 +0200431 bool anchored = false;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000432 int patternlen;
Uwe Hermann43959702010-03-13 17:28:29 +0000433
Sean Nelson316a29f2010-05-07 20:09:04 +0000434 msg_pspew("matching %s against %s\n", value, pattern);
Uwe Hermann43959702010-03-13 17:28:29 +0000435 /* The empty string is part of all strings! */
Michael Karcher6701ee82010-01-20 14:14:11 +0000436 if (pattern[0] == 0)
437 return 1;
438
439 if (pattern[0] == '^') {
Felix Singerdd5f6932022-08-19 03:33:27 +0200440 anchored = true;
Michael Karcher6701ee82010-01-20 14:14:11 +0000441 pattern++;
442 }
443
444 patternlen = strlen(pattern);
445 if (pattern[patternlen - 1] == '$') {
446 int valuelen = strlen(value);
447 patternlen--;
Uwe Hermann43959702010-03-13 17:28:29 +0000448 if (patternlen > valuelen)
Michael Karcher6701ee82010-01-20 14:14:11 +0000449 return 0;
450
451 /* full string match: require same length */
Uwe Hermann43959702010-03-13 17:28:29 +0000452 if (anchored && (valuelen != patternlen))
Michael Karcher6701ee82010-01-20 14:14:11 +0000453 return 0;
454
455 /* start character to make ends match */
456 value += valuelen - patternlen;
Felix Singerdd5f6932022-08-19 03:33:27 +0200457 anchored = true;
Michael Karcher6701ee82010-01-20 14:14:11 +0000458 }
459
460 if (anchored)
461 return strncmp(value, pattern, patternlen) == 0;
462 else
463 return strstr(value, pattern) != NULL;
464}
465
466int dmi_match(const char *pattern)
467{
Nico Huber519be662018-12-23 20:03:35 +0100468 unsigned int i;
Uwe Hermann43959702010-03-13 17:28:29 +0000469
Michael Karcher6701ee82010-01-20 14:14:11 +0000470 if (!has_dmi_support)
471 return 0;
472
Stefan Taunerd1045d82013-10-29 01:38:45 +0000473 for (i = 0; i < ARRAY_SIZE(dmi_strings); i++) {
474 if (dmi_strings[i].value == NULL)
475 continue;
476
Sean Nelson4c6d3a42013-09-11 23:35:03 +0000477 if (dmi_compare(dmi_strings[i].value, pattern))
Michael Karcher4dfa0932010-02-12 05:44:18 +0000478 return 1;
Stefan Taunerd1045d82013-10-29 01:38:45 +0000479 }
Michael Karcher6701ee82010-01-20 14:14:11 +0000480
481 return 0;
482}