/src/fwupd/libfwupdplugin/fu-version-common.c

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

#define G_LOG_DOMAIN "FuCommon"

#include "config.h"

#include <string.h>

#include "fwupd-enums.h"
#include "fwupd-error.h"

#include "fu-string.h"
#include "fu-version-common.h"

/*
 * nocheck:magic-inlines=81
 */

#define FU_COMMON_VERSION_DECODE_BCD(val) (((((val) >> 4) & 0x0f) * 10) + ((val) & 0x0f))

static gchar *
fu_version_ensure_semver_internal(const gchar *version);

/**
 * fu_version_from_uint64:
 * @val: a raw version number
 * @kind: version kind used for formatting, e.g. %FWUPD_VERSION_FORMAT_QUAD
 *
 * Returns a dotted decimal version string from a 64 bit number.
 *
 * Returns: a version number, e.g. `1.2.3.4`, or %NULL if not supported
 *
 * Since: 1.8.2
 **/
gchar *
fu_version_from_uint64(guint64 val, FwupdVersionFormat kind)
{
  if (kind == FWUPD_VERSION_FORMAT_QUAD) {
    /* AABB.CCDD.EEFF.GGHH */
    return g_strdup_printf("%" G_GUINT64_FORMAT "."
               "%" G_GUINT64_FORMAT "."
               "%" G_GUINT64_FORMAT "."
               "%" G_GUINT64_FORMAT "",
               (val >> 48) & 0xffff,
               (val >> 32) & 0xffff,
               (val >> 16) & 0xffff,
               val & 0xffff);
  }
  if (kind == FWUPD_VERSION_FORMAT_PAIR) {
    /* AABBCCDD.EEFFGGHH */
    return g_strdup_printf("%" G_GUINT64_FORMAT ".%" G_GUINT64_FORMAT "",
               (val >> 32) & 0xffffffff,
               val & 0xffffffff);
  }
  if (kind == FWUPD_VERSION_FORMAT_COMPAL_BIOS) {
    /* AA.BB */
    return g_strdup_printf("%02x.%02x",
               (guint)((val >> 8) & 0xff),
               (guint)(val & 0xff));
  }
  if (kind == FWUPD_VERSION_FORMAT_NUMBER || kind == FWUPD_VERSION_FORMAT_PLAIN) {
    /* AABBCCDD */
    return g_strdup_printf("%" G_GUINT64_FORMAT, val);
  }
  if (kind == FWUPD_VERSION_FORMAT_HEX) {
    /* 0xAABBCCDDEEFFGGHH */
    return g_strdup_printf("0x%08x%08x",
               (guint32)(val >> 32),
               (guint32)(val & 0xffffffff));
  }
  g_critical("failed to convert version format %s: %" G_GUINT64_FORMAT "",
       fwupd_version_format_to_string(kind),
       val);
  return NULL;
}

/**
 * fu_version_from_uint32:
 * @val: a uint32le version number
 * @kind: version kind used for formatting, e.g. %FWUPD_VERSION_FORMAT_TRIPLET
 *
 * Returns a dotted decimal version string from a 32 bit number.
 *
 * Returns: a version number, e.g. `1.0.3`, or %NULL if not supported
 *
 * Since: 1.8.2
 **/
gchar *
fu_version_from_uint32(guint32 val, FwupdVersionFormat kind)
{
  if (kind == FWUPD_VERSION_FORMAT_QUAD) {
    /* AA.BB.CC.DD */
    return g_strdup_printf("%u.%u.%u.%u",
               (val >> 24) & 0xff,
               (val >> 16) & 0xff,
               (val >> 8) & 0xff,
               val & 0xff);
  }
  if (kind == FWUPD_VERSION_FORMAT_TRIPLET) {
    /* AA.BB.CCDD */
    return g_strdup_printf("%u.%u.%u",
               (val >> 24) & 0xff,
               (val >> 16) & 0xff,
               val & 0xffff);
  }
  if (kind == FWUPD_VERSION_FORMAT_PAIR) {
    /* AABB.CCDD */
    return g_strdup_printf("%u.%u", (val >> 16) & 0xffff, val & 0xffff);
  }
  if (kind == FWUPD_VERSION_FORMAT_COMPAL_BIOS) {
    /* AA.BB */
    return g_strdup_printf("%02x.%02x", (val >> 8) & 0xff, val & 0xff);
  }
  if (kind == FWUPD_VERSION_FORMAT_NUMBER || kind == FWUPD_VERSION_FORMAT_PLAIN) {
    /* AABBCCDD */
    return g_strdup_printf("%" G_GUINT32_FORMAT, val);
  }
  if (kind == FWUPD_VERSION_FORMAT_BCD) {
    /* AA.BB.CC.DD, but BCD */
    return g_strdup_printf("%u.%u.%u.%u",
               FU_COMMON_VERSION_DECODE_BCD(val >> 24),
               FU_COMMON_VERSION_DECODE_BCD(val >> 16),
               FU_COMMON_VERSION_DECODE_BCD(val >> 8),
               FU_COMMON_VERSION_DECODE_BCD(val));
  }
  if (kind == FWUPD_VERSION_FORMAT_INTEL_ME) {
    /* aaa+11.bbbbb.cccccccc.dddddddddddddddd */
    return g_strdup_printf("%u.%u.%u.%u",
               ((val >> 29) & 0x07) + 0x0b,
               (val >> 24) & 0x1f,
               (val >> 16) & 0xff,
               val & 0xffff);
  }
  if (kind == FWUPD_VERSION_FORMAT_INTEL_ME2) {
    /* A.B.CC.DDDD */
    return g_strdup_printf("%u.%u.%u.%u",
               (val >> 28) & 0x0f,
               (val >> 24) & 0x0f,
               (val >> 16) & 0xff,
               val & 0xffff);
  }
  if (kind == FWUPD_VERSION_FORMAT_INTEL_CSME19) {
    /* aaa+19.bbbbb.cccccccc.dddddddddddddddd */
    return g_strdup_printf("%u.%u.%u.%u",
               ((val >> 29) & 0x07) + 19,
               (val >> 24) & 0x1f,
               (val >> 16) & 0xff,
               val & 0xffff);
  }
  if (kind == FWUPD_VERSION_FORMAT_SURFACE_LEGACY) {
    /* 10b.12b.10b */
    return g_strdup_printf("%u.%u.%u",
               (val >> 22) & 0x3ff,
               (val >> 10) & 0xfff,
               val & 0x3ff);
  }
  if (kind == FWUPD_VERSION_FORMAT_SURFACE) {
    /* 8b.16b.8b */
    return g_strdup_printf("%u.%u.%u",
               (val >> 24) & 0xff,
               (val >> 8) & 0xffff,
               val & 0xff);
  }
  if (kind == FWUPD_VERSION_FORMAT_DELL_BIOS) {
    /* BB.CC.DD */
    return g_strdup_printf("%u.%u.%u",
               (val >> 16) & 0xff,
               (val >> 8) & 0xff,
               val & 0xff);
  }
  if (kind == FWUPD_VERSION_FORMAT_HEX) {
    /* 0xAABBCCDD */
    return g_strdup_printf("0x%08x", val);
  }
  if (kind == FWUPD_VERSION_FORMAT_DELL_BIOS_MSB) {
    /* AA.BB.CC */
    return g_strdup_printf("%u.%u.%u",
               (val >> 24) & 0xff,
               (val >> 16) & 0xff,
               (val >> 8) & 0xff);
  }
  g_critical("failed to convert version format %s: %u",
       fwupd_version_format_to_string(kind),
       val);
  return NULL;
}

/**
 * fu_version_from_uint32_hex:
 * @val: a uint32le version number
 * @kind: version kind used for formatting, e.g. %FWUPD_VERSION_FORMAT_TRIPLET
 *
 * Returns a dotted decimal hex string from a 32 bit number.
 *
 * Returns: a version number, e.g. `1a.0.d3`, or %NULL if not supported
 *
 * Since: 2.0.0
 **/
gchar *
fu_version_from_uint32_hex(guint32 val, FwupdVersionFormat kind)
{
  if (kind == FWUPD_VERSION_FORMAT_HEX)
    return g_strdup_printf("0x%x", val);
  if (kind == FWUPD_VERSION_FORMAT_NUMBER)
    return g_strdup_printf("%x", val);
  if (kind == FWUPD_VERSION_FORMAT_PAIR)
    return g_strdup_printf("%x.%x", (val >> 16) & 0xffff, val & 0xffff);
  if (kind == FWUPD_VERSION_FORMAT_TRIPLET) {
    return g_strdup_printf("%x.%x.%x",
               (val >> 24) & 0xff,
               (val >> 16) & 0xff,
               val & 0xffff);
  }
  if (kind == FWUPD_VERSION_FORMAT_DELL_BIOS) {
    return g_strdup_printf("%x.%x.%x",
               (val >> 16) & 0xff,
               (val >> 8) & 0xff,
               val & 0xff);
  }
  if (kind == FWUPD_VERSION_FORMAT_DELL_BIOS_MSB) {
    return g_strdup_printf("%x.%x.%x",
               (val >> 24) & 0xff,
               (val >> 16) & 0xff,
               (val >> 8) & 0xff);
  }
  if (kind == FWUPD_VERSION_FORMAT_QUAD) {
    return g_strdup_printf("%x.%x.%x.%x",
               (val >> 24) & 0xff,
               (val >> 16) & 0xff,
               (val >> 8) & 0xff,
               val & 0xff);
  }

  if (kind == FWUPD_VERSION_FORMAT_BCD) {
    return g_strdup_printf("%x.%x.%x.%x",
               FU_COMMON_VERSION_DECODE_BCD(val >> 24),
               FU_COMMON_VERSION_DECODE_BCD(val >> 16),
               FU_COMMON_VERSION_DECODE_BCD(val >> 8),
               FU_COMMON_VERSION_DECODE_BCD(val));
  }
  g_critical("failed to convert version format %s: %u",
       fwupd_version_format_to_string(kind),
       val);
  return NULL;
}

/**
 * fu_version_from_uint24:
 * @val: a uint24le version number
 * @kind: version kind used for formatting, e.g. %FWUPD_VERSION_FORMAT_TRIPLET
 *
 * Returns a dotted decimal version string from a 24 bit number.
 *
 * Returns: a version number, e.g. `1.0.3`, or %NULL if not supported
 *
 * Since: 1.8.9
 **/
gchar *
fu_version_from_uint24(guint32 val, FwupdVersionFormat kind)
{
  if (kind == FWUPD_VERSION_FORMAT_TRIPLET) {
    /* BB.CC.DD */
    return g_strdup_printf("%u.%u.%u",
               (val >> 24) & 0xff,
               (val >> 16) & 0xff,
               val & 0xffff);
  }
  if (kind == FWUPD_VERSION_FORMAT_PAIR) {
    /* BB.CCDD */
    return g_strdup_printf("%u.%u", (val >> 16) & 0xff, val & 0xffff);
  }
  if (kind == FWUPD_VERSION_FORMAT_NUMBER || kind == FWUPD_VERSION_FORMAT_PLAIN) {
    /* BBCCDD */
    return g_strdup_printf("%" G_GUINT32_FORMAT, val);
  }
  if (kind == FWUPD_VERSION_FORMAT_HEX) {
    /* 0xBBCCDD */
    return g_strdup_printf("0x%06x", val);
  }
  g_critical("failed to convert version format %s: %u",
       fwupd_version_format_to_string(kind),
       val);
  return NULL;
}

/**
 * fu_version_from_uint16:
 * @val: a uint16le version number
 * @kind: version kind used for formatting, e.g. %FWUPD_VERSION_FORMAT_TRIPLET
 *
 * Returns a dotted decimal version string from a 16 bit number.
 *
 * Returns: a version number, e.g. `1.3`, or %NULL if not supported
 *
 * Since: 1.8.2
 **/
gchar *
fu_version_from_uint16(guint16 val, FwupdVersionFormat kind)
{
  if (kind == FWUPD_VERSION_FORMAT_BCD) {
    return g_strdup_printf("%i.%i",
               FU_COMMON_VERSION_DECODE_BCD(val >> 8),
               FU_COMMON_VERSION_DECODE_BCD(val));
  }
  if (kind == FWUPD_VERSION_FORMAT_PAIR)
    return g_strdup_printf("%u.%u", (guint)(val >> 8) & 0xff, (guint)val & 0xff);
  if (kind == FWUPD_VERSION_FORMAT_COMPAL_BIOS)
    return g_strdup_printf("%02x.%02x", (guint)(val >> 8) & 0xff, (guint)val & 0xff);
  if (kind == FWUPD_VERSION_FORMAT_QUAD) {
    return g_strdup_printf("%u.%u.%u.%u",
               (guint)(val >> 12) & 0xF,
               (guint)(val >> 8) & 0xF,
               (guint)(val >> 4) & 0xF,
               (guint)val & 0xF);
  }
  if (kind == FWUPD_VERSION_FORMAT_TRIPLET) {
    return g_strdup_printf("%u.%u.%u",
               (guint)(val >> 12) & 0xF,
               (guint)(val >> 8) & 0xF,
               (guint)val & 0xFF);
  }
  if (kind == FWUPD_VERSION_FORMAT_NUMBER || kind == FWUPD_VERSION_FORMAT_PLAIN)
    return g_strdup_printf("%" G_GUINT16_FORMAT, val);
  if (kind == FWUPD_VERSION_FORMAT_HEX) {
    /* 0xAABB */
    return g_strdup_printf("0x%04x", val);
  }
  g_critical("failed to convert version format %s: %u",
       fwupd_version_format_to_string(kind),
       val);
  return NULL;
}

/**
 * fu_version_from_uint16_hex:
 * @val: a uint16le version number
 * @kind: version kind used for formatting, e.g. %FWUPD_VERSION_FORMAT_TRIPLET
 *
 * Returns a dotted hex version string from a 16 bit number.
 *
 * Returns: a version number, e.g. `1a.f3`, or %NULL if not supported
 *
 * Since: 2.0.0
 **/
gchar *
fu_version_from_uint16_hex(guint16 val, FwupdVersionFormat kind)
{
  if (kind == FWUPD_VERSION_FORMAT_NUMBER)
    return g_strdup_printf("%x", val);
  if (kind == FWUPD_VERSION_FORMAT_HEX)
    return g_strdup_printf("0x%x", val);
  if (kind == FWUPD_VERSION_FORMAT_PAIR)
    return g_strdup_printf("%x.%x", (guint)(val >> 8) & 0xff, (guint)val & 0xff);
  if (kind == FWUPD_VERSION_FORMAT_BCD) {
    return g_strdup_printf("%x.%x",
               (guint)FU_COMMON_VERSION_DECODE_BCD(val >> 8),
               (guint)FU_COMMON_VERSION_DECODE_BCD(val));
  }
  if (kind == FWUPD_VERSION_FORMAT_TRIPLET) {
    return g_strdup_printf("%x.%x.%x",
               (guint)(val >> 12) & 0xF,
               (guint)(val >> 8) & 0xF,
               (guint)val & 0xFF);
  }
  g_critical("failed to convert version format %s: %u",
       fwupd_version_format_to_string(kind),
       val);
  return NULL;
}

static gint
fu_version_compare_char(gchar chr1, gchar chr2)
{
  if (chr1 == chr2)
    return 0;
  if (chr1 == '~')
    return -1;
  if (chr2 == '~')
    return 1;
  return chr1 < chr2 ? -1 : 1;
}

static gint
fu_version_compare_chunk(const gchar *str1, const gchar *str2)
{
  guint i;

  /* trivial */
  if (g_strcmp0(str1, str2) == 0)
    return 0;
  if (str1 == NULL)
    return 1;
  if (str2 == NULL)
    return -1;

  /* check each char of the chunk */
  for (i = 0; str1[i] != '\0' && str2[i] != '\0'; i++) {
    gint rc = fu_version_compare_char(str1[i], str2[i]);
    if (rc != 0)
      return rc;
  }
  return fu_version_compare_char(str1[i], str2[i]);
}

static gboolean
_g_ascii_is_digits(const gchar *str)
{
  g_return_val_if_fail(str != NULL, FALSE);
  for (gsize i = 0; str[i] != '\0'; i++) {
    if (!g_ascii_isdigit(str[i]))
      return FALSE;
  }
  return TRUE;
}

static gboolean
_g_ascii_is_xdigits(const gchar *str)
{
  g_return_val_if_fail(str != NULL, FALSE);
  for (gsize i = 0; str[i] != '\0'; i++) {
    if (!g_ascii_isxdigit(str[i]))
      return FALSE;
  }
  return TRUE;
}

static guint
fu_version_format_number_sections(FwupdVersionFormat fmt)
{
  if (fmt == FWUPD_VERSION_FORMAT_PLAIN || fmt == FWUPD_VERSION_FORMAT_NUMBER ||
      fmt == FWUPD_VERSION_FORMAT_HEX)
    return 1;
  if (fmt == FWUPD_VERSION_FORMAT_PAIR || fmt == FWUPD_VERSION_FORMAT_COMPAL_BIOS ||
      fmt == FWUPD_VERSION_FORMAT_BCD)
    return 2;
  if (fmt == FWUPD_VERSION_FORMAT_TRIPLET || fmt == FWUPD_VERSION_FORMAT_SURFACE_LEGACY ||
      fmt == FWUPD_VERSION_FORMAT_SURFACE || fmt == FWUPD_VERSION_FORMAT_DELL_BIOS ||
      fmt == FWUPD_VERSION_FORMAT_DELL_BIOS_MSB)
    return 3;
  if (fmt == FWUPD_VERSION_FORMAT_QUAD || fmt == FWUPD_VERSION_FORMAT_INTEL_ME ||
      fmt == FWUPD_VERSION_FORMAT_INTEL_ME2 || fmt == FWUPD_VERSION_FORMAT_INTEL_CSME19)
    return 4;
  return 0;
}

/**
 * fu_version_ensure_semver:
 * @version: (nullable): a version number, e.g. ` V1.2.3 `
 * @fmt: a version format, e.g. %FWUPD_VERSION_FORMAT_TRIPLET
 *
 * Builds a semver from the possibly crazy version number. Depending on the @semver value
 * the string will be split and a string in the correct format will be returned.
 *
 * Returns: a version number, e.g. `1.2.3`, or %NULL if the version was not valid
 *
 * Since: 1.8.2
 */
gchar *
fu_version_ensure_semver(const gchar *version, FwupdVersionFormat fmt)
{
  guint sections_actual;
  guint sections_expected = fu_version_format_number_sections(fmt);
  g_autofree gchar *tmp = NULL;
  g_auto(GStrv) split = NULL;
  g_autoptr(GString) str = g_string_new(NULL);

  /* split into all sections */
  tmp = fu_version_ensure_semver_internal(version);
  if (tmp == NULL)
    return NULL;
  if (fmt == FWUPD_VERSION_FORMAT_UNKNOWN)
    return g_steal_pointer(&tmp);
  split = g_strsplit(tmp, ".", -1);
  sections_actual = g_strv_length(split);

  /* add zero sections as required */
  if (sections_actual < sections_expected) {
    for (guint i = 0; i < sections_expected - sections_actual; i++) {
      if (str->len > 0)
        g_string_append(str, ".");
      g_string_append(str, "0");
    }
  }

  /* only add enough sections for the format */
  for (guint i = 0; i < sections_actual && i < sections_expected; i++) {
    if (str->len > 0)
      g_string_append(str, ".");
    g_string_append(str, split[i]);
  }

  /* success */
  return g_string_free(g_steal_pointer(&str), FALSE);
}

static gchar *
fu_version_ensure_semver_internal(const gchar *version)
{
  gboolean dot_valid = FALSE;
  guint digit_cnt = 0;
  g_autoptr(GString) version_safe = g_string_new(NULL);

  /* invalid */
  if (version == NULL)
    return NULL;

  /* hex prefix */
  if (g_str_has_prefix(version, "0x")) {
    return fu_version_parse_from_format(version, FWUPD_VERSION_FORMAT_TRIPLET);
  }

  /* make sane */
  for (guint i = 0; version[i] != '\0'; i++) {
    if (g_ascii_isdigit(version[i])) {
      g_string_append_c(version_safe, version[i]);
      digit_cnt++;
      dot_valid = TRUE;
      continue;
    }
    if (version[i] == '-' || version[i] == '~') {
      g_string_append_c(version_safe, '.');
      dot_valid = FALSE;
      continue;
    }
    if (version[i] == '.' && dot_valid && version[i + 1] != '\0') {
      g_string_append_c(version_safe, version[i]);
      dot_valid = FALSE;
      continue;
    }
  }

  /* remove any trailing dot */
  if (version_safe->len > 0 && version_safe->str[version_safe->len - 1] == '.')
    g_string_truncate(version_safe, version_safe->len - 1);

  /* found no digits */
  if (digit_cnt == 0)
    return NULL;
  return g_string_free(g_steal_pointer(&version_safe), FALSE);
}

/**
 * fu_version_parse_from_format
 * @version: (nullable): a version number
 * @fmt: a version format, e.g. %FWUPD_VERSION_FORMAT_TRIPLET
 *
 * Returns a dotted decimal version string from a version string using @fmt.
 * The supported formats are:
 *
 * - Dotted decimal, e.g. `1.2.3`
 * - Base 16, a hex number *with* a 0x prefix, e.g. `0x10203`
 * - Base 10, a string containing just [0-9], e.g. `66051`
 * - Date in YYYYMMDD format, e.g. `20150915`
 *
 * Anything with a `.` or that doesn't match `[0-9]` or `0x[a-f,0-9]` is considered
 * a string and returned without modification.
 *
 * Returns: a version number, e.g. `1.0.3`, or %NULL on error
 *
 * Since: 1.8.2
 */
gchar *
fu_version_parse_from_format(const gchar *version, FwupdVersionFormat fmt)
{
  guint64 tmp = 0;

  /* sanity check */
  if (version == NULL)
    return NULL;

  /* already dotted decimal */
  if (g_strstr_len(version, -1, ".") != NULL)
    return g_strdup(version);

  /* is a date */
  if (g_str_has_prefix(version, "20") && strlen(version) == 8)
    return g_strdup(version);

  /* convert 0x prefixed strings to dotted decimal */
  if (!fu_strtoull(version, &tmp, 0, G_MAXUINT32, FU_INTEGER_BASE_AUTO, NULL))
    return g_strdup(version);
  if (tmp == 0)
    return g_strdup(version);
  return fu_version_from_uint32((guint32)tmp, fmt);
}

/**
 * fu_version_guess_format:
 * @version: (nullable): a version number, e.g. `1.2.3`
 *
 * Guesses the version format from the version number. This is only a heuristic
 * and plugins and components should explicitly set the version format whenever
 * possible.
 *
 * If the version format cannot be guessed with any degree of accuracy, the
 * %FWUPD_VERSION_FORMAT_UNKNOWN constant is returned.
 *
 * Returns: a version format, e.g. %FWUPD_VERSION_FORMAT_QUAD
 *
 * Since: 1.8.2
 */
FwupdVersionFormat
fu_version_guess_format(const gchar *version)
{
  guint sz;
  g_auto(GStrv) split = NULL;

  /* nothing to use */
  if (version == NULL || version[0] == '\0')
    return FWUPD_VERSION_FORMAT_UNKNOWN;

  /* no dots, assume just text */
  split = g_strsplit(version, ".", -1);
  sz = g_strv_length(split);
  if (sz == 1) {
    if (g_str_has_prefix(version, "0x") || _g_ascii_is_digits(version))
      return FWUPD_VERSION_FORMAT_NUMBER;
    if (_g_ascii_is_xdigits(version))
      return FWUPD_VERSION_FORMAT_HEX;
    return FWUPD_VERSION_FORMAT_PLAIN;
  }

  /* check for only-digit semver version */
  for (guint i = 0; split[i] != NULL; i++) {
    /* check sections are plain numbers */
    if (!_g_ascii_is_digits(split[i]))
      return FWUPD_VERSION_FORMAT_PLAIN;
  }

  /* the most common formats */
  if (sz == 2)
    return FWUPD_VERSION_FORMAT_PAIR;
  if (sz == 3)
    return FWUPD_VERSION_FORMAT_TRIPLET;
  if (sz == 4)
    return FWUPD_VERSION_FORMAT_QUAD;

  /* unknown! */
  return FWUPD_VERSION_FORMAT_UNKNOWN;
}

static FwupdVersionFormat
fu_version_format_convert_base(FwupdVersionFormat fmt)
{
  if (fmt == FWUPD_VERSION_FORMAT_INTEL_ME || fmt == FWUPD_VERSION_FORMAT_INTEL_ME2 ||
      fmt == FWUPD_VERSION_FORMAT_INTEL_CSME19)
    return FWUPD_VERSION_FORMAT_QUAD;
  if (fmt == FWUPD_VERSION_FORMAT_DELL_BIOS || fmt == FWUPD_VERSION_FORMAT_DELL_BIOS_MSB ||
      fmt == FWUPD_VERSION_FORMAT_SURFACE || fmt == FWUPD_VERSION_FORMAT_SURFACE_LEGACY)
    return FWUPD_VERSION_FORMAT_TRIPLET;
  if (fmt == FWUPD_VERSION_FORMAT_BCD)
    return FWUPD_VERSION_FORMAT_PAIR;
  if (fmt == FWUPD_VERSION_FORMAT_HEX)
    return FWUPD_VERSION_FORMAT_NUMBER;
  return fmt;
}

/**
 * fu_version_verify_format:
 * @version: (not nullable): a string, e.g. `0x1234`
 * @fmt: a version format
 * @error: (nullable): optional return location for an error
 *
 * Verifies if a version matches the input format.
 *
 * Returns: TRUE or FALSE
 *
 * Since: 1.8.2
 **/
gboolean
fu_version_verify_format(const gchar *version, FwupdVersionFormat fmt, GError **error)
{
  FwupdVersionFormat fmt_guess;

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

  /* don't touch */
  if (fmt == FWUPD_VERSION_FORMAT_PLAIN)
    return TRUE;

  /* nothing we can check for */
  if (fmt == FWUPD_VERSION_FORMAT_UNKNOWN)
    return TRUE;

  /* hex */
  if (fmt == FWUPD_VERSION_FORMAT_HEX) {
    if (_g_ascii_is_xdigits(version))
      return TRUE;
  }

  /* check the base format */
  fmt_guess = fu_version_guess_format(version);
  if (fmt == FWUPD_VERSION_FORMAT_BCD &&
      (fmt_guess == FWUPD_VERSION_FORMAT_PAIR || fmt_guess == FWUPD_VERSION_FORMAT_QUAD))
    return TRUE;
  if (fmt_guess == FWUPD_VERSION_FORMAT_PAIR && fmt == FWUPD_VERSION_FORMAT_COMPAL_BIOS)
    return TRUE;
  if (fmt_guess != fu_version_format_convert_base(fmt)) {
    g_set_error(error,
          FWUPD_ERROR,
          FWUPD_ERROR_INVALID_DATA,
          "%s is not a valid %s (guessed %s)",
          version,
          fwupd_version_format_to_string(fmt),
          fwupd_version_format_to_string(fmt_guess));
    return FALSE;
  }
  return TRUE;
}

static gint
fu_version_compare_safe(const gchar *version_a, const gchar *version_b)
{
  guint longest_split;
  g_auto(GStrv) split_a = NULL;
  g_auto(GStrv) split_b = NULL;

  /* sanity check */
  if (version_a == NULL || version_b == NULL)
    return G_MAXINT;

  /* optimization */
  if (g_strcmp0(version_a, version_b) == 0)
    return 0;

  /* split into sections, and try to parse */
  split_a = g_strsplit(version_a, ".", -1);
  split_b = g_strsplit(version_b, ".", -1);
  longest_split = MAX(g_strv_length(split_a), g_strv_length(split_b));
  for (guint i = 0; i < longest_split; i++) {
    gchar *endptr_a = NULL;
    gchar *endptr_b = NULL;
    gint64 ver_a;
    gint64 ver_b;

    /* we lost or gained a dot */
    if (split_a[i] == NULL)
      return -1;
    if (split_b[i] == NULL)
      return 1;

    /* compare integers */
    ver_a = g_ascii_strtoll(split_a[i], &endptr_a, 10); /* nocheck:blocked */
    ver_b = g_ascii_strtoll(split_b[i], &endptr_b, 10); /* nocheck:blocked */
    if (ver_a < ver_b)
      return -1;
    if (ver_a > ver_b)
      return 1;

    /* compare strings */
    if ((endptr_a != NULL && endptr_a[0] != '\0') ||
        (endptr_b != NULL && endptr_b[0] != '\0')) {
      gint rc = fu_version_compare_chunk(endptr_a, endptr_b);
      if (rc < 0)
        return -1;
      if (rc > 0)
        return 1;
    }
  }

  /* we really shouldn't get here */
  return 0;
}

/**
 * fu_version_compare:
 * @version_a: (nullable): the semver release version, e.g. `1.2.3`
 * @version_b: (nullable): the semver release version, e.g. `1.2.3.1`
 * @fmt: a version format, e.g. %FWUPD_VERSION_FORMAT_PLAIN
 *
 * Compares version numbers for sorting taking into account the version format
 * if required.
 *
 * Returns: -1 if a < b, +1 if a > b, 0 if they are equal, and %G_MAXINT on error
 *
 * Since: 1.8.2
 */
gint
fu_version_compare(const gchar *version_a, const gchar *version_b, FwupdVersionFormat fmt)
{
  if (fmt == FWUPD_VERSION_FORMAT_PLAIN)
    return g_strcmp0(version_a, version_b);
  if (fmt == FWUPD_VERSION_FORMAT_HEX) {
    g_autofree gchar *hex_a = NULL;
    g_autofree gchar *hex_b = NULL;
    hex_a = fu_version_parse_from_format(version_a, fmt);
    hex_b = fu_version_parse_from_format(version_b, fmt);
    return fu_version_compare_safe(hex_a, hex_b);
  }
  return fu_version_compare_safe(version_a, version_b);
}

Coverage Report

Created: 2026-07-16 07:10