[grub2.git] / grub-core / commands / smbios.c

/* smbios.c - retrieve smbios information. */
/*
 *  GRUB  --  GRand Unified Bootloader
 *  Copyright (C) 2019  Free Software Foundation, Inc.
 *
 *  GRUB is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  GRUB is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <grub/dl.h>
#include <grub/env.h>
#include <grub/extcmd.h>
#include <grub/i18n.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/smbios.h>

GRUB_MOD_LICENSE ("GPLv3+");

/* Abstract useful values found in either the SMBIOS3 or SMBIOS EPS. */
static struct {
  grub_addr_t start;
  grub_addr_t end;
  grub_uint16_t structures;
} table_desc;

static grub_extcmd_t cmd;

/* Locate the SMBIOS entry point structure depending on the hardware. */
struct grub_smbios_eps *
grub_smbios_get_eps (void)
{
  static struct grub_smbios_eps *eps = NULL;

  if (eps != NULL)
    return eps;

  eps = grub_machine_smbios_get_eps ();

  return eps;
}

/* Locate the SMBIOS3 entry point structure depending on the hardware. */
static struct grub_smbios_eps3 *
grub_smbios_get_eps3 (void)
{
  static struct grub_smbios_eps3 *eps = NULL;

  if (eps != NULL)
    return eps;

  eps = grub_machine_smbios_get_eps3 ();

  return eps;
}

static char *
linux_string (const char *value)
{
  char *out = grub_malloc( grub_strlen (value) + 1);
  const char *src = value;
  char *dst = out;

  for (; *src; src++)
    if (*src > ' ' && *src < 127 && *src != ':')
      *dst++ = *src;

  *dst = 0;
  return out;
}

/*
 * These functions convert values from the various SMBIOS structure field types
 * into a string formatted to be returned to the user.  They expect that the
 * structure and offset were already validated.  When the requested data is
 * successfully retrieved and formatted, the pointer to the string is returned;
 * otherwise, NULL is returned on failure.  Don't free the result.
 */

static const char *
grub_smbios_format_byte (const grub_uint8_t *structure, grub_uint8_t offset)
{
  static char buffer[sizeof ("255")];

  grub_snprintf (buffer, sizeof (buffer), "%u", structure[offset]);

  return (const char *)buffer;
}

static const char *
grub_smbios_format_word (const grub_uint8_t *structure, grub_uint8_t offset)
{
  static char buffer[sizeof ("65535")];

  grub_uint16_t value = grub_get_unaligned16 (structure + offset);
  grub_snprintf (buffer, sizeof (buffer), "%u", value);

  return (const char *)buffer;
}

static const char *
grub_smbios_format_dword (const grub_uint8_t *structure, grub_uint8_t offset)
{
  static char buffer[sizeof ("4294967295")];

  grub_uint32_t value = grub_get_unaligned32 (structure + offset);
  grub_snprintf (buffer, sizeof (buffer), "%" PRIuGRUB_UINT32_T, value);

  return (const char *)buffer;
}

static const char *
grub_smbios_format_qword (const grub_uint8_t *structure, grub_uint8_t offset)
{
  static char buffer[sizeof ("18446744073709551615")];

  grub_uint64_t value = grub_get_unaligned64 (structure + offset);
  grub_snprintf (buffer, sizeof (buffer), "%" PRIuGRUB_UINT64_T, value);

  return (const char *)buffer;
}

static const char *
grub_smbios_get_string (const grub_uint8_t *structure, grub_uint8_t offset)
{
  const grub_uint8_t *ptr = structure + structure[1];
  const grub_uint8_t *table_end = (const grub_uint8_t *)table_desc.end;
  const grub_uint8_t referenced_string_number = structure[offset];
  grub_uint8_t i;

  /* A string referenced with zero is interpreted as unset. */
  if (referenced_string_number == 0)
    return NULL;

  /* Search the string set. */
  for (i = 1; *ptr != 0 && ptr < table_end; i++)
    if (i == referenced_string_number)
      {
        const char *str = (const char *)ptr;
        while (*ptr++ != 0)
          if (ptr >= table_end)
            return NULL; /* The string isn't terminated. */
        return str;
      }
    else
      while (*ptr++ != 0 && ptr < table_end);

  /* The string number is greater than the number of strings in the set. */
  return NULL;
}

static const char *
grub_smbios_format_uuid (const grub_uint8_t *structure, grub_uint8_t offset)
{
  static char buffer[sizeof ("ffffffff-ffff-ffff-ffff-ffffffffffff")];
  const grub_uint8_t *f = structure + offset; /* little-endian fields */
  const grub_uint8_t *g = f + 8; /* byte-by-byte fields */

  grub_snprintf (buffer, sizeof (buffer),
                 "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
                 "%02x%02x-%02x%02x%02x%02x%02x%02x",
                 f[3], f[2], f[1], f[0], f[5], f[4], f[7], f[6],
                 g[0], g[1], g[2], g[3], g[4], g[5], g[6], g[7]);

  return (const char *)buffer;
}

/* List the field formatting functions and the number of bytes they need. */
static const struct {
  const char *(*format) (const grub_uint8_t *structure, grub_uint8_t offset);
  grub_uint8_t field_length;
} field_extractors[] = {
  {grub_smbios_format_byte, 1},
  {grub_smbios_format_word, 2},
  {grub_smbios_format_dword, 4},
  {grub_smbios_format_qword, 8},
  {grub_smbios_get_string, 1},
  {grub_smbios_format_uuid, 16}
};

/* List command options, with structure field getters ordered as above. */
#define FIRST_GETTER_OPT (3)
#define SETTER_OPT (FIRST_GETTER_OPT + ARRAY_SIZE(field_extractors))
#define LINUX_OPT (FIRST_GETTER_OPT + ARRAY_SIZE(field_extractors) + 1)

static const struct grub_arg_option options[] = {
  {"type",       't', 0, N_("Match structures with the given type."),
                         N_("type"), ARG_TYPE_INT},
  {"handle",     'h', 0, N_("Match structures with the given handle."),
                         N_("handle"), ARG_TYPE_INT},
  {"match",      'm', 0, N_("Select a structure when several match."),
                         N_("match"), ARG_TYPE_INT},
  {"get-byte",   'b', 0, N_("Get the byte's value at the given offset."),
                         N_("offset"), ARG_TYPE_INT},
  {"get-word",   'w', 0, N_("Get two bytes' value at the given offset."),
                         N_("offset"), ARG_TYPE_INT},
  {"get-dword",  'd', 0, N_("Get four bytes' value at the given offset."),
                         N_("offset"), ARG_TYPE_INT},
  {"get-qword",  'q', 0, N_("Get eight bytes' value at the given offset."),
                         N_("offset"), ARG_TYPE_INT},
  {"get-string", 's', 0, N_("Get the string specified at the given offset."),
                         N_("offset"), ARG_TYPE_INT},
  {"get-uuid",   'u', 0, N_("Get the UUID's value at the given offset."),
                         N_("offset"), ARG_TYPE_INT},
  {"set",       '\0', 0, N_("Store the value in the given variable name."),
                         N_("variable"), ARG_TYPE_STRING},
  {"linux",     '\0', 0, N_("Filter the result like linux does."),
                         N_("variable"), ARG_TYPE_NONE},
  {0, 0, 0, 0, 0, 0}
};

/*
 * Return a matching SMBIOS structure.
 *
 * This method can use up to three criteria for selecting a structure:
 *   - The "type" field                  (use -1 to ignore)
 *   - The "handle" field                (use -1 to ignore)
 *   - Which to return if several match  (use  0 to ignore)
 *
 * The return value is a pointer to the first matching structure.  If no
 * structures match the given parameters, NULL is returned.
 */
static const grub_uint8_t *
grub_smbios_match_structure (const grub_int16_t type,
                             const grub_int32_t handle,
                             const grub_uint16_t match)
{
  const grub_uint8_t *ptr = (const grub_uint8_t *)table_desc.start;
  const grub_uint8_t *table_end = (const grub_uint8_t *)table_desc.end;
  grub_uint16_t structures = table_desc.structures;
  grub_uint16_t structure_count = 0;
  grub_uint16_t matches = 0;

  while (ptr < table_end
         && ptr[1] >= 4 /* Valid structures include the 4-byte header. */
         && (structure_count++ < structures || structures == 0))
    {
      grub_uint16_t structure_handle = grub_get_unaligned16 (ptr + 2);
      grub_uint8_t structure_type = ptr[0];

      if ((handle < 0 || handle == structure_handle)
          && (type < 0 || type == structure_type)
          && (match == 0 || match == ++matches))
        return ptr;
      else
        {
          ptr += ptr[1];
          while ((*ptr++ != 0 || *ptr++ != 0) && ptr < table_end);
        }

      if (structure_type == GRUB_SMBIOS_TYPE_END_OF_TABLE)
        break;
    }

  return NULL;
}

static grub_err_t
grub_cmd_smbios (grub_extcmd_context_t ctxt,
                 int argc __attribute__ ((unused)),
                 char **argv __attribute__ ((unused)))
{
  struct grub_arg_list *state = ctxt->state;

  grub_int16_t type = -1;
  grub_int32_t handle = -1;
  grub_uint16_t match = 0;
  grub_uint8_t offset = 0;

  const grub_uint8_t *structure;
  const char *value;
  char *modified_value = NULL;
  grub_int32_t option;
  grub_int8_t field_type = -1;
  grub_uint8_t i;

  if (table_desc.start == 0)
    return grub_error (GRUB_ERR_IO,
                       N_("the SMBIOS entry point structure was not found"));

  /* Read the given filtering options. */
  if (state[0].set)
    {
      option = grub_strtol (state[0].arg, NULL, 0);
      if (option < 0 || option > 255)
        return grub_error (GRUB_ERR_BAD_ARGUMENT,
                           N_("the type must be between 0 and 255"));
      type = (grub_int16_t)option;
    }
  if (state[1].set)
    {
      option = grub_strtol (state[1].arg, NULL, 0);
      if (option < 0 || option > 65535)
        return grub_error (GRUB_ERR_BAD_ARGUMENT,
                           N_("the handle must be between 0 and 65535"));
      handle = (grub_int32_t)option;
    }
  if (state[2].set)
    {
      option = grub_strtol (state[2].arg, NULL, 0);
      if (option <= 0 || option > 65535)
        return grub_error (GRUB_ERR_BAD_ARGUMENT,
                           N_("the match must be a positive integer"));
      match = (grub_uint16_t)option;
    }

  /* Determine the data type of the structure field to retrieve. */
  for (i = 0; i < ARRAY_SIZE(field_extractors); i++)
    if (state[FIRST_GETTER_OPT + i].set)
      {
        if (field_type >= 0)
          return grub_error (GRUB_ERR_BAD_ARGUMENT,
                             N_("only one --get option is usable at a time"));
        field_type = i;
      }

  /* Require a choice of a structure field to return. */
  if (field_type < 0)
    return grub_error (GRUB_ERR_BAD_ARGUMENT,
                       N_("one of the --get options is required"));

  /* Locate a matching SMBIOS structure. */
  structure = grub_smbios_match_structure (type, handle, match);
  if (structure == NULL)
    return grub_error (GRUB_ERR_IO,
                       N_("no structure matched the given options"));

  /* Ensure the requested byte offset is inside the structure. */
  option = grub_strtol (state[FIRST_GETTER_OPT + field_type].arg, NULL, 0);
  if (option < 0 || option >= structure[1])
    return grub_error (GRUB_ERR_OUT_OF_RANGE,
                       N_("the given offset is outside the structure"));

  /* Ensure the requested data type at the offset is inside the structure. */
  offset = (grub_uint8_t)option;
  if (offset + field_extractors[field_type].field_length > structure[1])
    return grub_error (GRUB_ERR_OUT_OF_RANGE,
                       N_("the field ends outside the structure"));

  /* Format the requested structure field into a readable string. */
  value = field_extractors[field_type].format (structure, offset);
  if (value == NULL)
    return grub_error (GRUB_ERR_IO,
                       N_("failed to retrieve the structure field"));

  if (state[LINUX_OPT].set)
    value = modified_value = linux_string (value);

  /* Store or print the formatted value. */
  if (state[SETTER_OPT].set)
    grub_env_set (state[SETTER_OPT].arg, value);
  else
    grub_printf ("%s\n", value);

  grub_free(modified_value);

  return GRUB_ERR_NONE;
}

GRUB_MOD_INIT(smbios)
{
  struct grub_smbios_eps3 *eps3;
  struct grub_smbios_eps *eps;

  if ((eps3 = grub_smbios_get_eps3 ()))
    {
      table_desc.start = (grub_addr_t)eps3->table_address;
      table_desc.end = table_desc.start + eps3->maximum_table_length;
      table_desc.structures = 0; /* SMBIOS3 drops the structure count. */
    }
  else if ((eps = grub_smbios_get_eps ()))
    {
      table_desc.start = (grub_addr_t)eps->intermediate.table_address;
      table_desc.end = table_desc.start + eps->intermediate.table_length;
      table_desc.structures = eps->intermediate.structures;
    }

  cmd = grub_register_extcmd ("smbios", grub_cmd_smbios, 0,
                              N_("[-t type] [-h handle] [-m match] "
                                 "(-b|-w|-d|-q|-s|-u) offset "
                                 "[--set variable]"),
                              N_("Retrieve SMBIOS information."), options);
}

GRUB_MOD_FINI(smbios)
{
  grub_unregister_extcmd (cmd);
}
Commit	Line	Data
688023cd DM	1	/* smbios.c - retrieve smbios information. */
	2	/*
	3	* GRUB -- GRand Unified Bootloader
	4	* Copyright (C) 2019 Free Software Foundation, Inc.
	5	*
	6	* GRUB is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation, either version 3 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* GRUB is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include <grub/dl.h>
	21	#include <grub/env.h>
	22	#include <grub/extcmd.h>
	23	#include <grub/i18n.h>
	24	#include <grub/misc.h>
	25	#include <grub/mm.h>
	26	#include <grub/smbios.h>
	27
	28	GRUB_MOD_LICENSE ("GPLv3+");
	29
	30	/* Abstract useful values found in either the SMBIOS3 or SMBIOS EPS. */
	31	static struct {
	32	grub_addr_t start;
	33	grub_addr_t end;
	34	grub_uint16_t structures;
	35	} table_desc;
	36
	37	static grub_extcmd_t cmd;
	38
	39	/* Locate the SMBIOS entry point structure depending on the hardware. */
	40	struct grub_smbios_eps *
	41	grub_smbios_get_eps (void)
	42	{
	43	static struct grub_smbios_eps *eps = NULL;
	44
	45	if (eps != NULL)
	46	return eps;
	47
	48	eps = grub_machine_smbios_get_eps ();
	49
	50	return eps;
	51	}
	52
	53	/* Locate the SMBIOS3 entry point structure depending on the hardware. */
	54	static struct grub_smbios_eps3 *
	55	grub_smbios_get_eps3 (void)
	56	{
	57	static struct grub_smbios_eps3 *eps = NULL;
	58
	59	if (eps != NULL)
	60	return eps;
	61
	62	eps = grub_machine_smbios_get_eps3 ();
	63
	64	return eps;
65	}
66
87049f97 JAK	67	static char *
	68	linux_string (const char *value)
	69	{
	70	char *out = grub_malloc( grub_strlen (value) + 1);
	71	const char *src = value;
	72	char *dst = out;
	73
	74	for (; *src; src++)
	75	if (src > ' ' && src < 127 && *src != ':')
	76	dst++ = src;
	77
	78	*dst = 0;
	79	return out;
	80	}
	81
688023cd DM	82	/*
	83	* These functions convert values from the various SMBIOS structure field types
	84	* into a string formatted to be returned to the user. They expect that the
	85	* structure and offset were already validated. When the requested data is
	86	* successfully retrieved and formatted, the pointer to the string is returned;
	87	* otherwise, NULL is returned on failure. Don't free the result.
	88	*/
	89
	90	static const char *
	91	grub_smbios_format_byte (const grub_uint8_t *structure, grub_uint8_t offset)
	92	{
	93	static char buffer[sizeof ("255")];
	94
	95	grub_snprintf (buffer, sizeof (buffer), "%u", structure[offset]);
	96
	97	return (const char *)buffer;
	98	}
	99
	100	static const char *
	101	grub_smbios_format_word (const grub_uint8_t *structure, grub_uint8_t offset)
	102	{
	103	static char buffer[sizeof ("65535")];
	104
	105	grub_uint16_t value = grub_get_unaligned16 (structure + offset);
	106	grub_snprintf (buffer, sizeof (buffer), "%u", value);
	107
	108	return (const char *)buffer;
	109	}
	110
	111	static const char *
	112	grub_smbios_format_dword (const grub_uint8_t *structure, grub_uint8_t offset)
	113	{
	114	static char buffer[sizeof ("4294967295")];
	115
	116	grub_uint32_t value = grub_get_unaligned32 (structure + offset);
	117	grub_snprintf (buffer, sizeof (buffer), "%" PRIuGRUB_UINT32_T, value);
	118
	119	return (const char *)buffer;
	120	}
	121
	122	static const char *
	123	grub_smbios_format_qword (const grub_uint8_t *structure, grub_uint8_t offset)
	124	{
	125	static char buffer[sizeof ("18446744073709551615")];
	126
	127	grub_uint64_t value = grub_get_unaligned64 (structure + offset);
	128	grub_snprintf (buffer, sizeof (buffer), "%" PRIuGRUB_UINT64_T, value);
	129
	130	return (const char *)buffer;
	131	}
	132
	133	static const char *
	134	grub_smbios_get_string (const grub_uint8_t *structure, grub_uint8_t offset)
	135	{
	136	const grub_uint8_t *ptr = structure + structure[1];
	137	const grub_uint8_t table_end = (const grub_uint8_t )table_desc.end;
	138	const grub_uint8_t referenced_string_number = structure[offset];
	139	grub_uint8_t i;
	140
	141	/* A string referenced with zero is interpreted as unset. */
	142	if (referenced_string_number == 0)
	143	return NULL;
	144
	145	/* Search the string set. */
146	for (i = 1; *ptr != 0 && ptr < table_end; i++)
147	if (i == referenced_string_number)
148	{
149	const char str = (const char )ptr;
150	while (*ptr++ != 0)
151	if (ptr >= table_end)
152	return NULL; /* The string isn't terminated. */
153	return str;
154	}
155	else
156	while (*ptr++ != 0 && ptr < table_end);
157
158	/* The string number is greater than the number of strings in the set. */
159	return NULL;
160	}
161
162	static const char *
163	grub_smbios_format_uuid (const grub_uint8_t *structure, grub_uint8_t offset)
164	{
165	static char buffer[sizeof ("ffffffff-ffff-ffff-ffff-ffffffffffff")];
166	const grub_uint8_t f = structure + offset; / little-endian fields */
167	const grub_uint8_t g = f + 8; / byte-by-byte fields */
168
169	grub_snprintf (buffer, sizeof (buffer),
170	"%02x%02x%02x%02x-%02x%02x-%02x%02x-"
171	"%02x%02x-%02x%02x%02x%02x%02x%02x",
172	f[3], f[2], f[1], f[0], f[5], f[4], f[7], f[6],
173	g[0], g[1], g[2], g[3], g[4], g[5], g[6], g[7]);
174
175	return (const char *)buffer;
176	}
177
178	/* List the field formatting functions and the number of bytes they need. */
179	static const struct {
180	const char (format) (const grub_uint8_t *structure, grub_uint8_t offset);
181	grub_uint8_t field_length;
182	} field_extractors[] = {
183	{grub_smbios_format_byte, 1},
184	{grub_smbios_format_word, 2},
185	{grub_smbios_format_dword, 4},
186	{grub_smbios_format_qword, 8},
187	{grub_smbios_get_string, 1},
188	{grub_smbios_format_uuid, 16}
189	};
190
191	/* List command options, with structure field getters ordered as above. */
192	#define FIRST_GETTER_OPT (3)
193	#define SETTER_OPT (FIRST_GETTER_OPT + ARRAY_SIZE(field_extractors))
87049f97	194	#define LINUX_OPT (FIRST_GETTER_OPT + ARRAY_SIZE(field_extractors) + 1)
688023cd DM	195
	196	static const struct grub_arg_option options[] = {
	197	{"type", 't', 0, N_("Match structures with the given type."),
	198	N_("type"), ARG_TYPE_INT},
	199	{"handle", 'h', 0, N_("Match structures with the given handle."),
	200	N_("handle"), ARG_TYPE_INT},
	201	{"match", 'm', 0, N_("Select a structure when several match."),
	202	N_("match"), ARG_TYPE_INT},
	203	{"get-byte", 'b', 0, N_("Get the byte's value at the given offset."),
	204	N_("offset"), ARG_TYPE_INT},
	205	{"get-word", 'w', 0, N_("Get two bytes' value at the given offset."),
	206	N_("offset"), ARG_TYPE_INT},
	207	{"get-dword", 'd', 0, N_("Get four bytes' value at the given offset."),
	208	N_("offset"), ARG_TYPE_INT},
	209	{"get-qword", 'q', 0, N_("Get eight bytes' value at the given offset."),
	210	N_("offset"), ARG_TYPE_INT},
	211	{"get-string", 's', 0, N_("Get the string specified at the given offset."),
	212	N_("offset"), ARG_TYPE_INT},
	213	{"get-uuid", 'u', 0, N_("Get the UUID's value at the given offset."),
	214	N_("offset"), ARG_TYPE_INT},
	215	{"set", '\0', 0, N_("Store the value in the given variable name."),
	216	N_("variable"), ARG_TYPE_STRING},
87049f97 JAK	217	{"linux", '\0', 0, N_("Filter the result like linux does."),
87049f97 JAK	218	N_("variable"), ARG_TYPE_NONE},
688023cd DM	219	{0, 0, 0, 0, 0, 0}
	220	};
	221
	222	/*
	223	* Return a matching SMBIOS structure.
	224	*
	225	* This method can use up to three criteria for selecting a structure:
	226	* - The "type" field (use -1 to ignore)
	227	* - The "handle" field (use -1 to ignore)
	228	* - Which to return if several match (use 0 to ignore)
	229	*
	230	* The return value is a pointer to the first matching structure. If no
	231	* structures match the given parameters, NULL is returned.
	232	*/
	233	static const grub_uint8_t *
	234	grub_smbios_match_structure (const grub_int16_t type,
	235	const grub_int32_t handle,
	236	const grub_uint16_t match)
	237	{
	238	const grub_uint8_t ptr = (const grub_uint8_t )table_desc.start;
	239	const grub_uint8_t table_end = (const grub_uint8_t )table_desc.end;
	240	grub_uint16_t structures = table_desc.structures;
	241	grub_uint16_t structure_count = 0;
	242	grub_uint16_t matches = 0;
	243
	244	while (ptr < table_end
	245	&& ptr[1] >= 4 /* Valid structures include the 4-byte header. */
	246	&& (structure_count++ < structures \|\| structures == 0))
	247	{
	248	grub_uint16_t structure_handle = grub_get_unaligned16 (ptr + 2);
	249	grub_uint8_t structure_type = ptr[0];
	250
	251	if ((handle < 0 \|\| handle == structure_handle)
	252	&& (type < 0 \|\| type == structure_type)
	253	&& (match == 0 \|\| match == ++matches))
	254	return ptr;
	255	else
	256	{
	257	ptr += ptr[1];
	258	while ((ptr++ != 0 \|\| ptr++ != 0) && ptr < table_end);
	259	}
	260
	261	if (structure_type == GRUB_SMBIOS_TYPE_END_OF_TABLE)
	262	break;
	263	}
	264
	265	return NULL;
	266	}
	267
	268	static grub_err_t
	269	grub_cmd_smbios (grub_extcmd_context_t ctxt,
	270	int argc __attribute__ ((unused)),
	271	char **argv __attribute__ ((unused)))
	272	{
	273	struct grub_arg_list *state = ctxt->state;
	274
	275	grub_int16_t type = -1;
	276	grub_int32_t handle = -1;
	277	grub_uint16_t match = 0;
	278	grub_uint8_t offset = 0;
	279
	280	const grub_uint8_t *structure;
	281	const char *value;
87049f97	282	char *modified_value = NULL;
688023cd DM	283	grub_int32_t option;
	284	grub_int8_t field_type = -1;
	285	grub_uint8_t i;
	286
	287	if (table_desc.start == 0)
	288	return grub_error (GRUB_ERR_IO,
	289	N_("the SMBIOS entry point structure was not found"));
	290
	291	/* Read the given filtering options. */
	292	if (state[0].set)
	293	{
	294	option = grub_strtol (state[0].arg, NULL, 0);
	295	if (option < 0 \|\| option > 255)
	296	return grub_error (GRUB_ERR_BAD_ARGUMENT,
	297	N_("the type must be between 0 and 255"));
	298	type = (grub_int16_t)option;
	299	}
	300	if (state[1].set)
	301	{
	302	option = grub_strtol (state[1].arg, NULL, 0);
	303	if (option < 0 \|\| option > 65535)
	304	return grub_error (GRUB_ERR_BAD_ARGUMENT,
	305	N_("the handle must be between 0 and 65535"));
	306	handle = (grub_int32_t)option;
	307	}
	308	if (state[2].set)
	309	{
	310	option = grub_strtol (state[2].arg, NULL, 0);
	311	if (option <= 0 \|\| option > 65535)
	312	return grub_error (GRUB_ERR_BAD_ARGUMENT,
	313	N_("the match must be a positive integer"));
	314	match = (grub_uint16_t)option;
	315	}
	316
	317	/* Determine the data type of the structure field to retrieve. */
	318	for (i = 0; i < ARRAY_SIZE(field_extractors); i++)
	319	if (state[FIRST_GETTER_OPT + i].set)
	320	{
	321	if (field_type >= 0)
	322	return grub_error (GRUB_ERR_BAD_ARGUMENT,
	323	N_("only one --get option is usable at a time"));
	324	field_type = i;
	325	}
	326
	327	/* Require a choice of a structure field to return. */
	328	if (field_type < 0)
	329	return grub_error (GRUB_ERR_BAD_ARGUMENT,
	330	N_("one of the --get options is required"));
	331
	332	/* Locate a matching SMBIOS structure. */
	333	structure = grub_smbios_match_structure (type, handle, match);
	334	if (structure == NULL)
	335	return grub_error (GRUB_ERR_IO,
	336	N_("no structure matched the given options"));
	337
	338	/* Ensure the requested byte offset is inside the structure. */
	339	option = grub_strtol (state[FIRST_GETTER_OPT + field_type].arg, NULL, 0);
	340	if (option < 0 \|\| option >= structure[1])
	341	return grub_error (GRUB_ERR_OUT_OF_RANGE,
	342	N_("the given offset is outside the structure"));
	343
	344	/* Ensure the requested data type at the offset is inside the structure. */
	345	offset = (grub_uint8_t)option;
	346	if (offset + field_extractors[field_type].field_length > structure[1])
347	return grub_error (GRUB_ERR_OUT_OF_RANGE,
348	N_("the field ends outside the structure"));
349
350	/* Format the requested structure field into a readable string. */
351	value = field_extractors[field_type].format (structure, offset);
352	if (value == NULL)
353	return grub_error (GRUB_ERR_IO,
354	N_("failed to retrieve the structure field"));
355
87049f97 JAK	356	if (state[LINUX_OPT].set)
	357	value = modified_value = linux_string (value);
	358
688023cd DM	359	/* Store or print the formatted value. */
	360	if (state[SETTER_OPT].set)
	361	grub_env_set (state[SETTER_OPT].arg, value);
	362	else
	363	grub_printf ("%s\n", value);
87049f97 JAK	364
87049f97 JAK	365	grub_free(modified_value);
688023cd DM	366
	367	return GRUB_ERR_NONE;
	368	}
	369
	370	GRUB_MOD_INIT(smbios)
	371	{
	372	struct grub_smbios_eps3 *eps3;
	373	struct grub_smbios_eps *eps;
	374
	375	if ((eps3 = grub_smbios_get_eps3 ()))
	376	{
	377	table_desc.start = (grub_addr_t)eps3->table_address;
	378	table_desc.end = table_desc.start + eps3->maximum_table_length;
	379	table_desc.structures = 0; /* SMBIOS3 drops the structure count. */
	380	}
	381	else if ((eps = grub_smbios_get_eps ()))
	382	{
	383	table_desc.start = (grub_addr_t)eps->intermediate.table_address;
	384	table_desc.end = table_desc.start + eps->intermediate.table_length;
	385	table_desc.structures = eps->intermediate.structures;
	386	}
	387
	388	cmd = grub_register_extcmd ("smbios", grub_cmd_smbios, 0,
	389	N_("[-t type] [-h handle] [-m match] "
	390	"(-b\|-w\|-d\|-q\|-s\|-u) offset "
	391	"[--set variable]"),
	392	N_("Retrieve SMBIOS information."), options);
	393	}
	394
	395	GRUB_MOD_FINI(smbios)
	396	{
	397	grub_unregister_extcmd (cmd);
	398	}