/src/fwupd/libfwupdplugin/fu-smbios.c

Source
/*
 * Copyright 2017 Richard Hughes <richard@hughsie.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

#define G_LOG_DOMAIN "FuSmbios"

#include "config.h"

#include <gio/gio.h>
#include <string.h>

#ifdef _WIN32
#include <errhandlingapi.h>
#include <sysinfoapi.h>
#endif

#include "fwupd-error.h"

#include "fu-byte-array.h"
#include "fu-common.h"
#include "fu-input-stream.h"
#include "fu-path.h"
#include "fu-smbios-private.h"
#include "fu-smbios-struct.h"
#include "fu-string.h"
#include "fu-sum.h"

/**
 * FuSmbios:
 *
 * Enumerate the SMBIOS data on the system.
 *
 * See also: [class@FuHwids]
 */

struct _FuSmbios {
  FuFirmware parent_instance;
  FuPathStore *pstore;
  guint32 structure_table_len;
  GPtrArray *items;
};

typedef struct {
  guint8 type;
  guint16 handle;
  GByteArray *buf;
  GPtrArray *strings;
} FuSmbiosItem;

G_DEFINE_TYPE(FuSmbios, fu_smbios, FU_TYPE_FIRMWARE)

static FuSmbiosItem *
fu_smbios_item_new(void)
{
  FuSmbiosItem *item = g_new0(FuSmbiosItem, 1);
  item->strings = g_ptr_array_new_with_free_func(g_free);
  return item;
}

static void
fu_smbios_item_free(FuSmbiosItem *item)
{
  if (item->buf != NULL)
    g_byte_array_unref(item->buf);
  g_ptr_array_unref(item->strings);
  g_free(item);
}

G_DEFINE_AUTOPTR_CLEANUP_FUNC(FuSmbiosItem, fu_smbios_item_free)

static FuSmbiosItem *
fu_smbios_get_item_for_type_length(FuSmbios *self, guint8 type, guint8 length)
{
  for (guint i = 0; i < self->items->len; i++) {
    FuSmbiosItem *item = g_ptr_array_index(self->items, i);
    if (item->type != type)
      continue;
    if (length != FU_SMBIOS_STRUCTURE_LENGTH_ANY && length != item->buf->len) {
      g_debug("filtering SMBIOS structure by length: 0x%x != 0x%x",
        length,
        item->buf->len);
      continue;
    }
    return item;
  }
  return NULL;
}

static gboolean
fu_smbios_setup_from_data(FuSmbios *self, const guint8 *buf, gsize bufsz, GError **error)
{
  gsize offset = 0;

  /* go through each structure */
  while (offset < bufsz) {
    guint8 length;
    g_autoptr(FuSmbiosItem) item = NULL;
    g_autoptr(FuStructSmbiosStructure) st_str = NULL;

    /* sanity check */
    st_str = fu_struct_smbios_structure_parse(buf, bufsz, offset, error);
    if (st_str == NULL)
      return FALSE;
    length = fu_struct_smbios_structure_get_length(st_str);
    if (length < st_str->buf->len) {
      g_set_error(error,
            FWUPD_ERROR,
            FWUPD_ERROR_INVALID_FILE,
            "structure smaller than allowed @0x%x",
            (guint)offset);
      return FALSE;
    }

    /* create a new result */
    item = fu_smbios_item_new();
    item->type = fu_struct_smbios_structure_get_type(st_str);
    item->handle = fu_struct_smbios_structure_get_handle(st_str);
    item->buf = g_byte_array_sized_new(length);
    if (!fu_byte_array_append_safe(item->buf, buf, bufsz, offset, length, error))
      return FALSE;

    /* jump to the end of the formatted area of the struct */
    if (!fu_size_checked_inc(&offset, length, error)) {
      g_prefix_error_literal(error, "structure offset overflow: ");
      return FALSE;
    }

    /* add strings from table */
    while (offset < bufsz) {
      g_autoptr(GString) str = NULL;

      /* end of string section */
      if (item->strings->len > 0 && buf[offset] == 0x0)
        break;

      /* copy into string table */
      str = fu_strdup((const gchar *)buf, bufsz, offset);
      if (!fu_size_checked_inc(&offset, str->len + 1, error)) {
        g_prefix_error_literal(error, "string offset overflow: ");
        return FALSE;
      }
      g_ptr_array_add(item->strings,
          g_string_free_and_steal(g_steal_pointer(&str)));
    }

    if (!fu_size_checked_inc(&offset, 1, error)) {
      g_prefix_error_literal(error, "SMBIOS terminator offset overflow: ");
      return FALSE;
    }

    /* success */
    g_ptr_array_add(self->items, g_steal_pointer(&item));
  }

  /* this has to exist */
  if (fu_smbios_get_item_for_type_length(self,
                 FU_SMBIOS_STRUCTURE_TYPE_SYSTEM,
                 FU_SMBIOS_STRUCTURE_LENGTH_ANY) == NULL) {
    g_set_error_literal(error,
            FWUPD_ERROR,
            FWUPD_ERROR_INVALID_FILE,
            "no structure with required type SYSTEM");
    return FALSE;
  }

  /* success */
  return TRUE;
}

/**
 * fu_smbios_setup_from_file:
 * @self: a #FuSmbios
 * @filename: a filename
 * @error: (nullable): optional return location for an error
 *
 * Reads all the SMBIOS values from a DMI blob.
 *
 * Returns: %TRUE for success
 *
 * Since: 1.0.0
 **/
gboolean
fu_smbios_setup_from_file(FuSmbios *self, const gchar *filename, GError **error)
{
  gsize sz = 0;
  g_autofree gchar *buf = NULL;

  g_return_val_if_fail(FU_IS_SMBIOS(self), FALSE);
  g_return_val_if_fail(filename != NULL, FALSE);
  g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

  /* DMI blob */
  if (!g_file_get_contents(filename, &buf, &sz, error))
    return FALSE;
  return fu_smbios_setup_from_data(self, (guint8 *)buf, sz, error);
}

static gboolean
fu_smbios_parse_ep32(FuSmbios *self, const guint8 *buf, gsize bufsz, GError **error)
{
  guint8 csum = 0;
  g_autofree gchar *version_str = NULL;
  g_autofree gchar *intermediate_anchor_str = NULL;
  g_autoptr(FuStructSmbiosEp32) st_ep32 = NULL;

  /* verify checksum */
  st_ep32 = fu_struct_smbios_ep32_parse(buf, bufsz, 0x0, error);
  if (st_ep32 == NULL)
    return FALSE;
  csum = fu_sum8(buf, bufsz);
  if (csum != 0x00) {
    g_set_error_literal(error,
            FWUPD_ERROR,
            FWUPD_ERROR_INVALID_FILE,
            "entry point checksum invalid");
    return FALSE;
  }

  /* verify intermediate section */
  intermediate_anchor_str = fu_struct_smbios_ep32_get_intermediate_anchor_str(st_ep32);
  if (g_strcmp0(intermediate_anchor_str, "_DMI_") != 0) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_FILE,
          "intermediate anchor signature invalid, got %s",
          intermediate_anchor_str);
    return FALSE;
  }
  csum = fu_sum8(buf + 10, bufsz - 10);
  if (csum != 0x00) {
    g_set_error_literal(error,
            FWUPD_ERROR,
            FWUPD_ERROR_INVALID_FILE,
            "intermediate checksum invalid");
    return FALSE;
  }
  self->structure_table_len = fu_struct_smbios_ep32_get_structure_table_len(st_ep32);
  version_str = g_strdup_printf("%u.%u",
              fu_struct_smbios_ep32_get_smbios_major_ver(st_ep32),
              fu_struct_smbios_ep32_get_smbios_minor_ver(st_ep32));
  fu_firmware_set_version(FU_FIRMWARE(self), version_str); /* nocheck:set-version */
  fu_firmware_set_version_raw(
      FU_FIRMWARE(self),
      (((guint16)fu_struct_smbios_ep32_get_smbios_major_ver(st_ep32)) << 8) +
    fu_struct_smbios_ep32_get_smbios_minor_ver(st_ep32));
  return TRUE;
}

static gboolean
fu_smbios_parse_ep64(FuSmbios *self, const guint8 *buf, gsize bufsz, GError **error)
{
  guint8 csum = 0;
  g_autofree gchar *version_str = NULL;
  g_autoptr(FuStructSmbiosEp64) st_ep64 = NULL;

  /* verify checksum */
  st_ep64 = fu_struct_smbios_ep64_parse(buf, bufsz, 0x0, error);
  if (st_ep64 == NULL)
    return FALSE;
  csum = fu_sum8(buf, bufsz);
  if (csum != 0x00) {
    g_set_error_literal(error,
            FWUPD_ERROR,
            FWUPD_ERROR_INVALID_FILE,
            "entry point checksum invalid");
    return FALSE;
  }
  self->structure_table_len = fu_struct_smbios_ep64_get_structure_table_len(st_ep64);
  version_str = g_strdup_printf("%u.%u",
              fu_struct_smbios_ep64_get_smbios_major_ver(st_ep64),
              fu_struct_smbios_ep64_get_smbios_minor_ver(st_ep64));
  fu_firmware_set_version(FU_FIRMWARE(self), version_str); /* nocheck:set-version */
  return TRUE;
}

/**
 * fu_smbios_setup_from_path:
 * @self: a #FuSmbios
 * @path: a path, e.g. `/sys/firmware/dmi/tables`
 * @error: (nullable): optional return location for an error
 *
 * Reads all the SMBIOS values from a specific path.
 *
 * Returns: %TRUE for success
 *
 * Since: 1.0.0
 **/
gboolean
fu_smbios_setup_from_path(FuSmbios *self, const gchar *path, GError **error)
{
  gsize sz = 0;
  g_autofree gchar *dmi_fn = NULL;
  g_autofree gchar *dmi_raw = NULL;
  g_autofree gchar *ep_fn = NULL;
  g_autofree gchar *ep_raw = NULL;

  g_return_val_if_fail(FU_IS_SMBIOS(self), FALSE);
  g_return_val_if_fail(path != NULL, FALSE);
  g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

  /* get the smbios entry point */
  ep_fn = g_build_filename(path, "smbios_entry_point", NULL);
  if (!g_file_get_contents(ep_fn, &ep_raw, &sz, error)) {
    fwupd_error_convert(error);
    return FALSE;
  }

  /* check we got enough data to read the signature */
  if (sz < 5) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_FILE,
          "invalid smbios entry point got 0x%x bytes, expected 0x%x or 0x%x",
          (guint)sz,
          (guint)FU_STRUCT_SMBIOS_EP32_SIZE,
          (guint)FU_STRUCT_SMBIOS_EP64_SIZE);
    return FALSE;
  }

  /* parse 32 bit structure */
  if (memcmp(ep_raw, "_SM_", 4) == 0) {
    if (!fu_smbios_parse_ep32(self, (const guint8 *)ep_raw, sz, error))
      return FALSE;
  } else if (memcmp(ep_raw, "_SM3_", 5) == 0) {
    if (!fu_smbios_parse_ep64(self, (const guint8 *)ep_raw, sz, error))
      return FALSE;
  } else {
    g_autofree gchar *tmp = g_strndup(ep_raw, 4);
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_FILE,
          "SMBIOS signature invalid, got %s",
          tmp);
    return FALSE;
  }

  /* get the DMI data */
  dmi_fn = g_build_filename(path, "DMI", NULL);
  if (!g_file_get_contents(dmi_fn, &dmi_raw, &sz, error)) {
    fwupd_error_convert(error);
    return FALSE;
  }
  if (sz > self->structure_table_len) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_FILE,
          "invalid DMI data size, got 0x%x bytes, expected 0x%x",
          (guint)sz,
          self->structure_table_len);
    return FALSE;
  }

  /* parse blob */
  return fu_smbios_setup_from_data(self, (guint8 *)dmi_raw, sz, error);
}

static gboolean
fu_smbios_parse(FuFirmware *firmware,
    FuInputStream *stream,
    FuFirmwareParseFlags flags,
    GError **error)
{
  FuSmbios *self = FU_SMBIOS(firmware);
  g_autoptr(GBytes) fw = NULL;
  fw = fu_input_stream_read_bytes(stream, 0x0, G_MAXSIZE, NULL, error);
  if (fw == NULL)
    return FALSE;
  return fu_smbios_setup_from_data(self,
           g_bytes_get_data(fw, NULL),
           g_bytes_get_size(fw),
           error);
}

#ifdef _WIN32
#define FU_SMBIOS_FT_SIG_ACPI 0x41435049
#define FU_SMBIOS_FT_SIG_FIRM 0x4649524D
#define FU_SMBIOS_FT_SIG_RSMB 0x52534D42
#define FU_SMBIOS_FT_RAW_OFFSET 0x08
#endif

/**
 * fu_smbios_setup:
 * @self: a #FuSmbios
 * @error: (nullable): optional return location for an error
 *
 * Reads all the SMBIOS values from the hardware.
 *
 * Returns: %TRUE for success
 *
 * Since: 1.0.0
 **/
gboolean
fu_smbios_setup(FuSmbios *self, GError **error)
{
#ifdef _WIN32
  gsize bufsz;
  guint rc;
  g_autofree guint8 *buf = NULL;

  rc = GetSystemFirmwareTable(FU_SMBIOS_FT_SIG_RSMB, 0, 0, 0);
  if (rc <= 0) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_FILE,
          "failed to access RSMB [%u]",
          (guint)GetLastError());
    return FALSE;
  }
  if (rc < FU_SMBIOS_FT_RAW_OFFSET || rc > 10 * FU_MB) {
    g_set_error_literal(error,
            FWUPD_ERROR,
            FWUPD_ERROR_INVALID_FILE,
            "RSMB impossible size");
    return FALSE;
  }
  bufsz = rc;
  buf = g_malloc0(bufsz);
  rc = GetSystemFirmwareTable(FU_SMBIOS_FT_SIG_RSMB, 0, buf, (DWORD)bufsz);
  if (rc <= 0) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_FILE,
          "failed to read RSMB [%u]",
          (guint)GetLastError());
    return FALSE;
  }
  return fu_smbios_setup_from_data(self,
           buf + FU_SMBIOS_FT_RAW_OFFSET,
           bufsz - FU_SMBIOS_FT_RAW_OFFSET,
           error);
#else
  g_autofree gchar *path = NULL;
  g_autoptr(GError) error_local = NULL;

  g_return_val_if_fail(FU_IS_SMBIOS(self), FALSE);
  g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

  /* DMI */
  path = fu_path_store_build_filename(self->pstore,
              error,
              FU_PATH_KIND_SYSFSDIR_FW,
              "dmi",
              "tables",
              NULL);
  if (path == NULL)
    return FALSE;
  if (!g_file_test(path, G_FILE_TEST_EXISTS)) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_NOT_SUPPORTED,
          "SMBIOS tables not found at %s",
          path);
    return FALSE;
  }
  if (!fu_smbios_setup_from_path(self, path, &error_local)) {
    if (!g_error_matches(error_local, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE)) {
      g_propagate_error(error, g_steal_pointer(&error_local));
      return FALSE;
    }
    g_debug("ignoring %s", error_local->message);
  }

  /* success */
  return TRUE;
#endif
}

static void
fu_smbios_export(FuFirmware *firmware, FuFirmwareExportFlags flags, XbBuilderNode *bn)
{
  FuSmbios *self = FU_SMBIOS(firmware);

  for (guint i = 0; i < self->items->len; i++) {
    FuSmbiosItem *item = g_ptr_array_index(self->items, i);
    g_autoptr(XbBuilderNode) bc = xb_builder_node_insert(bn, "item", NULL);
    g_autofree gchar *buf = fu_byte_array_to_string(item->buf);
    fu_xmlb_builder_insert_kx(bc, "type", item->type);
    fu_xmlb_builder_insert_kx(bc, "length", item->buf->len);
    fu_xmlb_builder_insert_kx(bc, "handle", item->handle);
    fu_xmlb_builder_insert_kv(bc, "buf", buf);
    for (guint j = 0; j < item->strings->len; j++) {
      const gchar *tmp = g_ptr_array_index(item->strings, j);
      g_autofree gchar *title = g_strdup_printf("%02u", j);
      g_autofree gchar *value = fu_strsafe(tmp, 40);
      xb_builder_node_insert_text(bc, "string", value, "idx", title, NULL);
    }
  }
}

static gboolean
fu_smbios_build_item(FuSmbios *self, XbNode *n, GError **error)
{
  const gchar *str;
  guint64 tmp;
  g_autoptr(FuSmbiosItem) item = fu_smbios_item_new();
  g_autoptr(GPtrArray) xb_strings = NULL;

  /* optional type */
  tmp = xb_node_query_text_as_uint(n, "type", NULL);
  if (tmp != G_MAXUINT64) {
    if (tmp > G_MAXUINT8) {
      g_set_error_literal(error,
              FWUPD_ERROR,
              FWUPD_ERROR_INVALID_DATA,
              "invalid item type");
      return FALSE;
    }
    item->type = tmp;
  }

  /* optional handle */
  tmp = xb_node_query_text_as_uint(n, "handle", NULL);
  if (tmp != G_MAXUINT64) {
    if (tmp > G_MAXUINT16) {
      g_set_error_literal(error,
              FWUPD_ERROR,
              FWUPD_ERROR_INVALID_DATA,
              "invalid item handle");
      return FALSE;
    }
    item->handle = tmp;
  }

  /* optional data buffer */
  str = xb_node_query_text(n, "buf", NULL);
  if (str != NULL) {
    item->buf = fu_byte_array_from_string(str, error);
    if (item->buf == NULL)
      return FALSE;
  }

  /* optional string table */
  xb_strings = xb_node_query(n, "string", 0, NULL);
  if (xb_strings != NULL) {
    for (guint i = 0; i < xb_strings->len; i++) {
      XbNode *c = g_ptr_array_index(xb_strings, i);
      g_ptr_array_add(item->strings, g_strdup(xb_node_get_text(c)));
    }
  }

  /* success */
  g_ptr_array_add(self->items, g_steal_pointer(&item));
  return TRUE;
}

static gboolean
fu_smbios_build(FuFirmware *firmware, XbNode *n, GError **error)
{
  FuSmbios *self = FU_SMBIOS(firmware);
  g_autoptr(GPtrArray) xb_items = NULL;

  /* optional items */
  xb_items = xb_node_query(n, "item", 0, NULL);
  if (xb_items != NULL) {
    for (guint i = 0; i < xb_items->len; i++) {
      XbNode *c = g_ptr_array_index(xb_items, i);
      if (!fu_smbios_build_item(self, c, error))
        return FALSE;
    }
  }

  /* success */
  return TRUE;
}

/**
 * fu_smbios_get_data:
 * @self: a #FuSmbios
 * @type: a structure type, e.g. %FU_SMBIOS_STRUCTURE_TYPE_BIOS
 * @length: expected length of the structure, or %FU_SMBIOS_STRUCTURE_LENGTH_ANY
 * @error: (nullable): optional return location for an error
 *
 * Reads all the SMBIOS data blobs of a specified type.
 *
 * Returns: (transfer container) (element-type GBytes): a #GBytes, or %NULL if invalid or not found
 *
 * Since: 2.0.7
 **/
GPtrArray *
fu_smbios_get_data(FuSmbios *self, guint8 type, guint8 length, GError **error)
{
  g_autoptr(GPtrArray) array = g_ptr_array_new_with_free_func((GDestroyNotify)g_bytes_unref);

  g_return_val_if_fail(FU_IS_SMBIOS(self), NULL);
  g_return_val_if_fail(error == NULL || *error == NULL, NULL);

  for (guint i = 0; i < self->items->len; i++) {
    FuSmbiosItem *item = g_ptr_array_index(self->items, i);
    if (item->type != type)
      continue;
    if (length != FU_SMBIOS_STRUCTURE_LENGTH_ANY && length != item->buf->len)
      continue;
    if (item->buf->len == 0)
      continue;
    g_ptr_array_add(array, g_bytes_new(item->buf->data, item->buf->len));
  }
  if (array->len == 0) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_FILE,
          "no structures with type %02x",
          type);
    return NULL;
  }
  return g_steal_pointer(&array);
}

/**
 * fu_smbios_get_integer:
 * @self: a #FuSmbios
 * @type: a structure type, e.g. %FU_SMBIOS_STRUCTURE_TYPE_BIOS
 * @length: expected length of the structure, or %FU_SMBIOS_STRUCTURE_LENGTH_ANY
 * @offset: a structure offset
 * @error: (nullable): optional return location for an error
 *
 * Reads an integer value from the SMBIOS string table of a specific structure.
 *
 * The @type and @offset can be referenced from the DMTF SMBIOS specification:
 * https://www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.1.1.pdf
 *
 * Returns: an integer, or %G_MAXUINT if invalid or not found
 *
 * Since: 2.0.7
 **/
guint
fu_smbios_get_integer(FuSmbios *self, guint8 type, guint8 length, guint8 offset, GError **error)
{
  FuSmbiosItem *item;

  g_return_val_if_fail(FU_IS_SMBIOS(self), 0);
  g_return_val_if_fail(error == NULL || *error == NULL, 0);

  /* get item */
  item = fu_smbios_get_item_for_type_length(self, type, length);
  if (item == NULL) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_FILE,
          "no structure with type %02x",
          type);
    return G_MAXUINT;
  }

  /* check offset valid */
  if (offset >= item->buf->len) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_FILE,
          "offset bigger than size %u",
          item->buf->len);
    return G_MAXUINT;
  }

  /* success */
  return item->buf->data[offset];
}

/**
 * fu_smbios_get_string:
 * @self: a #FuSmbios
 * @type: a structure type, e.g. %FU_SMBIOS_STRUCTURE_TYPE_BIOS
 * @length: expected length of the structure, or %FU_SMBIOS_STRUCTURE_LENGTH_ANY
 * @offset: a structure offset
 * @error: (nullable): optional return location for an error
 *
 * Reads a string from the SMBIOS string table of a specific structure.
 *
 * The @type and @offset can be referenced from the DMTF SMBIOS specification:
 * https://www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.1.1.pdf
 *
 * Returns: a string, or %NULL if invalid or not found
 *
 * Since: 2.0.7
 **/
const gchar *
fu_smbios_get_string(FuSmbios *self, guint8 type, guint8 length, guint8 offset, GError **error)
{
  FuSmbiosItem *item;

  g_return_val_if_fail(FU_IS_SMBIOS(self), NULL);
  g_return_val_if_fail(error == NULL || *error == NULL, NULL);

  /* get item */
  item = fu_smbios_get_item_for_type_length(self, type, length);
  if (item == NULL) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_FILE,
          "no structure with type %02x",
          type);
    return NULL;
  }

  /* check offset valid */
  if (offset >= item->buf->len) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_FILE,
          "offset bigger than size %u",
          item->buf->len);
    return NULL;
  }
  if (item->buf->data[offset] == 0x00) {
    g_set_error_literal(error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "no data available");
    return NULL;
  }

  /* check string index valid */
  if (item->buf->data[offset] > item->strings->len) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_FILE,
          "index larger than string table %u",
          item->strings->len);
    return NULL;
  }
  return g_ptr_array_index(item->strings, item->buf->data[offset] - 1);
}

static void
fu_smbios_finalize(GObject *object)
{
  FuSmbios *self = FU_SMBIOS(object);
  if (self->pstore != NULL)
    g_object_unref(self->pstore);
  g_ptr_array_unref(self->items);
  G_OBJECT_CLASS(fu_smbios_parent_class)->finalize(object);
}

static void
fu_smbios_class_init(FuSmbiosClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS(klass);
  FuFirmwareClass *firmware_class = FU_FIRMWARE_CLASS(klass);
  object_class->finalize = fu_smbios_finalize;
  fu_firmware_set_size_max(firmware_class, 16 * FU_MB);
  firmware_class->parse = fu_smbios_parse;
  firmware_class->build = fu_smbios_build;
  firmware_class->export = fu_smbios_export;
}

static void
fu_smbios_init(FuSmbios *self)
{
  self->items = g_ptr_array_new_with_free_func((GDestroyNotify)fu_smbios_item_free);
}

/**
 * fu_smbios_new:
 *
 * Creates a new object to parse SMBIOS data.
 *
 * Returns: a #FuSmbios
 *
 * Since: 1.0.0
 **/
FuSmbios *
fu_smbios_new(FuPathStore *pstore)
{
  FuSmbios *self;

  g_return_val_if_fail(FU_IS_PATH_STORE(pstore), NULL);

  self = g_object_new(FU_TYPE_SMBIOS, NULL);
  self->pstore = g_object_ref(pstore);
  return FU_SMBIOS(self);
}

Coverage Report

Created: 2026-09-14 07:00