/*

 * Copyright 2017 Richard Hughes <richard@hughsie.com>

 *

 * SPDX-License-Identifier: LGPL-2.1-or-later

 */

#define G_LOG_DOMAIN "FuHwids"

#include "config.h"

#include <gio/gio.h>

#include "fwupd-common.h"

#include "fwupd-error.h"

#include "fu-hwids-private.h"

/**

 * FuHwids:

 *

 * A the hardware IDs on the system.

 *

 * Note, these are called "CHIDs" in Microsoft Windows and the results here

 * will match that of `ComputerHardwareIds.exe`.

 *

 * See also: [class@FuSmbios]

 */

struct _FuHwids {

  GObject parent_instance;

  GHashTable *hash_values;   /* BiosVersion->"1.2.3 " */

  GHashTable *hash_values_display; /* BiosVersion->"1.2.3" */

  GHashTable *hash_guid;     /* a-c-b-d->1 */

  GPtrArray *array_guids;    /* a-c-b-d */

  GHashTable *chids;     /* "HardwareID-5"->"Manufacturer&ProductName" */

};

G_DEFINE_TYPE(FuHwids, fu_hwids, G_TYPE_OBJECT)

/**

 * fu_hwids_get_value:

 * @self: a #FuHwids

 * @key: a DMI ID, e.g. `BiosVersion`

 *

 * Gets the cached value for one specific key that is valid ASCII and suitable

 * for display.

 *

 * Returns: the string, e.g. `1.2.3`, or %NULL if not found

 *

 * Since: 0.9.3

 **/

const gchar *

fu_hwids_get_value(FuHwids *self, const gchar *key)

{

  return g_hash_table_lookup(self->hash_values_display, key);

}

/**

 * fu_hwids_has_guid:

 * @self: a #FuHwids

 * @guid: a GUID, e.g. `059eb22d-6dc7-59af-abd3-94bbe017f67c`

 *

 * Finds out if a hardware GUID exists.

 *

 * Returns: %TRUE if the GUID exists

 *

 * Since: 0.9.3

 **/

gboolean

fu_hwids_has_guid(FuHwids *self, const gchar *guid)

{

  return g_hash_table_lookup(self->hash_guid, guid) != NULL;

}

/**

 * fu_hwids_get_guids:

 * @self: a #FuHwids

 *

 * Returns all the defined HWIDs

 *

 * Returns: (transfer none) (element-type utf8): an array of GUIDs

 *

 * Since: 0.9.3

 **/

GPtrArray *

fu_hwids_get_guids(FuHwids *self)

{

  return self->array_guids;

}

/**

 * fu_hwids_get_keys:

 * @self: a #FuHwids

 *

 * Returns all the defined HWID keys.

 *

 * Returns: (transfer container) (element-type utf8): All the known keys,

 * e.g. %FU_HWIDS_KEY_FAMILY

 *

 * Since: 1.5.6

 **/

GPtrArray *

fu_hwids_get_keys(FuHwids *self)

{

  GPtrArray *array = g_ptr_array_new();

  const gchar *keys[] = {FU_HWIDS_KEY_BIOS_VENDOR,

             FU_HWIDS_KEY_BIOS_VERSION,

             FU_HWIDS_KEY_BIOS_MAJOR_RELEASE,

             FU_HWIDS_KEY_BIOS_MINOR_RELEASE,

             FU_HWIDS_KEY_FIRMWARE_MAJOR_RELEASE,

             FU_HWIDS_KEY_FIRMWARE_MINOR_RELEASE,

             FU_HWIDS_KEY_MANUFACTURER,

             FU_HWIDS_KEY_FAMILY,

             FU_HWIDS_KEY_PRODUCT_NAME,

             FU_HWIDS_KEY_PRODUCT_SKU,

             FU_HWIDS_KEY_ENCLOSURE_KIND,

             FU_HWIDS_KEY_BASEBOARD_MANUFACTURER,

             FU_HWIDS_KEY_BASEBOARD_PRODUCT,

             NULL};

  g_return_val_if_fail(FU_IS_HWIDS(self), NULL);

  for (guint i = 0; keys[i] != NULL; i++)

    g_ptr_array_add(array, (gpointer)keys[i]);

  return array;

}

static gchar *

fu_hwids_get_guid_for_str(const gchar *str, GError **error)

{

  glong items_written = 0;

  g_autofree gunichar2 *data = NULL;

  /* convert to UTF-16 and convert to GUID using custom namespace */

  data = g_utf8_to_utf16(str, -1, NULL, &items_written, error);

  if (data == NULL)

    return NULL;

  if (items_written == 0) {

    g_set_error_literal(error,

            FWUPD_ERROR,

            FWUPD_ERROR_INVALID_FILE,

            "no GUIDs in data");

    return NULL;

  }

  /* ensure the data is in little endian format */

  for (glong i = 0; i < items_written; i++)

    data[i] = GUINT16_TO_LE(data[i]); /* nocheck:blocked */

  /* convert to a GUID */

  return fwupd_guid_hash_data((guint8 *)data,

            items_written * 2,

            FWUPD_GUID_FLAG_NAMESPACE_MICROSOFT);

}

/**

 * fu_hwids_get_replace_keys:

 * @self: a #FuHwids

 * @key: a CHID key, e.g. `HardwareID-03`

 *

 * Gets the defined values for a well known value.

 *

 * Returns: the replacement value, e.g. `Manufacturer&ProductName`, or %NULL for error.

 *

 * Since: 0.9.3

 **/

const gchar *

fu_hwids_get_replace_keys(FuHwids *self, const gchar *key)

{

  const gchar *value;

  g_return_val_if_fail(FU_IS_HWIDS(self), NULL);

  g_return_val_if_fail(key != NULL, NULL);

  value = g_hash_table_lookup(self->chids, key);

  if (value != NULL)

    return value;

  return key;

}

/**

 * fu_hwids_add_chid:

 * @self: a #FuHwids

 * @key: an textual ID, e.g. `HardwareID-05`

 * @value: a composite hardware key, e.g. `Manufacturer&ProductName`

 *

 * Defines a "Computer Hardware ID" in terms of a set of SMBIOS values.

 *

 * Since: 1.9.16

 **/

void

fu_hwids_add_chid(FuHwids *self, const gchar *key, const gchar *value)

{

  g_return_if_fail(FU_IS_HWIDS(self));

  g_return_if_fail(key != NULL);

  g_return_if_fail(value != NULL);

  g_hash_table_insert(self->chids, g_strdup(key), g_strdup(value));

}

static gint

fu_hwids_sort_keys_cb(gconstpointer a, gconstpointer b)

{

  const gchar *key1 = *((gchar **)a);

  const gchar *key2 = *((gchar **)b);

  return g_strcmp0(key1, key2);

}

/**

 * fu_hwids_get_chid_keys:

 * @self: a #FuHwids

 *

 * Returns all the CHID keys added by fu_hwids_add_chid().

 *

 * Returns: (transfer container) (element-type utf8): IDs

 *

 * Since: 1.9.16

 **/

GPtrArray *

fu_hwids_get_chid_keys(FuHwids *self)

{

  GHashTableIter iter;

  gpointer key;

  g_autoptr(GPtrArray) keys = g_ptr_array_new_with_free_func(g_free);

  g_return_val_if_fail(FU_IS_HWIDS(self), NULL);

  g_hash_table_iter_init(&iter, self->chids);

  while (g_hash_table_iter_next(&iter, &key, NULL))

    g_ptr_array_add(keys, g_strdup(key));

  g_ptr_array_sort(keys, fu_hwids_sort_keys_cb);

  return g_steal_pointer(&keys);

}

/**

 * fu_hwids_add_value:

 * @self: a #FuHwids

 * @key: a key, e.g. %FU_HWIDS_KEY_PRODUCT_SKU

 * @value: (nullable): a new value, e.g. `ExampleModel`

 *

 * Sets override values so you can emulate another system.

 *

 * This function has no effect if called after fu_hwids_setup()

 *

 * Since: 1.8.10

 **/

void

fu_hwids_add_value(FuHwids *self, const gchar *key, const gchar *value)

{

  g_return_if_fail(FU_IS_HWIDS(self));

  g_return_if_fail(key != NULL);

  /* does not replace; first value set wins */

  if (g_hash_table_contains(self->hash_values, key))

    return;

  g_hash_table_insert(self->hash_values, g_strdup(key), g_strdup(value));

  /* make suitable for display */

  if (value != NULL) {

    g_autofree gchar *value_safe = g_str_to_ascii(value, "C");

    g_strdelimit(value_safe, "\n\r", '\0');

    g_strchomp(value_safe);

    g_hash_table_insert(self->hash_values_display,

            g_strdup(key),

            g_steal_pointer(&value_safe));

  } else {

    g_hash_table_insert(self->hash_values_display, g_strdup(key), NULL);

  }

}

/**

 * fu_hwids_get_replace_values:

 * @self: a #FuHwids

 * @keys: a key, e.g. `HardwareID-3` or %FU_HWIDS_KEY_PRODUCT_SKU

 * @error: (nullable): optional return location for an error

 *

 * Gets the replacement values for a HardwareID key or plain key.

 *

 * Returns: a string, e.g. `LENOVO&ThinkPad T440s`, or %NULL for error.

 *

 * Since: 0.9.3

 **/

gchar *

fu_hwids_get_replace_values(FuHwids *self, const gchar *keys, GError **error)

{

  g_auto(GStrv) split = NULL;

  g_autoptr(GString) str = g_string_new(NULL);

  g_return_val_if_fail(FU_IS_HWIDS(self), NULL);

  g_return_val_if_fail(keys != NULL, NULL);

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

  /* do any replacements */

  keys = fu_hwids_get_replace_keys(self, keys);

  /* get each part of the HWID */

  split = g_strsplit(keys, "&", -1);

  for (guint j = 0; split[j] != NULL; j++) {

    const gchar *tmp = g_hash_table_lookup(self->hash_values, split[j]);

    if (tmp == NULL) {

      g_set_error(error,

            FWUPD_ERROR,

            FWUPD_ERROR_NOT_FOUND,

            "not available as '%s' unknown",

            split[j]);

      return NULL;

    }

    g_string_append_printf(str, "%s&", tmp);

  }

  if (str->len > 0)

    g_string_truncate(str, str->len - 1);

  return g_strdup(str->str);

}

/**

 * fu_hwids_get_guid:

 * @self: a #FuHwids

 * @keys: a key, e.g. `HardwareID-3` or %FU_HWIDS_KEY_PRODUCT_SKU

 * @error: (nullable): optional return location for an error

 *

 * Gets the GUID for a specific key.

 *

 * Returns: a string, or %NULL for error.

 *

 * Since: 0.9.3

 **/

gchar *

fu_hwids_get_guid(FuHwids *self, const gchar *keys, GError **error)

{

  g_autofree gchar *tmp = NULL;

  g_return_val_if_fail(FU_IS_HWIDS(self), NULL);

  g_return_val_if_fail(keys != NULL, NULL);

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

  tmp = fu_hwids_get_replace_values(self, keys, error);

  if (tmp == NULL)

    return NULL;

  return fu_hwids_get_guid_for_str(tmp, error);

}

/**

 * fu_hwids_add_guid:

 * @self: a #FuHwids

 * @guid: a GUID

 *

 * Adds a HWID GUID value.

 *

 * Since: 1.8.10

 **/

void

fu_hwids_add_guid(FuHwids *self, const gchar *guid)

{

  g_return_if_fail(FU_IS_HWIDS(self));

  g_return_if_fail(guid != NULL);

  g_hash_table_insert(self->hash_guid, g_strdup(guid), GUINT_TO_POINTER(1));

  g_ptr_array_add(self->array_guids, g_strdup(guid));

}

/**

 * fu_hwids_setup:

 * @self: a #FuHwids

 * @error: (nullable): optional return location for an error

 *

 * Adds all the `HardwareID` GUIDs from the previously supplied data.

 *

 * Returns: %TRUE for success

 *

 * Since: 0.9.3

 **/

gboolean

fu_hwids_setup(FuHwids *self, GError **error)

{

  g_autoptr(GPtrArray) chids = fu_hwids_get_chid_keys(self);

  g_return_val_if_fail(FU_IS_HWIDS(self), FALSE);

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

  /* add GUIDs */

  for (guint i = 0; i < chids->len; i++) {

    const gchar *key = g_ptr_array_index(chids, i);

    g_autofree gchar *guid = NULL;

    g_autoptr(GError) error_local = NULL;

    /* get the GUID and add to hash */

    guid = fu_hwids_get_guid(self, key, &error_local);

    if (guid == NULL) {

      g_debug("%s is not available, %s", key, error_local->message);

      continue;

    }

    fu_hwids_add_guid(self, guid);

  }

  return TRUE;

}

static void

fu_hwids_finalize(GObject *object)

{

  FuHwids *self;

  g_return_if_fail(FU_IS_HWIDS(object));

  self = FU_HWIDS(object);

  g_hash_table_unref(self->hash_values);

  g_hash_table_unref(self->hash_values_display);

  g_hash_table_unref(self->hash_guid);

  g_hash_table_unref(self->chids);

  g_ptr_array_unref(self->array_guids);

  G_OBJECT_CLASS(fu_hwids_parent_class)->finalize(object);

}

static void

fu_hwids_class_init(FuHwidsClass *klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS(klass);

  object_class->finalize = fu_hwids_finalize;

}

static void

fu_hwids_init(FuHwids *self)

{

  self->hash_values = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);

  self->hash_values_display = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);

  self->hash_guid = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);

  self->chids = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);

  self->array_guids = g_ptr_array_new_with_free_func(g_free);

  /* Windows 10 CHIDs */

  fu_hwids_add_chid(self,

        "HardwareID-00",

        "Manufacturer&Family&ProductName&ProductSku&BiosVendor&BiosVersion&"

        "BiosMajorRelease&BiosMinorRelease");

  fu_hwids_add_chid(self,

        "HardwareID-01",

        "Manufacturer&Family&ProductName&BiosVendor&BiosVersion&"

        "BiosMajorRelease&BiosMinorRelease");

  fu_hwids_add_chid(self,

        "HardwareID-02",

        "Manufacturer&ProductName&BiosVendor&BiosVersion&"

        "BiosMajorRelease&BiosMinorRelease");

  fu_hwids_add_chid(self,

        "HardwareID-03",

        "Manufacturer&Family&ProductName&ProductSku&"

        "BaseboardManufacturer&BaseboardProduct");

  fu_hwids_add_chid(self, "HardwareID-04", "Manufacturer&Family&ProductName&ProductSku");

  fu_hwids_add_chid(self, "HardwareID-05", "Manufacturer&Family&ProductName");

  fu_hwids_add_chid(self,

        "HardwareID-06",

        "Manufacturer&ProductSku&BaseboardManufacturer&BaseboardProduct");

  fu_hwids_add_chid(self, "HardwareID-07", "Manufacturer&ProductSku");

  fu_hwids_add_chid(self,

        "HardwareID-08",

        "Manufacturer&ProductName&BaseboardManufacturer&BaseboardProduct");

  fu_hwids_add_chid(self, "HardwareID-09", "Manufacturer&ProductName");

  fu_hwids_add_chid(self,

        "HardwareID-10",

        "Manufacturer&Family&BaseboardManufacturer&BaseboardProduct");

  fu_hwids_add_chid(self, "HardwareID-11", "Manufacturer&Family");

  fu_hwids_add_chid(self, "HardwareID-12", "Manufacturer&EnclosureKind");

  fu_hwids_add_chid(self,

        "HardwareID-13",

        "Manufacturer&BaseboardManufacturer&BaseboardProduct");

  fu_hwids_add_chid(self, "HardwareID-14", "Manufacturer");

  /* used by the flashrom plugin */

  fu_hwids_add_chid(self,

        "fwupd-04",

        "Manufacturer&Family&ProductName&ProductSku&BiosVendor");

  fu_hwids_add_chid(self, "fwupd-05", "Manufacturer&Family&ProductName&BiosVendor");

  fu_hwids_add_chid(self, "fwupd-14", "Manufacturer&BiosVendor");

}

/**

 * fu_hwids_new:

 *

 * Creates a new #FuHwids

 *

 * Since: 0.9.3

 **/

FuHwids *

fu_hwids_new(void)

{

  FuHwids *self;

  self = g_object_new(FU_TYPE_HWIDS, NULL);

  return FU_HWIDS(self);

}