/*
 * 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(g_steal_pointer(&str), FALSE));
		}

		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,
		GInputStream *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;
	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_firmware_set_size_max(FU_FIRMWARE(self), 16 * FU_MB);
}

/**
 * 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);
}
