proxmox-mirrors/fwupd
1
0
Fork 0
mirror of https://git.proxmox.com/git/fwupd synced 2025-07-31 23:03:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

trivial: Unify ambiguity between bios-attrs and bios-settings

Browse Source 
These are currently used interchangeably since there was indecisiveness
which to use as the feature was being developed.

As outward facing it will be named with "settings", change all uses
in the code to match this.
This commit is contained in:
Mario Limonciello 2022-08-24 00:14:39 -05:00 committed by Mario Limonciello
parent 8b63023aaf
commit b7b0ce533d
48 changed files with 1286 additions and 1260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
contrib/ci/populate-bios-attr-translations.py → contrib/ci/populate-bios-setting-translations.py
View File

@ -32,6 +32,6 @@ def populate_translations(path):
if __name__ == "__main__":
if len(sys.argv) != 2:
print("path to bios attributes directory required")
print("path to bios settings directory required")
sys.exit(1)
populate_translations(sys.argv[1])

14
contrib/generate-emulation.py
View File

@ -25,7 +25,7 @@ def _minimize_json(json_str: str) -> str:
nodes = json.loads(json_str)
new_attrs: List[Dict[str, Any]] = []
new_devices: List[Dict[str, Any]] = []
new_bios_attrs: List[Dict[str, Any]] = []
new_bios_settings: List[Dict[str, Any]] = []
try:
for attr in nodes["SecurityAttributes"]:
new_attr: Dict[str, Any] = {}
@ -45,19 +45,19 @@ def _minimize_json(json_str: str) -> str:
except KeyError:
pass
try:
for device in nodes["BiosAttributes"]:
for device in nodes["BiosSettings"]:
new_attr: Dict[str, Any] = {}
for key in device:
if key not in ["Filename"]:
new_attr[key] = device[key]
new_bios_attrs.append(new_attr)
new_bios_settings.append(new_attr)
except KeyError:
pass
return json.dumps(
{
"SecurityAttributes": new_attrs,
"Devices": new_devices,
"BiosAttributes": new_bios_attrs,
"BiosSettings": new_bios_settings,
},
indent=2,
separators=(",", " : "),
@ -99,13 +99,13 @@ def _get_host_devices_and_attrs() -> str:
builder.end_object()
builder.end_array()
# add BIOS attributes
# add BIOS settings
try:
attrs = client.get_bios_attrs()
attrs = client.get_bios_settings()
except GLib.GError as e:
print("ignoring {}".format(e))
else:
builder.set_member_name("BiosAttributes")
builder.set_member_name("BiosSettings")
builder.begin_array()
for attr in attrs:
builder.begin_object()

18
data/bash-completion/fwupdmgr
View File

@ -104,23 +104,23 @@ _show_modifiers()
COMPREPLY+=( $(compgen -W '${_fwupdmgr_opts[@]}' -- "$cur") )
}
_show_bios_attrs()
_show_bios_settings()
{
if ! command -v jq &> /dev/null; then
return 0
fi
local attr
attr="$(command fwupdmgr get-bios-setting --json --no-authenticate 2>/dev/null | jq '.BiosAttributes | .[] | .Name')"
attr="$(command fwupdmgr get-bios-setting --json --no-authenticate 2>/dev/null | jq '.BiosSettings | .[] | .Name')"
COMPREPLY+=( $(compgen -W "${attr}" -- "$cur") )
}
_show_bios_attrs_possible()
_show_bios_settings_possible()
{
if ! command -v jq &> /dev/null; then
return 0
fi
local attr
attr="$(command fwupdmgr get-bios-setting "$1" --json --no-authenticate 2>/dev/null | jq '.BiosAttributes | .[] | .BiosAttrPossibleValues | .[]')"
attr="$(command fwupdmgr get-bios-setting "$1" --json --no-authenticate 2>/dev/null | jq '.BiosSettings | .[] | .BiosSettingPossibleValues | .[]')"
COMPREPLY+=( $(compgen -W "${attr}" -- "$cur") )
}
@ -174,8 +174,8 @@ _fwupdmgr()
fi
;;
get-bios-settings|get-bios-setting)
#bios attrs (no limit)
_show_bios_attrs
#bios settings (no limit)
_show_bios_settings
_show_bios_get_modifiers
return 0
;;
@ -185,13 +185,13 @@ _fwupdmgr()
return 0
fi
count=$(($((args)) % 2))
#allow setting a single bios attr at a time
#allow setting a single bios setting at a time
if [[ $count == 0 ]]; then
_show_bios_attrs
_show_bios_settings
fi
#possible values (only works for enumeration though)
if [[ $count == 1 ]]; then
_show_bios_attrs_possible "$prev"
_show_bios_settings_possible "$prev"
return 0
fi
_show_bios_set_modifiers

18
libfwupd/fwupd-bios-attr-private.h
View File

@ -1,18 +0,0 @@
/*
* Copyright (C) 2022 Mario Limonciello <mario.limonciello@amd.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include <json-glib/json-glib.h>
#include "fwupd-bios-attr.h"
#pragma once
GVariant *
fwupd_bios_attr_to_variant(FwupdBiosAttr *self, gboolean trusted);
void
fwupd_bios_attr_to_json(FwupdBiosAttr *self, JsonBuilder *builder);
gboolean
fwupd_bios_attr_from_json(FwupdBiosAttr *self, JsonNode *json_node, GError **error);

118
libfwupd/fwupd-bios-attr.h
View File

@ -1,118 +0,0 @@
/*
* Copyright (C) 2022 Mario Limonciello <mario.limonciello@amd.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <glib-object.h>
#include "fwupd-enums.h"
G_BEGIN_DECLS
#define FWUPD_TYPE_BIOS_ATTR (fwupd_bios_attr_get_type())
G_DECLARE_DERIVABLE_TYPE(FwupdBiosAttr, fwupd_bios_attr, FWUPD, BIOS_ATTR, GObject)
struct _FwupdBiosAttrClass {
GObjectClass parent_class;
/*< private >*/
void (*_fwupd_reserved1)(void);
void (*_fwupd_reserved2)(void);
void (*_fwupd_reserved3)(void);
void (*_fwupd_reserved4)(void);
void (*_fwupd_reserved5)(void);
void (*_fwupd_reserved6)(void);
void (*_fwupd_reserved7)(void);
};
/* special attributes */
#define FWUPD_BIOS_ATTR_PENDING_REBOOT "pending_reboot"
#define FWUPD_BIOS_ATTR_RESET_BIOS "reset_bios"
#define FWUPD_BIOS_ATTR_DEBUG_CMD "debug_cmd"
/**
* FwupdBiosAttrKind:
* @FWUPD_BIOS_ATTR_KIND_UNKNOWN: BIOS attribute type is unknown
* @FWUPD_BIOS_ATTR_KIND_ENUMERATION: BIOS attribute that has enumerated possible values
* @FWUPD_BIOS_ATTR_KIND_INTEGER: BIOS attribute that is an integer
* @FWUPD_BIOS_ATTR_KIND_STRING: BIOS attribute that accepts a string
*
* The type of BIOS attribute.
**/
typedef enum {
FWUPD_BIOS_ATTR_KIND_UNKNOWN = 0, /* Since: 1.8.4 */
FWUPD_BIOS_ATTR_KIND_ENUMERATION = 1, /* Since: 1.8.4 */
FWUPD_BIOS_ATTR_KIND_INTEGER = 2, /* Since: 1.8.4 */
FWUPD_BIOS_ATTR_KIND_STRING = 3, /* Since: 1.8.4 */
/*< private >*/
FWUPD_BIOS_ATTR_KIND_LAST = 4 /* perhaps increased in the future */
} FwupdBiosAttrKind;
FwupdBiosAttr *
fwupd_bios_attr_new(const gchar *name, const gchar *path);
gchar *
fwupd_bios_attr_to_string(FwupdBiosAttr *self);
gboolean
fwupd_bios_attr_get_read_only(FwupdBiosAttr *self);
void
fwupd_bios_attr_set_read_only(FwupdBiosAttr *self, gboolean val);
guint64
fwupd_bios_attr_get_upper_bound(FwupdBiosAttr *self);
guint64
fwupd_bios_attr_get_lower_bound(FwupdBiosAttr *self);
guint64
fwupd_bios_attr_get_scalar_increment(FwupdBiosAttr *self);
void
fwupd_bios_attr_set_upper_bound(FwupdBiosAttr *self, guint64 val);
void
fwupd_bios_attr_set_lower_bound(FwupdBiosAttr *self, guint64 val);
void
fwupd_bios_attr_set_scalar_increment(FwupdBiosAttr *self, guint64 val);
void
fwupd_bios_attr_set_kind(FwupdBiosAttr *self, FwupdBiosAttrKind type);
void
fwupd_bios_attr_set_name(FwupdBiosAttr *self, const gchar *name);
void
fwupd_bios_attr_set_path(FwupdBiosAttr *self, const gchar *path);
void
fwupd_bios_attr_set_description(FwupdBiosAttr *self, const gchar *description);
FwupdBiosAttrKind
fwupd_bios_attr_get_kind(FwupdBiosAttr *self);
const gchar *
fwupd_bios_attr_get_name(FwupdBiosAttr *self);
const gchar *
fwupd_bios_attr_get_path(FwupdBiosAttr *self);
const gchar *
fwupd_bios_attr_get_description(FwupdBiosAttr *self);
const gchar *
fwupd_bios_attr_map_possible_value(FwupdBiosAttr *self, const gchar *key, GError **error);
gboolean
fwupd_bios_attr_has_possible_value(FwupdBiosAttr *self, const gchar *val);
void
fwupd_bios_attr_add_possible_value(FwupdBiosAttr *self, const gchar *possible_value);
GPtrArray *
fwupd_bios_attr_get_possible_values(FwupdBiosAttr *self);
FwupdBiosAttr *
fwupd_bios_attr_from_variant(GVariant *value);
GPtrArray *
fwupd_bios_attr_array_from_variant(GVariant *value);
const gchar *
fwupd_bios_attr_get_current_value(FwupdBiosAttr *self);
void
fwupd_bios_attr_set_current_value(FwupdBiosAttr *self, const gchar *value);
const gchar *
fwupd_bios_attr_get_id(FwupdBiosAttr *self);
void
fwupd_bios_attr_set_id(FwupdBiosAttr *self, const gchar *id);
G_END_DECLS

18
libfwupd/fwupd-bios-setting-private.h Normal file
View File

@ -0,0 +1,18 @@
/*
* Copyright (C) 2022 Mario Limonciello <mario.limonciello@amd.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#include <json-glib/json-glib.h>
#include "fwupd-bios-setting.h"
#pragma once
GVariant *
fwupd_bios_setting_to_variant(FwupdBiosSetting *self, gboolean trusted);
void
fwupd_bios_setting_to_json(FwupdBiosSetting *self, JsonBuilder *builder);
gboolean
fwupd_bios_setting_from_json(FwupdBiosSetting *self, JsonNode *json_node, GError **error);

585
libfwupd/fwupd-bios-attr.c → libfwupd/fwupd-bios-setting.c
View File

File diff suppressed because it is too large Load Diff

119
libfwupd/fwupd-bios-setting.h Normal file
View File

@ -0,0 +1,119 @@
/*
* Copyright (C) 2022 Mario Limonciello <mario.limonciello@amd.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <glib-object.h>
#include "fwupd-enums.h"
G_BEGIN_DECLS
#define FWUPD_TYPE_BIOS_SETTING (fwupd_bios_setting_get_type())
G_DECLARE_DERIVABLE_TYPE(FwupdBiosSetting, fwupd_bios_setting, FWUPD, BIOS_SETTING, GObject)
struct _FwupdBiosSettingClass {
GObjectClass parent_class;
/*< private >*/
void (*_fwupd_reserved1)(void);
void (*_fwupd_reserved2)(void);
void (*_fwupd_reserved3)(void);
void (*_fwupd_reserved4)(void);
void (*_fwupd_reserved5)(void);
void (*_fwupd_reserved6)(void);
void (*_fwupd_reserved7)(void);
};
/* special attributes */
#define FWUPD_BIOS_SETTING_PENDING_REBOOT "pending_reboot"
#define FWUPD_BIOS_SETTING_RESET_BIOS "reset_bios"
#define FWUPD_BIOS_SETTING_DEBUG_CMD "debug_cmd"
/**
* FwupdBiosSettingKind:
* @FWUPD_BIOS_SETTING_KIND_UNKNOWN: BIOS setting type is unknown
* @FWUPD_BIOS_SETTING_KIND_ENUMERATION: BIOS setting that has enumerated possible
*values
* @FWUPD_BIOS_SETTING_KIND_INTEGER: BIOS setting that is an integer
* @FWUPD_BIOS_SETTING_KIND_STRING: BIOS setting that accepts a string
*
* The type of BIOS setting.
**/
typedef enum {
FWUPD_BIOS_SETTING_KIND_UNKNOWN = 0, /* Since: 1.8.4 */
FWUPD_BIOS_SETTING_KIND_ENUMERATION = 1, /* Since: 1.8.4 */
FWUPD_BIOS_SETTING_KIND_INTEGER = 2, /* Since: 1.8.4 */
FWUPD_BIOS_SETTING_KIND_STRING = 3, /* Since: 1.8.4 */
/*< private >*/
FWUPD_BIOS_SETTING_KIND_LAST = 4 /* perhaps increased in the future */
} FwupdBiosSettingKind;
FwupdBiosSetting *
fwupd_bios_setting_new(const gchar *name, const gchar *path);
gchar *
fwupd_bios_setting_to_string(FwupdBiosSetting *self);
gboolean
fwupd_bios_setting_get_read_only(FwupdBiosSetting *self);
void
fwupd_bios_setting_set_read_only(FwupdBiosSetting *self, gboolean val);
guint64
fwupd_bios_setting_get_upper_bound(FwupdBiosSetting *self);
guint64
fwupd_bios_setting_get_lower_bound(FwupdBiosSetting *self);
guint64
fwupd_bios_setting_get_scalar_increment(FwupdBiosSetting *self);
void
fwupd_bios_setting_set_upper_bound(FwupdBiosSetting *self, guint64 val);
void
fwupd_bios_setting_set_lower_bound(FwupdBiosSetting *self, guint64 val);
void
fwupd_bios_setting_set_scalar_increment(FwupdBiosSetting *self, guint64 val);
void
fwupd_bios_setting_set_kind(FwupdBiosSetting *self, FwupdBiosSettingKind type);
void
fwupd_bios_setting_set_name(FwupdBiosSetting *self, const gchar *name);
void
fwupd_bios_setting_set_path(FwupdBiosSetting *self, const gchar *path);
void
fwupd_bios_setting_set_description(FwupdBiosSetting *self, const gchar *description);
FwupdBiosSettingKind
fwupd_bios_setting_get_kind(FwupdBiosSetting *self);
const gchar *
fwupd_bios_setting_get_name(FwupdBiosSetting *self);
const gchar *
fwupd_bios_setting_get_path(FwupdBiosSetting *self);
const gchar *
fwupd_bios_setting_get_description(FwupdBiosSetting *self);
const gchar *
fwupd_bios_setting_map_possible_value(FwupdBiosSetting *self, const gchar *key, GError **error);
gboolean
fwupd_bios_setting_has_possible_value(FwupdBiosSetting *self, const gchar *val);
void
fwupd_bios_setting_add_possible_value(FwupdBiosSetting *self, const gchar *possible_value);
GPtrArray *
fwupd_bios_setting_get_possible_values(FwupdBiosSetting *self);
FwupdBiosSetting *
fwupd_bios_setting_from_variant(GVariant *value);
GPtrArray *
fwupd_bios_setting_array_from_variant(GVariant *value);
const gchar *
fwupd_bios_setting_get_current_value(FwupdBiosSetting *self);
void
fwupd_bios_setting_set_current_value(FwupdBiosSetting *self, const gchar *value);
const gchar *
fwupd_bios_setting_get_id(FwupdBiosSetting *self);
void
fwupd_bios_setting_set_id(FwupdBiosSetting *self, const gchar *id);
G_END_DECLS

46
libfwupd/fwupd-client-sync.c
View File

@ -888,22 +888,22 @@ fwupd_client_get_results(FwupdClient *self,
}
static void
fwupd_client_modify_bios_attr_cb(GObject *source, GAsyncResult *res, gpointer user_data)
fwupd_client_modify_bios_setting_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
FwupdClientHelper *helper = (FwupdClientHelper *)user_data;
helper->ret =
fwupd_client_modify_bios_attr_finish(FWUPD_CLIENT(source), res, &helper->error);
fwupd_client_modify_bios_setting_finish(FWUPD_CLIENT(source), res, &helper->error);
g_main_loop_quit(helper->loop);
}
/**
* fwupd_client_modify_bios_attr
* fwupd_client_modify_bios_setting
* @self: a #FwupdClient
* @settings: (transfer container): BIOS settings
* @cancellable: (nullable): optional #GCancellable
* @error: (nullable): optional return location for an error
*
* Modifies a BIOS attribute using kernel API.
* Modifies a BIOS setting using kernel API.
* The daemon will only respond to this request with proper permissions.
*
* Returns: %TRUE for success
@ -911,10 +911,10 @@ fwupd_client_modify_bios_attr_cb(GObject *source, GAsyncResult *res, gpointer us
* Since: 1.8.4
**/
gboolean
fwupd_client_modify_bios_attr(FwupdClient *self,
GHashTable *settings,
GCancellable *cancellable,
GError **error)
fwupd_client_modify_bios_setting(FwupdClient *self,
GHashTable *settings,
GCancellable *cancellable,
GError **error)
{
g_autoptr(FwupdClientHelper) helper = NULL;
@ -929,11 +929,11 @@ fwupd_client_modify_bios_attr(FwupdClient *self,
/* call async version and run loop until complete */
helper = fwupd_client_helper_new(self);
fwupd_client_modify_bios_attr_async(self,
settings,
cancellable,
fwupd_client_modify_bios_attr_cb,
helper);
fwupd_client_modify_bios_setting_async(self,
settings,
cancellable,
fwupd_client_modify_bios_setting_cb,
helper);
g_main_loop_run(helper->loop);
if (!helper->ret) {
g_propagate_error(error, g_steal_pointer(&helper->error));
@ -943,28 +943,28 @@ fwupd_client_modify_bios_attr(FwupdClient *self,
}
static void
fwupd_client_get_bios_attrs_cb(GObject *source, GAsyncResult *res, gpointer user_data)
fwupd_client_get_bios_settings_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
FwupdClientHelper *helper = (FwupdClientHelper *)user_data;
helper->array =
fwupd_client_get_bios_attrs_finish(FWUPD_CLIENT(source), res, &helper->error);
fwupd_client_get_bios_settings_finish(FWUPD_CLIENT(source), res, &helper->error);
g_main_loop_quit(helper->loop);
}
/**
* fwupd_client_get_bios_attrs:
* fwupd_client_get_bios_settings:
* @self: a #FwupdClient
* @cancellable: (nullable): optional #GCancellable
* @error: (nullable): optional return location for an error
*
* Gets all the BIOS attributes from the daemon.
* Gets all the BIOS settings from the daemon.
*
* Returns: (element-type FwupdBiosAttr) (transfer container): attributes
* Returns: (element-type FwupdBiosSetting) (transfer container): attributes
*
* Since: 1.8.4
**/
GPtrArray *
fwupd_client_get_bios_attrs(FwupdClient *self, GCancellable *cancellable, GError **error)
fwupd_client_get_bios_settings(FwupdClient *self, GCancellable *cancellable, GError **error)
{
g_autoptr(FwupdClientHelper) helper = NULL;
@ -978,10 +978,10 @@ fwupd_client_get_bios_attrs(FwupdClient *self, GCancellable *cancellable, GError
/* call async version and run loop until complete */
helper = fwupd_client_helper_new(self);
fwupd_client_get_bios_attrs_async(self,
cancellable,
fwupd_client_get_bios_attrs_cb,
helper);
fwupd_client_get_bios_settings_async(self,
cancellable,
fwupd_client_get_bios_settings_cb,
helper);
g_main_loop_run(helper->loop);
if (helper->array == NULL) {
g_propagate_error(error, g_steal_pointer(&helper->error));

14
libfwupd/fwupd-client-sync.h
View File

@ -88,14 +88,14 @@ fwupd_client_get_results(FwupdClient *self,
GCancellable *cancellable,
GError **error) G_GNUC_WARN_UNUSED_RESULT;
gboolean
fwupd_client_modify_bios_attr(FwupdClient *self,
GHashTable *settings,
GCancellable *cancellable,
GError **error);
fwupd_client_modify_bios_setting(FwupdClient *self,
GHashTable *settings,
GCancellable *cancellable,
GError **error);
GPtrArray *
fwupd_client_get_bios_attrs(FwupdClient *self,
GCancellable *cancellable,
GError **error) G_GNUC_WARN_UNUSED_RESULT;
fwupd_client_get_bios_settings(FwupdClient *self,
GCancellable *cancellable,
GError **error) G_GNUC_WARN_UNUSED_RESULT;
GPtrArray *
fwupd_client_get_host_security_attrs(FwupdClient *self,
GCancellable *cancellable,

54
libfwupd/fwupd-client.c
View File

@ -20,7 +20,7 @@
#include <sys/stat.h>
#include <sys/types.h>
#include "fwupd-bios-attr-private.h"
#include "fwupd-bios-setting-private.h"
#include "fwupd-client-private.h"
#include "fwupd-client-sync.h"
#include "fwupd-common-private.h"
@ -1086,7 +1086,7 @@ fwupd_client_get_host_security_attrs_finish(FwupdClient *self, GAsyncResult *res
}
static void
fwupd_client_modify_bios_attr_cb(GObject *source, GAsyncResult *res, gpointer user_data)
fwupd_client_modify_bios_setting_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
g_autoptr(GTask) task = G_TASK(user_data);
g_autoptr(GError) error = NULL;
@ -1104,24 +1104,24 @@ fwupd_client_modify_bios_attr_cb(GObject *source, GAsyncResult *res, gpointer us
}
/**
* fwupd_client_modify_bios_attr_async:
* fwupd_client_modify_bios_setting_async:
* @self: a #FwupdClient
* @settings: (transfer container): BIOS settings
* @cancellable: (nullable): optional #GCancellable
* @callback: the function to run on completion
* @callback_data: the data to pass to @callback
*
* Modifies a BIOS attribute using kernel API.
* Modifies a BIOS setting using kernel API.
* The daemon will only respond to this request with proper permissions.
*
* Since: 1.8.4
**/
void
fwupd_client_modify_bios_attr_async(FwupdClient *self,
GHashTable *settings,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer callback_data)
fwupd_client_modify_bios_setting_async(FwupdClient *self,
GHashTable *settings,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer callback_data)
{
FwupdClientPrivate *priv = GET_PRIVATE(self);
GVariantBuilder builder;
@ -1145,29 +1145,29 @@ fwupd_client_modify_bios_attr_async(FwupdClient *self,
g_variant_builder_add(&builder, "{ss}", (const gchar *)key, (const gchar *)value);
}
g_dbus_proxy_call(priv->proxy,
"SetBiosAttrs",
"SetBiosSettings",
g_variant_new("(a{ss})", &builder),
G_DBUS_CALL_FLAGS_NONE,
FWUPD_CLIENT_DBUS_PROXY_TIMEOUT,
cancellable,
fwupd_client_modify_bios_attr_cb,
fwupd_client_modify_bios_setting_cb,
g_steal_pointer(&task));
}
/**
* fwupd_client_modify_bios_attr_finish:
* fwupd_client_modify_bios_setting_finish:
* @self: a #FwupdClient
* @res: the asynchronous result
* @error: (nullable): optional return location for an error
*
* Gets the result of [method@FwupdClient.modify_bios_attr_async].
* Gets the result of [method@FwupdClient.modify_bios_setting_async].
*
* Returns: %TRUE for success
*
* Since: 1.8.4
**/
gboolean
fwupd_client_modify_bios_attr_finish(FwupdClient *self, GAsyncResult *res, GError **error)
fwupd_client_modify_bios_setting_finish(FwupdClient *self, GAsyncResult *res, GError **error)
{
g_return_val_if_fail(FWUPD_IS_CLIENT(self), FALSE);
g_return_val_if_fail(g_task_is_valid(res, self), FALSE);
@ -1176,7 +1176,7 @@ fwupd_client_modify_bios_attr_finish(FwupdClient *self, GAsyncResult *res, GErro
}
static void
fwupd_client_get_bios_attrs_cb(GObject *source, GAsyncResult *res, gpointer user_data)
fwupd_client_get_bios_settings_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
g_autoptr(GTask) task = G_TASK(user_data);
g_autoptr(GError) error = NULL;
@ -1191,12 +1191,12 @@ fwupd_client_get_bios_attrs_cb(GObject *source, GAsyncResult *res, gpointer user
/* success */
g_task_return_pointer(task,
fwupd_bios_attr_array_from_variant(val),
fwupd_bios_setting_array_from_variant(val),
(GDestroyNotify)g_ptr_array_unref);
}
/**
* fwupd_client_get_bios_attrs_async:
* fwupd_client_get_bios_settings_async:
* @self: a #FwupdClient
* @cancellable: (nullable): optional #GCancellable
* @callback: the function to run on completion
@ -1210,10 +1210,10 @@ fwupd_client_get_bios_attrs_cb(GObject *source, GAsyncResult *res, gpointer user
* Since: 1.8.4
**/
void
fwupd_client_get_bios_attrs_async(FwupdClient *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer callback_data)
fwupd_client_get_bios_settings_async(FwupdClient *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer callback_data)
{
FwupdClientPrivate *priv = GET_PRIVATE(self);
g_autoptr(GTask) task = NULL;
@ -1225,29 +1225,29 @@ fwupd_client_get_bios_attrs_async(FwupdClient *self,
/* call into daemon */
task = g_task_new(self, cancellable, callback, callback_data);
g_dbus_proxy_call(priv->proxy,
"GetBiosAttrs",
"GetBiosSettings",
NULL,
G_DBUS_CALL_FLAGS_NONE,
FWUPD_CLIENT_DBUS_PROXY_TIMEOUT,
cancellable,
fwupd_client_get_bios_attrs_cb,
fwupd_client_get_bios_settings_cb,
g_steal_pointer(&task));
}
/**
* fwupd_client_get_bios_attrs_finish:
* fwupd_client_get_bios_settings_finish:
* @self: a #FwupdClient
* @res: the asynchronous result
* @error: (nullable): optional return location for an error
*
* Gets the result of [method@FwupdClient.get_bios_attrs_async].
* Gets the result of [method@FwupdClient.get_bios_settings_async].
*
* Returns: (element-type FwupdBiosAttr) (transfer container): attributes
* Returns: (element-type FwupdBiosSetting) (transfer container): attributes
*
* Since: 1.8.4
**/
GPtrArray *
fwupd_client_get_bios_attrs_finish(FwupdClient *self, GAsyncResult *res, GError **error)
fwupd_client_get_bios_settings_finish(FwupdClient *self, GAsyncResult *res, GError **error)
{
g_return_val_if_fail(FWUPD_IS_CLIENT(self), NULL);
g_return_val_if_fail(g_task_is_valid(res, self), NULL);

26
libfwupd/fwupd-client.h
View File

@ -220,22 +220,22 @@ fwupd_client_get_results_finish(FwupdClient *self,
GAsyncResult *res,
GError **error) G_GNUC_WARN_UNUSED_RESULT;
void
fwupd_client_modify_bios_attr_async(FwupdClient *self,
GHashTable *settings,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer callback_data);
fwupd_client_modify_bios_setting_async(FwupdClient *self,
GHashTable *settings,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer callback_data);
gboolean
fwupd_client_modify_bios_attr_finish(FwupdClient *self, GAsyncResult *res, GError **error);
fwupd_client_modify_bios_setting_finish(FwupdClient *self, GAsyncResult *res, GError **error);
void
fwupd_client_get_bios_attrs_async(FwupdClient *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer callback_data);
fwupd_client_get_bios_settings_async(FwupdClient *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer callback_data);
GPtrArray *
fwupd_client_get_bios_attrs_finish(FwupdClient *self,
GAsyncResult *res,
GError **error) G_GNUC_WARN_UNUSED_RESULT;
fwupd_client_get_bios_settings_finish(FwupdClient *self,
GAsyncResult *res,
GError **error) G_GNUC_WARN_UNUSED_RESULT;
void
fwupd_client_get_host_security_attrs_async(FwupdClient *self,
GCancellable *cancellable,

54
libfwupd/fwupd-enums-private.h
View File

@ -509,78 +509,78 @@ G_BEGIN_DECLS
**/
#define FWUPD_RESULT_KEY_BATTERY_THRESHOLD "BatteryThreshold"
/**
* FWUPD_RESULT_KEY_BIOS_ATTR_ID:
* FWUPD_RESULT_KEY_BIOS_SETTING_ID:
*
* Result key to represent the unique identifier of the BIOS attribute.
* Result key to represent the unique identifier of the BIOS setting.
*
* The D-Bus type signature string is 's' i.e. a string.
**/
#define FWUPD_RESULT_KEY_BIOS_ATTR_ID "BiosAttrId"
#define FWUPD_RESULT_KEY_BIOS_SETTING_ID "BiosSettingId"
/**
* FWUPD_RESULT_KEY_BIOS_ATTR_TARGET_VALUE:
* FWUPD_RESULT_KEY_BIOS_SETTING_TARGET_VALUE:
*
* Result key to represent the value that would enable this attribute.
*
* The D-Bus type signature string is 's' i.e. a string.
**/
#define FWUPD_RESULT_KEY_BIOS_ATTR_TARGET_VALUE "BiosAttrTargetValue"
#define FWUPD_RESULT_KEY_BIOS_SETTING_TARGET_VALUE "BiosSettingTargetValue"
/**
* FWUPD_RESULT_KEY_BIOS_ATTR_CURRENT_VALUE:
* FWUPD_RESULT_KEY_BIOS_SETTING_CURRENT_VALUE:
*
* Result key to represent the current value of BIOS attribute.
* Result key to represent the current value of BIOS setting.
*
* The D-Bus type signature string is 's' i.e. a string.
**/
#define FWUPD_RESULT_KEY_BIOS_ATTR_CURRENT_VALUE "BiosAttrCurrentValue"
#define FWUPD_RESULT_KEY_BIOS_SETTING_CURRENT_VALUE "BiosSettingCurrentValue"
/**
* FWUPD_RESULT_KEY_BIOS_ATTR_TYPE:
* FWUPD_RESULT_KEY_BIOS_SETTING_TYPE:
*
* Result key to represent the type of BIOS attribute.
* Result key to represent the type of BIOS setting.
* 0 is invalid, 1+ represent an attribute type
*
* The D-Bus type signature string is 't' i.e. a unsigned 64 bit integer.
**/
#define FWUPD_RESULT_KEY_BIOS_ATTR_TYPE "BiosAttrType"
#define FWUPD_RESULT_KEY_BIOS_SETTING_TYPE "BiosSettingType"
/**
* FWUPD_RESULT_KEY_BIOS_ATTR_POSSIBLE_VALUES:
* FWUPD_RESULT_KEY_BIOS_SETTING_POSSIBLE_VALUES:
*
* Result key to represent possible values
*
* The D-Bus type signature string is 'as' i.e. an array of strings.
**/
#define FWUPD_RESULT_KEY_BIOS_ATTR_POSSIBLE_VALUES "BiosAttrPossibleValues"
#define FWUPD_RESULT_KEY_BIOS_SETTING_POSSIBLE_VALUES "BiosSettingPossibleValues"
/**
* FWUPD_RESULT_KEY_BIOS_ATTR_LOWER_BOUND:
* FWUPD_RESULT_KEY_BIOS_SETTING_LOWER_BOUND:
*
* Result key to represent the upper bound for an integer BIOS attribute.
* or minimum length for string BIOS attribute.
* Result key to represent the upper bound for an integer BIOS setting.
* or minimum length for string BIOS setting.
* The D-Bus type signature string is 't' i.e. a unsigned 64 bit integer.
**/
#define FWUPD_RESULT_KEY_BIOS_ATTR_LOWER_BOUND "BiosAttrLowerBound"
#define FWUPD_RESULT_KEY_BIOS_SETTING_LOWER_BOUND "BiosSettingLowerBound"
/**
* FWUPD_RESULT_KEY_BIOS_ATTR_UPPER_BOUND:
* FWUPD_RESULT_KEY_BIOS_SETTING_UPPER_BOUND:
*
* Result key to represent the lower bound for an integer BIOS attribute
* or maximum length for string BIOS attribute.
* Result key to represent the lower bound for an integer BIOS setting
* or maximum length for string BIOS setting.
*
* The D-Bus type signature string is 't' i.e. a unsigned 64 bit integer.
**/
#define FWUPD_RESULT_KEY_BIOS_ATTR_UPPER_BOUND "BiosAttrUpperBound"
#define FWUPD_RESULT_KEY_BIOS_SETTING_UPPER_BOUND "BiosSettingUpperBound"
/**
* FWUPD_RESULT_KEY_BIOS_ATTR_SCALAR_INCREMENT:
* FWUPD_RESULT_KEY_BIOS_SETTING_SCALAR_INCREMENT:
*
* Result key to represent the scalar increment for an integer BIOS attribute.
* Result key to represent the scalar increment for an integer BIOS setting.
*
* The D-Bus type signature string is 't' i.e. a unsigned 64 bit integer.
**/
#define FWUPD_RESULT_KEY_BIOS_ATTR_SCALAR_INCREMENT "BiosAttrScalarIncrement"
#define FWUPD_RESULT_KEY_BIOS_SETTING_SCALAR_INCREMENT "BiosSettingScalarIncrement"
/**
* FWUPD_RESULT_KEY_BIOS_ATTR_READ_ONLY:
* FWUPD_RESULT_KEY_BIOS_SETTING_READ_ONLY:
*
* Result key to represent whether BIOS attribute is read only
* Result key to represent whether BIOS setting is read only
*
* The D-Bus type signature string is 'b' i.e. a boolean.
**/
#define FWUPD_RESULT_KEY_BIOS_ATTR_READ_ONLY "BiosAttrReadOnly"
#define FWUPD_RESULT_KEY_BIOS_SETTING_READ_ONLY "BiosSettingReadOnly"
G_END_DECLS

148
libfwupd/fwupd-security-attr.c
View File

@ -38,9 +38,9 @@ typedef struct {
FwupdSecurityAttrResult result;
FwupdSecurityAttrResult result_fallback;
FwupdSecurityAttrFlags flags;
gchar *bios_attr_id;
gchar *bios_attr_target_value;
gchar *bios_attr_current_value;
gchar *bios_setting_id;
gchar *bios_setting_target_value;
gchar *bios_setting_current_value;
} FwupdSecurityAttrPrivate;
G_DEFINE_TYPE_WITH_PRIVATE(FwupdSecurityAttr, fwupd_security_attr, G_TYPE_OBJECT)
@ -227,43 +227,43 @@ fwupd_security_attr_flag_to_suffix(FwupdSecurityAttrFlags flag)
}
/**
* fwupd_security_attr_get_bios_attr_id:
* fwupd_security_attr_get_bios_setting_id:
* @self: a #FwupdSecurityAttr
*
* Gets the #FwupdBiosAttr that can be used to improve this
* Gets the #FwupdBiosSetting that can be used to improve this
* #FwupdSecurityAttr.
*
* Returns: The unique ID used for #FwupdBiosAttr or NULL
* Returns: The unique ID used for #FwupdBiosSetting or NULL
*
* Since: 1.8.4
**/
const gchar *
fwupd_security_attr_get_bios_attr_id(FwupdSecurityAttr *self)
fwupd_security_attr_get_bios_setting_id(FwupdSecurityAttr *self)
{
FwupdSecurityAttrPrivate *priv = GET_PRIVATE(self);
g_return_val_if_fail(FWUPD_IS_SECURITY_ATTR(self), NULL);
return priv->bios_attr_id;
return priv->bios_setting_id;
}
/**
* fwupd_security_attr_set_bios_attr_id:
* fwupd_security_attr_set_bios_setting_id:
* @self: a #FwupdSecurityAttr
* @id: Unique identifier used for #FwupdBiosAttr
* @id: Unique identifier used for #FwupdBiosSetting
*
* Sets the #FwupdBiosAttr that can be used to improve this
* Sets the #FwupdBiosSetting that can be used to improve this
* #FwupdSecurityAttr.
*
* Since: 1.8.4
**/
void
fwupd_security_attr_set_bios_attr_id(FwupdSecurityAttr *self, const gchar *id)
fwupd_security_attr_set_bios_setting_id(FwupdSecurityAttr *self, const gchar *id)
{
FwupdSecurityAttrPrivate *priv = GET_PRIVATE(self);
g_return_if_fail(FWUPD_IS_SECURITY_ATTR(self));
if (priv->bios_attr_id == id)
if (priv->bios_setting_id == id)
return;
g_free(priv->bios_attr_id);
priv->bios_attr_id = g_strdup(id);
g_free(priv->bios_setting_id);
priv->bios_setting_id = g_strdup(id);
}
/**
@ -503,7 +503,7 @@ fwupd_security_attr_set_name(FwupdSecurityAttr *self, const gchar *name)
}
/**
* fwupd_security_attr_get_bios_attr_target_value:
* fwupd_security_attr_get_bios_setting_target_value:
* @self: a #FwupdSecurityAttr
*
* Gets the value that when written to an attribute would activate it or satisfy
@ -514,15 +514,15 @@ fwupd_security_attr_set_name(FwupdSecurityAttr *self, const gchar *name)
* Since: 1.8.4
**/
const gchar *
fwupd_security_attr_get_bios_attr_target_value(FwupdSecurityAttr *self)
fwupd_security_attr_get_bios_setting_target_value(FwupdSecurityAttr *self)
{
FwupdSecurityAttrPrivate *priv = GET_PRIVATE(self);
g_return_val_if_fail(FWUPD_IS_SECURITY_ATTR(self), NULL);
return priv->bios_attr_target_value;
return priv->bios_setting_target_value;
}
/**
* fwupd_security_attr_set_bios_attr_target_value:
* fwupd_security_attr_set_bios_setting_target_value:
* @self: a #FwupdSecurityAttr
* @value: The string to set target value to
*
@ -531,56 +531,56 @@ fwupd_security_attr_get_bios_attr_target_value(FwupdSecurityAttr *self)
* Since: 1.8.4
**/
void
fwupd_security_attr_set_bios_attr_target_value(FwupdSecurityAttr *self, const gchar *value)
fwupd_security_attr_set_bios_setting_target_value(FwupdSecurityAttr *self, const gchar *value)
{
FwupdSecurityAttrPrivate *priv = GET_PRIVATE(self);
/* not changed */
if (g_strcmp0(priv->bios_attr_target_value, value) == 0)
if (g_strcmp0(priv->bios_setting_target_value, value) == 0)
return;
g_free(priv->bios_attr_target_value);
priv->bios_attr_target_value = g_strdup(value);
g_free(priv->bios_setting_target_value);
priv->bios_setting_target_value = g_strdup(value);
}
/**
* fwupd_security_attr_get_bios_attr_current_value:
* fwupd_security_attr_get_bios_setting_current_value:
* @self: a #FwupdSecurityAttr
*
* Gets the current value of the BIOS attribute that can be changed.
* Gets the current value of the BIOS setting that can be changed.
*
* Returns: the current value of the attribute.
*
* Since: 1.8.4
**/
const gchar *
fwupd_security_attr_get_bios_attr_current_value(FwupdSecurityAttr *self)
fwupd_security_attr_get_bios_setting_current_value(FwupdSecurityAttr *self)
{
FwupdSecurityAttrPrivate *priv = GET_PRIVATE(self);
g_return_val_if_fail(FWUPD_IS_SECURITY_ATTR(self), NULL);
return priv->bios_attr_current_value;
return priv->bios_setting_current_value;
}
/**
* fwupd_security_attr_set_bios_attr_current_value:
* fwupd_security_attr_set_bios_setting_current_value:
* @self: a #FwupdSecurityAttr
* @value: The string to set current value to
*
* Sets the current value of the BIOS attribute that can be changed.
* Sets the current value of the BIOS setting that can be changed.
*
* Since: 1.8.4
**/
void
fwupd_security_attr_set_bios_attr_current_value(FwupdSecurityAttr *self, const gchar *value)
fwupd_security_attr_set_bios_setting_current_value(FwupdSecurityAttr *self, const gchar *value)
{
FwupdSecurityAttrPrivate *priv = GET_PRIVATE(self);
/* not changed */
if (g_strcmp0(priv->bios_attr_current_value, value) == 0)
if (g_strcmp0(priv->bios_setting_current_value, value) == 0)
return;
g_free(priv->bios_attr_current_value);
priv->bios_attr_current_value = g_strdup(value);
g_free(priv->bios_setting_current_value);
priv->bios_setting_current_value = g_strdup(value);
}
/**
@ -1096,23 +1096,23 @@ fwupd_security_attr_to_variant(FwupdSecurityAttr *self)
FWUPD_RESULT_KEY_METADATA,
fwupd_hash_kv_to_variant(priv->metadata));
}
if (priv->bios_attr_id != NULL) {
if (priv->bios_setting_id != NULL) {
g_variant_builder_add(&builder,
"{sv}",
FWUPD_RESULT_KEY_BIOS_ATTR_ID,
g_variant_new_string(priv->bios_attr_id));
FWUPD_RESULT_KEY_BIOS_SETTING_ID,
g_variant_new_string(priv->bios_setting_id));
}
if (priv->bios_attr_target_value != NULL) {
if (priv->bios_setting_target_value != NULL) {
g_variant_builder_add(&builder,
"{sv}",
FWUPD_RESULT_KEY_BIOS_ATTR_TARGET_VALUE,
g_variant_new_string(priv->bios_attr_target_value));
FWUPD_RESULT_KEY_BIOS_SETTING_TARGET_VALUE,
g_variant_new_string(priv->bios_setting_target_value));
}
if (priv->bios_attr_current_value != NULL) {
if (priv->bios_setting_current_value != NULL) {
g_variant_builder_add(&builder,
"{sv}",
FWUPD_RESULT_KEY_BIOS_ATTR_CURRENT_VALUE,
g_variant_new_string(priv->bios_attr_current_value));
FWUPD_RESULT_KEY_BIOS_SETTING_CURRENT_VALUE,
g_variant_new_string(priv->bios_setting_current_value));
}
return g_variant_new("a{sv}", &builder);
}
@ -1226,18 +1226,20 @@ fwupd_security_attr_from_key_value(FwupdSecurityAttr *self, const gchar *key, GV
priv->metadata = fwupd_variant_to_hash_kv(value);
return;
}
if (g_strcmp0(key, FWUPD_RESULT_KEY_BIOS_ATTR_ID) == 0) {
fwupd_security_attr_set_bios_attr_id(self, g_variant_get_string(value, NULL));
if (g_strcmp0(key, FWUPD_RESULT_KEY_BIOS_SETTING_ID) == 0) {
fwupd_security_attr_set_bios_setting_id(self, g_variant_get_string(value, NULL));
return;
}
if (g_strcmp0(key, FWUPD_RESULT_KEY_BIOS_ATTR_TARGET_VALUE) == 0) {
fwupd_security_attr_set_bios_attr_target_value(self,
g_variant_get_string(value, NULL));
if (g_strcmp0(key, FWUPD_RESULT_KEY_BIOS_SETTING_TARGET_VALUE) == 0) {
fwupd_security_attr_set_bios_setting_target_value(
self,
g_variant_get_string(value, NULL));
return;
}
if (g_strcmp0(key, FWUPD_RESULT_KEY_BIOS_ATTR_CURRENT_VALUE) == 0) {
fwupd_security_attr_set_bios_attr_current_value(self,
g_variant_get_string(value, NULL));
if (g_strcmp0(key, FWUPD_RESULT_KEY_BIOS_SETTING_CURRENT_VALUE) == 0) {
fwupd_security_attr_set_bios_setting_current_value(
self,
g_variant_get_string(value, NULL));
return;
}
}
@ -1321,18 +1323,20 @@ fwupd_security_attr_from_json(FwupdSecurityAttr *self, JsonNode *json_node, GErr
fwupd_security_attr_set_created(
self,
json_object_get_int_member_with_default(obj, FWUPD_RESULT_KEY_CREATED, 0));
fwupd_security_attr_set_bios_attr_id(
self,
json_object_get_string_member_with_default(obj, FWUPD_RESULT_KEY_BIOS_ATTR_ID, NULL));
fwupd_security_attr_set_bios_attr_target_value(
fwupd_security_attr_set_bios_setting_id(
self,
json_object_get_string_member_with_default(obj,
FWUPD_RESULT_KEY_BIOS_ATTR_TARGET_VALUE,
FWUPD_RESULT_KEY_BIOS_SETTING_ID,
NULL));
fwupd_security_attr_set_bios_attr_current_value(
fwupd_security_attr_set_bios_setting_target_value(
self,
json_object_get_string_member_with_default(obj,
FWUPD_RESULT_KEY_BIOS_ATTR_CURRENT_VALUE,
FWUPD_RESULT_KEY_BIOS_SETTING_TARGET_VALUE,
NULL));
fwupd_security_attr_set_bios_setting_current_value(
self,
json_object_get_string_member_with_default(obj,
FWUPD_RESULT_KEY_BIOS_SETTING_CURRENT_VALUE,
NULL));
/* also optional */
@ -1413,12 +1417,14 @@ fwupd_security_attr_to_json(FwupdSecurityAttr *self, JsonBuilder *builder)
fwupd_common_json_add_string(builder, FWUPD_RESULT_KEY_PLUGIN, priv->plugin);
fwupd_common_json_add_string(builder, FWUPD_RESULT_KEY_URI, priv->url);
fwupd_common_json_add_string(builder,
FWUPD_RESULT_KEY_BIOS_ATTR_TARGET_VALUE,
priv->bios_attr_target_value);
FWUPD_RESULT_KEY_BIOS_SETTING_TARGET_VALUE,
priv->bios_setting_target_value);
fwupd_common_json_add_string(builder,
FWUPD_RESULT_KEY_BIOS_ATTR_CURRENT_VALUE,
priv->bios_attr_current_value);
fwupd_common_json_add_string(builder, FWUPD_RESULT_KEY_BIOS_ATTR_ID, priv->bios_attr_id);
FWUPD_RESULT_KEY_BIOS_SETTING_CURRENT_VALUE,
priv->bios_setting_current_value);
fwupd_common_json_add_string(builder,
FWUPD_RESULT_KEY_BIOS_SETTING_ID,
priv->bios_setting_id);
if (priv->flags != FWUPD_SECURITY_ATTR_FLAG_NONE) {
json_builder_set_member_name(builder, FWUPD_RESULT_KEY_FLAGS);
@ -1487,13 +1493,13 @@ fwupd_security_attr_to_string(FwupdSecurityAttr *self)
fwupd_pad_kv_str(str, FWUPD_RESULT_KEY_DESCRIPTION, priv->description);
fwupd_pad_kv_str(str, FWUPD_RESULT_KEY_PLUGIN, priv->plugin);
fwupd_pad_kv_str(str, FWUPD_RESULT_KEY_URI, priv->url);
fwupd_pad_kv_str(str, FWUPD_RESULT_KEY_BIOS_ATTR_ID, priv->bios_attr_id);
fwupd_pad_kv_str(str, FWUPD_RESULT_KEY_BIOS_SETTING_ID, priv->bios_setting_id);
fwupd_pad_kv_str(str,
FWUPD_RESULT_KEY_BIOS_ATTR_TARGET_VALUE,
priv->bios_attr_target_value);
FWUPD_RESULT_KEY_BIOS_SETTING_TARGET_VALUE,
priv->bios_setting_target_value);
fwupd_pad_kv_str(str,
FWUPD_RESULT_KEY_BIOS_ATTR_CURRENT_VALUE,
priv->bios_attr_current_value);
FWUPD_RESULT_KEY_BIOS_SETTING_CURRENT_VALUE,
priv->bios_setting_current_value);
for (guint i = 0; i < priv->obsoletes->len; i++) {
const gchar *appstream_id = g_ptr_array_index(priv->obsoletes, i);
@ -1540,9 +1546,9 @@ fwupd_security_attr_finalize(GObject *object)
if (priv->metadata != NULL)
g_hash_table_unref(priv->metadata);
g_free(priv->bios_attr_id);
g_free(priv->bios_attr_target_value);
g_free(priv->bios_attr_current_value);
g_free(priv->bios_setting_id);
g_free(priv->bios_setting_target_value);
g_free(priv->bios_setting_current_value);
g_free(priv->appstream_id);
g_free(priv->name);
g_free(priv->title);
@ -1661,7 +1667,7 @@ fwupd_security_attr_copy(FwupdSecurityAttr *self)
fwupd_security_attr_set_flags(new, priv->flags);
fwupd_security_attr_set_result(new, priv->result);
fwupd_security_attr_set_created(new, priv->created);
fwupd_security_attr_set_bios_attr_id(new, priv->bios_attr_id);
fwupd_security_attr_set_bios_setting_id(new, priv->bios_setting_id);
for (guint i = 0; i < priv->guids->len; i++) {
const gchar *guid = g_ptr_array_index(priv->guids, i);

12
libfwupd/fwupd-security-attr.h
View File

@ -127,17 +127,17 @@ gchar *
fwupd_security_attr_to_string(FwupdSecurityAttr *self);
const gchar *
fwupd_security_attr_get_bios_attr_id(FwupdSecurityAttr *self);
fwupd_security_attr_get_bios_setting_id(FwupdSecurityAttr *self);
void
fwupd_security_attr_set_bios_attr_id(FwupdSecurityAttr *self, const gchar *id);
fwupd_security_attr_set_bios_setting_id(FwupdSecurityAttr *self, const gchar *id);
const gchar *
fwupd_security_attr_get_bios_attr_target_value(FwupdSecurityAttr *self);
fwupd_security_attr_get_bios_setting_target_value(FwupdSecurityAttr *self);
void
fwupd_security_attr_set_bios_attr_target_value(FwupdSecurityAttr *self, const gchar *value);
fwupd_security_attr_set_bios_setting_target_value(FwupdSecurityAttr *self, const gchar *value);
const gchar *
fwupd_security_attr_get_bios_attr_current_value(FwupdSecurityAttr *self);
fwupd_security_attr_get_bios_setting_current_value(FwupdSecurityAttr *self);
void
fwupd_security_attr_set_bios_attr_current_value(FwupdSecurityAttr *self, const gchar *value);
fwupd_security_attr_set_bios_setting_current_value(FwupdSecurityAttr *self, const gchar *value);
const gchar *
fwupd_security_attr_get_appstream_id(FwupdSecurityAttr *self);

90
libfwupd/fwupd-self-test.c
View File

@ -12,7 +12,7 @@
#include <fnmatch.h>
#endif
#include "fwupd-bios-attr-private.h"
#include "fwupd-bios-setting-private.h"
#include "fwupd-client-sync.h"
#include "fwupd-client.h"
#include "fwupd-common.h"
@ -1218,8 +1218,8 @@ fwupd_attr_to_json_string(GObject *attr, GError **error)
json_builder_begin_object(builder);
if (FWUPD_IS_SECURITY_ATTR(attr))
fwupd_security_attr_to_json(FWUPD_SECURITY_ATTR(attr), builder);
else if (FWUPD_IS_BIOS_ATTR(attr))
fwupd_bios_attr_to_json(FWUPD_BIOS_ATTR(attr), builder);
else if (FWUPD_IS_BIOS_SETTING(attr))
fwupd_bios_setting_to_json(FWUPD_BIOS_SETTING(attr), builder);
json_builder_end_object(builder);
json_root = json_builder_get_root(builder);
json_generator = json_generator_new();
@ -1377,7 +1377,7 @@ fwupd_security_attr_func(void)
}
static void
fwupd_bios_attrs_func(void)
fwupd_bios_settings_func(void)
{
gboolean ret;
g_autofree gchar *str1 = NULL;
@ -1385,57 +1385,59 @@ fwupd_bios_attrs_func(void)
g_autofree gchar *str3 = NULL;
g_autofree gchar *json1 = NULL;
g_autofree gchar *json2 = NULL;
g_autoptr(FwupdBiosAttr) attr1 = fwupd_bios_attr_new("foo", "/path/to/bar");
g_autoptr(FwupdBiosAttr) attr2 = NULL;
g_autoptr(FwupdBiosSetting) attr1 = fwupd_bios_setting_new("foo", "/path/to/bar");
g_autoptr(FwupdBiosSetting) attr2 = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GVariant) data1 = NULL;
g_autoptr(GVariant) data2 = NULL;
g_autoptr(JsonParser) parser = json_parser_new();
g_assert_cmpstr(fwupd_bios_attr_get_name(attr1), ==, "foo");
fwupd_bios_attr_set_name(attr1, "UEFISecureBoot");
g_assert_cmpstr(fwupd_bios_attr_get_name(attr1), ==, "UEFISecureBoot");
g_assert_cmpstr(fwupd_bios_setting_get_name(attr1), ==, "foo");
fwupd_bios_setting_set_name(attr1, "UEFISecureBoot");
g_assert_cmpstr(fwupd_bios_setting_get_name(attr1), ==, "UEFISecureBoot");
fwupd_bios_attr_set_kind(attr1, FWUPD_BIOS_ATTR_KIND_ENUMERATION);
g_assert_cmpint(fwupd_bios_attr_get_kind(attr1), ==, FWUPD_BIOS_ATTR_KIND_ENUMERATION);
fwupd_bios_setting_set_kind(attr1, FWUPD_BIOS_SETTING_KIND_ENUMERATION);
g_assert_cmpint(fwupd_bios_setting_get_kind(attr1),
==,
FWUPD_BIOS_SETTING_KIND_ENUMERATION);
fwupd_bios_attr_set_description(attr1, "Controls Secure boot");
g_assert_cmpstr(fwupd_bios_attr_get_description(attr1), ==, "Controls Secure boot");
fwupd_bios_attr_set_current_value(attr1, "Disabled");
g_assert_cmpstr(fwupd_bios_attr_get_current_value(attr1), ==, "Disabled");
fwupd_bios_setting_set_description(attr1, "Controls Secure boot");
g_assert_cmpstr(fwupd_bios_setting_get_description(attr1), ==, "Controls Secure boot");
fwupd_bios_setting_set_current_value(attr1, "Disabled");
g_assert_cmpstr(fwupd_bios_setting_get_current_value(attr1), ==, "Disabled");
fwupd_bios_attr_add_possible_value(attr1, "Disabled");
fwupd_bios_attr_add_possible_value(attr1, "Enabled");
g_assert_true(fwupd_bios_attr_has_possible_value(attr1, "Disabled"));
g_assert_false(fwupd_bios_attr_has_possible_value(attr1, "NOT_GOING_TO_EXIST"));
fwupd_bios_setting_add_possible_value(attr1, "Disabled");
fwupd_bios_setting_add_possible_value(attr1, "Enabled");
g_assert_true(fwupd_bios_setting_has_possible_value(attr1, "Disabled"));
g_assert_false(fwupd_bios_setting_has_possible_value(attr1, "NOT_GOING_TO_EXIST"));
str1 = fwupd_bios_attr_to_string(attr1);
str1 = fwupd_bios_setting_to_string(attr1);
ret = fu_test_compare_lines(str1,
" Name: UEFISecureBoot\n"
" Description: Controls Secure boot\n"
" Filename: /path/to/bar\n"
" BiosAttrType: 1\n"
" BiosAttrCurrentValue: Disabled\n"
" BiosAttrReadOnly: False\n"
" BiosAttrPossibleValues: Disabled\n"
" BiosAttrPossibleValues: Enabled\n",
" BiosSettingType: 1\n"
" BiosSettingCurrentValue: Disabled\n"
" BiosSettingReadOnly: False\n"
" BiosSettingPossibleValues: Disabled\n"
" BiosSettingPossibleValues: Enabled\n",
&error);
g_assert_no_error(error);
g_assert_true(ret);
/* roundtrip GVariant */
data1 = fwupd_bios_attr_to_variant(attr1, TRUE);
attr2 = fwupd_bios_attr_from_variant(data1);
str2 = fwupd_bios_attr_to_string(attr2);
data1 = fwupd_bios_setting_to_variant(attr1, TRUE);
attr2 = fwupd_bios_setting_from_variant(data1);
str2 = fwupd_bios_setting_to_string(attr2);
ret = fu_test_compare_lines(str2,
" Name: UEFISecureBoot\n"
" Description: Controls Secure boot\n"
" Filename: /path/to/bar\n"
" BiosAttrType: 1\n"
" BiosAttrCurrentValue: Disabled\n"
" BiosAttrReadOnly: False\n"
" BiosAttrPossibleValues: Disabled\n"
" BiosAttrPossibleValues: Enabled\n",
" BiosSettingType: 1\n"
" BiosSettingCurrentValue: Disabled\n"
" BiosSettingReadOnly: False\n"
" BiosSettingPossibleValues: Disabled\n"
" BiosSettingPossibleValues: Enabled\n",
&error);
g_assert_no_error(error);
g_assert_true(ret);
@ -1446,13 +1448,13 @@ fwupd_bios_attrs_func(void)
g_assert_nonnull(json1);
ret = fu_test_compare_lines(json1,
"{\n"
" \"BiosAttrReadOnly\" : \"false\",\n"
" \"BiosAttrType\" : 1,\n"
" \"BiosSettingReadOnly\" : \"false\",\n"
" \"BiosSettingType\" : 1,\n"
" \"Name\" : \"UEFISecureBoot\",\n"
" \"Description\" : \"Controls Secure boot\",\n"
" \"Filename\" : \"/path/to/bar\",\n"
" \"BiosAttrCurrentValue\" : \"Disabled\",\n"
" \"BiosAttrPossibleValues\" : [\n"
" \"BiosSettingCurrentValue\" : \"Disabled\",\n"
" \"BiosSettingPossibleValues\" : [\n"
" \"Disabled\",\n"
" \"Enabled\"\n"
" ]\n"
@ -1465,7 +1467,7 @@ fwupd_bios_attrs_func(void)
ret = json_parser_load_from_data(parser, json1, -1, &error);
g_assert_no_error(error);
g_assert_true(ret);
ret = fwupd_bios_attr_from_json(attr2, json_parser_get_root(parser), &error);
ret = fwupd_bios_setting_from_json(attr2, json_parser_get_root(parser), &error);
if (g_error_matches(error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED)) {
g_test_skip(error->message);
return;
@ -1473,24 +1475,24 @@ fwupd_bios_attrs_func(void)
g_assert_no_error(error);
g_assert_true(ret);
str3 = fwupd_bios_attr_to_string(attr2);
str3 = fwupd_bios_setting_to_string(attr2);
ret = fu_test_compare_lines(str3, str1, &error);
g_assert_no_error(error);
g_assert_true(ret);
/* make sure we filter CurrentValue if not trusted */
data2 = fwupd_bios_attr_to_variant(attr1, TRUE);
data2 = fwupd_bios_setting_to_variant(attr1, TRUE);
json2 = fwupd_attr_to_json_string(G_OBJECT(attr1), &error);
g_assert_no_error(error);
g_assert_nonnull(json2);
ret = fu_test_compare_lines(json2,
"{\n"
" \"BiosAttrReadOnly\" : \"false\",\n"
" \"BiosAttrType\" : 1,\n"
" \"BiosSettingReadOnly\" : \"false\",\n"
" \"BiosSettingType\" : 1,\n"
" \"Name\" : \"UEFISecureBoot\",\n"
" \"Description\" : \"Controls Secure boot\",\n"
" \"Filename\" : \"/path/to/bar\",\n"
" \"BiosAttrPossibleValues\" : [\n"
" \"BiosSettingPossibleValues\" : [\n"
" \"Disabled\",\n"
" \"Enabled\"\n"
" ]\n"
@ -1524,7 +1526,7 @@ main(int argc, char **argv)
g_test_add_func("/fwupd/remote{local}", fwupd_remote_local_func);
g_test_add_func("/fwupd/remote{duplicate}", fwupd_remote_duplicate_func);
g_test_add_func("/fwupd/remote{auth}", fwupd_remote_auth_func);
g_test_add_func("/fwupd/bios-attrs", fwupd_bios_attrs_func);
g_test_add_func("/fwupd/bios-attrs", fwupd_bios_settings_func);
if (fwupd_has_system_bus()) {
g_test_add_func("/fwupd/client{remotes}", fwupd_client_remotes_func);
g_test_add_func("/fwupd/client{devices}", fwupd_client_devices_func);

2
libfwupd/fwupd.h
View File

@ -8,7 +8,7 @@
#define __FWUPD_H_INSIDE__
#include <libfwupd/fwupd-bios-attr.h>
#include <libfwupd/fwupd-bios-setting.h>
#include <libfwupd/fwupd-client-sync.h>
#include <libfwupd/fwupd-client.h>
#include <libfwupd/fwupd-common.h>

88
libfwupd/fwupd.map
View File

@ -803,49 +803,49 @@ LIBFWUPD_1.8.3 {
LIBFWUPD_1.8.4 {
global:
fwupd_bios_attr_add_possible_value;
fwupd_bios_attr_array_from_variant;
fwupd_bios_attr_from_json;
fwupd_bios_attr_from_variant;
fwupd_bios_attr_get_current_value;
fwupd_bios_attr_get_description;
fwupd_bios_attr_get_id;
fwupd_bios_attr_get_kind;
fwupd_bios_attr_get_lower_bound;
fwupd_bios_attr_get_name;
fwupd_bios_attr_get_path;
fwupd_bios_attr_get_possible_values;
fwupd_bios_attr_get_read_only;
fwupd_bios_attr_get_scalar_increment;
fwupd_bios_attr_get_type;
fwupd_bios_attr_get_upper_bound;
fwupd_bios_attr_has_possible_value;
fwupd_bios_attr_map_possible_value;
fwupd_bios_attr_new;
fwupd_bios_attr_set_current_value;
fwupd_bios_attr_set_description;
fwupd_bios_attr_set_id;
fwupd_bios_attr_set_kind;
fwupd_bios_attr_set_lower_bound;
fwupd_bios_attr_set_name;
fwupd_bios_attr_set_path;
fwupd_bios_attr_set_read_only;
fwupd_bios_attr_set_scalar_increment;
fwupd_bios_attr_set_upper_bound;
fwupd_bios_attr_to_json;
fwupd_bios_attr_to_string;
fwupd_bios_attr_to_variant;
fwupd_client_get_bios_attrs;
fwupd_client_get_bios_attrs_async;
fwupd_client_get_bios_attrs_finish;
fwupd_client_modify_bios_attr;
fwupd_client_modify_bios_attr_async;
fwupd_client_modify_bios_attr_finish;
fwupd_security_attr_get_bios_attr_current_value;
fwupd_security_attr_get_bios_attr_id;
fwupd_security_attr_get_bios_attr_target_value;
fwupd_security_attr_set_bios_attr_current_value;
fwupd_security_attr_set_bios_attr_id;
fwupd_security_attr_set_bios_attr_target_value;
fwupd_bios_setting_add_possible_value;
fwupd_bios_setting_array_from_variant;
fwupd_bios_setting_from_json;
fwupd_bios_setting_from_variant;
fwupd_bios_setting_get_current_value;
fwupd_bios_setting_get_description;
fwupd_bios_setting_get_id;
fwupd_bios_setting_get_kind;
fwupd_bios_setting_get_lower_bound;
fwupd_bios_setting_get_name;
fwupd_bios_setting_get_path;
fwupd_bios_setting_get_possible_values;
fwupd_bios_setting_get_read_only;
fwupd_bios_setting_get_scalar_increment;
fwupd_bios_setting_get_type;
fwupd_bios_setting_get_upper_bound;
fwupd_bios_setting_has_possible_value;
fwupd_bios_setting_map_possible_value;
fwupd_bios_setting_new;
fwupd_bios_setting_set_current_value;
fwupd_bios_setting_set_description;
fwupd_bios_setting_set_id;
fwupd_bios_setting_set_kind;
fwupd_bios_setting_set_lower_bound;
fwupd_bios_setting_set_name;
fwupd_bios_setting_set_path;
fwupd_bios_setting_set_read_only;
fwupd_bios_setting_set_scalar_increment;
fwupd_bios_setting_set_upper_bound;
fwupd_bios_setting_to_json;
fwupd_bios_setting_to_string;
fwupd_bios_setting_to_variant;
fwupd_client_get_bios_settings;
fwupd_client_get_bios_settings_async;
fwupd_client_get_bios_settings_finish;
fwupd_client_modify_bios_setting;
fwupd_client_modify_bios_setting_async;
fwupd_client_modify_bios_setting_finish;
fwupd_security_attr_get_bios_setting_current_value;
fwupd_security_attr_get_bios_setting_id;
fwupd_security_attr_get_bios_setting_target_value;
fwupd_security_attr_set_bios_setting_current_value;
fwupd_security_attr_set_bios_setting_id;
fwupd_security_attr_set_bios_setting_target_value;
local: *;
} LIBFWUPD_1.8.3;

10
libfwupd/meson.build
View File

@ -23,7 +23,7 @@ install_headers([
'fwupd-error.h',
'fwupd-remote.h',
'fwupd-request.h',
'fwupd-bios-attr.h',
'fwupd-bios-setting.h',
'fwupd-security-attr.h',
'fwupd-release.h',
'fwupd-plugin.h',
@ -47,7 +47,7 @@ libfwupd_src = [
'fwupd-device.c', # fuzzing
'fwupd-enums.c', # fuzzing
'fwupd-error.c', # fuzzing
'fwupd-bios-attr.c', # fuzzing
'fwupd-bios-setting.c', # fuzzing
'fwupd-security-attr.c', # fuzzing
'fwupd-release.c', # fuzzing
'fwupd-plugin.c',
@ -113,9 +113,9 @@ if introspection.allowed()
'fwupd-enums-private.h',
'fwupd-error.c',
'fwupd-error.h',
'fwupd-bios-attr.c',
'fwupd-bios-attr.h',
'fwupd-bios-attr-private.h',
'fwupd-bios-setting.c',
'fwupd-bios-setting.h',
'fwupd-bios-setting-private.h',
'fwupd-security-attr.c',
'fwupd-security-attr.h',
'fwupd-security-attr-private.h',

22
libfwupdplugin/fu-bios-attrs-private.h
View File

@ -1,22 +0,0 @@
/*
* Copyright (C) 2022 Mario Limonciello <mario.limonciello@amd.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <json-glib/json-glib.h>
#include "fu-bios-attrs.h"
gboolean
fu_bios_attrs_setup(FuBiosAttrs *self, GError **error);
GPtrArray *
fu_bios_attrs_get_all(FuBiosAttrs *self);
GVariant *
fu_bios_attrs_to_variant(FuBiosAttrs *self, gboolean trusted);
gboolean
fu_bios_attrs_from_json(FuBiosAttrs *self, JsonNode *json_node, GError **error);

20
libfwupdplugin/fu-bios-attrs.h
View File

@ -1,20 +0,0 @@
/*
* Copyright (C) 2022 Mario Limonciello <mario.limonciello@amd.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <libfwupd/fwupd-bios-attr.h>
#define FU_TYPE_FIRMWARE_ATTRS (fu_bios_attrs_get_type())
G_DECLARE_FINAL_TYPE(FuBiosAttrs, fu_bios_attrs, FU, BIOS_ATTRS, GObject)
FuBiosAttrs *
fu_bios_attrs_new(void);
gboolean
fu_bios_attrs_get_pending_reboot(FuBiosAttrs *self, gboolean *result, GError **error);
FwupdBiosAttr *
fu_bios_attrs_get_attr(FuBiosAttrs *self, const gchar *val);

22
libfwupdplugin/fu-bios-settings-private.h Normal file
View File

@ -0,0 +1,22 @@
/*
* Copyright (C) 2022 Mario Limonciello <mario.limonciello@amd.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <json-glib/json-glib.h>
#include "fu-bios-settings.h"
gboolean
fu_bios_settings_setup(FuBiosSettings *self, GError **error);
GPtrArray *
fu_bios_settings_get_all(FuBiosSettings *self);
GVariant *
fu_bios_settings_to_variant(FuBiosSettings *self, gboolean trusted);
gboolean
fu_bios_settings_from_json(FuBiosSettings *self, JsonNode *json_node, GError **error);

276
libfwupdplugin/fu-bios-attrs.c → libfwupdplugin/fu-bios-settings.c
View File

@ -4,48 +4,48 @@
* SPDX-License-Identifier: LGPL-2.1+
*/
#define G_LOG_DOMAIN "FuBiosAttrs"
#define G_LOG_DOMAIN "FuBiosSettings"
#include "config.h"
#include "fwupd-bios-attr-private.h"
#include "fwupd-bios-setting-private.h"
#include "fwupd-error.h"
#include "fu-bios-attrs-private.h"
#include "fu-bios-settings-private.h"
#include "fu-path.h"
#include "fu-string.h"
struct _FuBiosAttrs {
struct _FuBiosSettings {
GObject parent_instance;
GPtrArray *attrs;
};
G_DEFINE_TYPE(FuBiosAttrs, fu_bios_attrs, G_TYPE_OBJECT)
G_DEFINE_TYPE(FuBiosSettings, fu_bios_settings, G_TYPE_OBJECT)
static void
fu_bios_attrs_finalize(GObject *obj)
fu_bios_settings_finalize(GObject *obj)
{
FuBiosAttrs *self = FU_BIOS_ATTRS(obj);
FuBiosSettings *self = FU_BIOS_SETTINGS(obj);
g_ptr_array_unref(self->attrs);
G_OBJECT_CLASS(fu_bios_attrs_parent_class)->finalize(obj);
G_OBJECT_CLASS(fu_bios_settings_parent_class)->finalize(obj);
}
static void
fu_bios_attrs_class_init(FuBiosAttrsClass *klass)
fu_bios_settings_class_init(FuBiosSettingsClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->finalize = fu_bios_attrs_finalize;
object_class->finalize = fu_bios_settings_finalize;
}
static gboolean
fu_bios_attr_get_key(FwupdBiosAttr *attr, const gchar *key, gchar **value_out, GError **error)
fu_bios_setting_get_key(FwupdBiosSetting *attr, const gchar *key, gchar **value_out, GError **error)
{
g_autofree gchar *tmp = NULL;
g_return_val_if_fail(FWUPD_IS_BIOS_ATTR(attr), FALSE);
g_return_val_if_fail(FWUPD_IS_BIOS_SETTING(attr), FALSE);
g_return_val_if_fail(&value_out != NULL, FALSE);
tmp = g_build_filename(fwupd_bios_attr_get_path(attr), key, NULL);
tmp = g_build_filename(fwupd_bios_setting_get_path(attr), key, NULL);
if (!g_file_get_contents(tmp, value_out, NULL, error)) {
g_prefix_error(error, "failed to load %s: ", key);
return FALSE;
@ -55,26 +55,26 @@ fu_bios_attr_get_key(FwupdBiosAttr *attr, const gchar *key, gchar **value_out, G
}
static gboolean
fu_bios_attr_set_description(FwupdBiosAttr *attr, GError **error)
fu_bios_setting_set_description(FwupdBiosSetting *attr, GError **error)
{
g_autofree gchar *data = NULL;
g_return_val_if_fail(FWUPD_IS_BIOS_ATTR(attr), FALSE);
g_return_val_if_fail(FWUPD_IS_BIOS_SETTING(attr), FALSE);
if (!fu_bios_attr_get_key(attr, "display_name", &data, error))
if (!fu_bios_setting_get_key(attr, "display_name", &data, error))
return FALSE;
fwupd_bios_attr_set_description(attr, data);
fwupd_bios_setting_set_description(attr, data);
return TRUE;
}
static guint64
fu_bios_attr_get_key_as_integer(FwupdBiosAttr *attr, const gchar *key, GError **error)
fu_bios_setting_get_key_as_integer(FwupdBiosSetting *attr, const gchar *key, GError **error)
{
g_autofree gchar *str = NULL;
guint64 tmp;
if (!fu_bios_attr_get_key(attr, key, &str, error))
if (!fu_bios_setting_get_key(attr, key, &str, error))
return G_MAXUINT64;
if (!fu_strtoull(str, &tmp, 0, G_MAXUINT64, error)) {
g_prefix_error(error, "failed to convert %s to integer: ", key);
@ -84,12 +84,12 @@ fu_bios_attr_get_key_as_integer(FwupdBiosAttr *attr, const gchar *key, GError **
}
static gboolean
fu_bios_attr_set_enumeration_attrs(FwupdBiosAttr *attr, GError **error)
fu_bios_setting_set_enumeration_attrs(FwupdBiosSetting *attr, GError **error)
{
const gchar *delimiters[] = {",", ";", NULL};
g_autofree gchar *str = NULL;
if (!fu_bios_attr_get_key(attr, "possible_values", &str, error))
if (!fu_bios_setting_get_key(attr, "possible_values", &str, error))
return FALSE;
for (guint j = 0; delimiters[j] != NULL; j++) {
g_auto(GStrv) vals = NULL;
@ -97,59 +97,59 @@ fu_bios_attr_set_enumeration_attrs(FwupdBiosAttr *attr, GError **error)
continue;
vals = fu_strsplit(str, strlen(str), delimiters[j], -1);
if (vals[0] != NULL)
fwupd_bios_attr_set_kind(attr, FWUPD_BIOS_ATTR_KIND_ENUMERATION);
fwupd_bios_setting_set_kind(attr, FWUPD_BIOS_SETTING_KIND_ENUMERATION);
for (guint i = 0; vals[i] != NULL && vals[i][0] != '\0'; i++)
fwupd_bios_attr_add_possible_value(attr, vals[i]);
fwupd_bios_setting_add_possible_value(attr, vals[i]);
}
return TRUE;
}
static gboolean
fu_bios_attr_set_string_attrs(FwupdBiosAttr *attr, GError **error)
fu_bios_setting_set_string_attrs(FwupdBiosSetting *attr, GError **error)
{
guint64 tmp;
tmp = fu_bios_attr_get_key_as_integer(attr, "min_length", error);
tmp = fu_bios_setting_get_key_as_integer(attr, "min_length", error);
if (tmp == G_MAXUINT64)
return FALSE;
fwupd_bios_attr_set_lower_bound(attr, tmp);
tmp = fu_bios_attr_get_key_as_integer(attr, "max_length", error);
fwupd_bios_setting_set_lower_bound(attr, tmp);
tmp = fu_bios_setting_get_key_as_integer(attr, "max_length", error);
if (tmp == G_MAXUINT64)
return FALSE;
fwupd_bios_attr_set_upper_bound(attr, tmp);
fwupd_bios_attr_set_kind(attr, FWUPD_BIOS_ATTR_KIND_STRING);
fwupd_bios_setting_set_upper_bound(attr, tmp);
fwupd_bios_setting_set_kind(attr, FWUPD_BIOS_SETTING_KIND_STRING);
return TRUE;
}
static gboolean
fu_bios_attr_set_integer_attrs(FwupdBiosAttr *attr, GError **error)
fu_bios_setting_set_integer_attrs(FwupdBiosSetting *attr, GError **error)
{
guint64 tmp;
tmp = fu_bios_attr_get_key_as_integer(attr, "min_value", error);
tmp = fu_bios_setting_get_key_as_integer(attr, "min_value", error);
if (tmp == G_MAXUINT64)
return FALSE;
fwupd_bios_attr_set_lower_bound(attr, tmp);
tmp = fu_bios_attr_get_key_as_integer(attr, "max_value", error);
fwupd_bios_setting_set_lower_bound(attr, tmp);
tmp = fu_bios_setting_get_key_as_integer(attr, "max_value", error);
if (tmp == G_MAXUINT64)
return FALSE;
fwupd_bios_attr_set_upper_bound(attr, tmp);
tmp = fu_bios_attr_get_key_as_integer(attr, "scalar_increment", error);
fwupd_bios_setting_set_upper_bound(attr, tmp);
tmp = fu_bios_setting_get_key_as_integer(attr, "scalar_increment", error);
if (tmp == G_MAXUINT64)
return FALSE;
fwupd_bios_attr_set_scalar_increment(attr, tmp);
fwupd_bios_attr_set_kind(attr, FWUPD_BIOS_ATTR_KIND_INTEGER);
fwupd_bios_setting_set_scalar_increment(attr, tmp);
fwupd_bios_setting_set_kind(attr, FWUPD_BIOS_SETTING_KIND_INTEGER);
return TRUE;
}
static gboolean
fu_bios_attr_set_current_value(FwupdBiosAttr *attr, GError **error)
fu_bios_setting_set_current_value(FwupdBiosSetting *attr, GError **error)
{
g_autofree gchar *str = NULL;
if (!fu_bios_attr_get_key(attr, "current_value", &str, error))
if (!fu_bios_setting_get_key(attr, "current_value", &str, error))
return FALSE;
fwupd_bios_attr_set_current_value(attr, str);
fwupd_bios_setting_set_current_value(attr, str);
return TRUE;
}
@ -158,24 +158,24 @@ fu_bios_attr_set_current_value(FwupdBiosAttr *attr, GError **error)
#define LENOVO_EXCLUDED "[Excluded from boot order:"
static void
fu_bios_attr_fixup_read_only(FwupdBiosAttr *attr)
fu_bios_setting_fixup_read_only(FwupdBiosSetting *attr)
{
if (fwupd_bios_attr_get_kind(attr) == FWUPD_BIOS_ATTR_KIND_ENUMERATION) {
if (fwupd_bios_setting_get_kind(attr) == FWUPD_BIOS_SETTING_KIND_ENUMERATION) {
struct {
const gchar *id;
const gchar *value;
} read_only_map[] = {{"com.thinklmi.SecureBoot", "Enable"},
{"com.dell-wmi-sysman.SecureBoot", "Enabled"},
{NULL, NULL}};
const gchar *id = fwupd_bios_attr_get_id(attr);
const gchar *tmp = fwupd_bios_attr_get_current_value(attr);
const gchar *id = fwupd_bios_setting_get_id(attr);
const gchar *tmp = fwupd_bios_setting_get_current_value(attr);
for (guint i = 0; read_only_map[i].id != NULL; i++) {
if (g_strcmp0(id, read_only_map[i].id) != 0)
continue;
if (read_only_map[i].value == NULL ||
g_strcmp0(tmp, read_only_map[i].value) == 0) {
fwupd_bios_attr_set_read_only(attr, TRUE);
fwupd_bios_setting_set_read_only(attr, TRUE);
return;
}
}
@ -183,9 +183,9 @@ fu_bios_attr_fixup_read_only(FwupdBiosAttr *attr)
}
static gboolean
fu_bios_attr_fixup_lenovo_thinklmi_bug(FwupdBiosAttr *attr, GError **error)
fu_bios_setting_fixup_lenovo_thinklmi_bug(FwupdBiosSetting *attr, GError **error)
{
const gchar *current_value = fwupd_bios_attr_get_current_value(attr);
const gchar *current_value = fwupd_bios_setting_get_current_value(attr);
const gchar *tmp;
g_autoptr(GString) str = NULL;
g_autoptr(GString) right_str = NULL;
@ -193,14 +193,14 @@ fu_bios_attr_fixup_lenovo_thinklmi_bug(FwupdBiosAttr *attr, GError **error)
if (g_getenv("FWUPD_BIOS_SETTING_VERBOSE") != NULL) {
g_debug("Processing %s: (%s)",
fwupd_bios_attr_get_name(attr),
fwupd_bios_attr_get_current_value(attr));
fwupd_bios_setting_get_name(attr),
fwupd_bios_setting_get_current_value(attr));
}
/* We have read only */
tmp = g_strrstr(current_value, LENOVO_READ_ONLY_NEEDLE);
if (tmp != NULL) {
fwupd_bios_attr_set_read_only(attr, TRUE);
fwupd_bios_setting_set_read_only(attr, TRUE);
str = g_string_new_len(current_value, tmp - current_value);
} else {
str = g_string_new(current_value);
@ -214,7 +214,7 @@ fu_bios_attr_fixup_lenovo_thinklmi_bug(FwupdBiosAttr *attr, GError **error)
vals = fu_strsplit(str->str, str->len, ";", 2);
/* use left half for current value */
fwupd_bios_attr_set_current_value(attr, vals[0]);
fwupd_bios_setting_set_current_value(attr, vals[0]);
if (vals[1] == NULL)
return TRUE;
@ -233,7 +233,7 @@ fu_bios_attr_fixup_lenovo_thinklmi_bug(FwupdBiosAttr *attr, GError **error)
g_string_erase(right_str, 0, strlen(LENOVO_POSSIBLE_NEEDLE));
possible_vals = fu_strsplit(right_str->str, right_str->len, ",", -1);
if (possible_vals[0] != NULL)
fwupd_bios_attr_set_kind(attr, FWUPD_BIOS_ATTR_KIND_ENUMERATION);
fwupd_bios_setting_set_kind(attr, FWUPD_BIOS_SETTING_KIND_ENUMERATION);
for (guint i = 0; possible_vals[i] != NULL && possible_vals[i][0] != '\0'; i++) {
/* last string */
if (possible_vals[i + 1] == NULL &&
@ -242,36 +242,36 @@ fu_bios_attr_fixup_lenovo_thinklmi_bug(FwupdBiosAttr *attr, GError **error)
strlen(possible_vals[i]),
"]",
-1);
fwupd_bios_attr_add_possible_value(attr, stripped_vals[0]);
fwupd_bios_setting_add_possible_value(attr, stripped_vals[0]);
continue;
}
fwupd_bios_attr_add_possible_value(attr, possible_vals[i]);
fwupd_bios_setting_add_possible_value(attr, possible_vals[i]);
}
}
return TRUE;
}
static gboolean
fu_bios_attrs_run_folder_fixups(FwupdBiosAttr *attr, GError **error)
fu_bios_settings_run_folder_fixups(FwupdBiosSetting *attr, GError **error)
{
if (fwupd_bios_attr_get_kind(attr) == FWUPD_BIOS_ATTR_KIND_UNKNOWN)
return fu_bios_attr_fixup_lenovo_thinklmi_bug(attr, error);
if (fwupd_bios_setting_get_kind(attr) == FWUPD_BIOS_SETTING_KIND_UNKNOWN)
return fu_bios_setting_fixup_lenovo_thinklmi_bug(attr, error);
return TRUE;
}
static gboolean
fu_bios_attr_set_type(FuBiosAttrs *self, FwupdBiosAttr *attr, GError **error)
fu_bios_setting_set_type(FuBiosSettings *self, FwupdBiosSetting *attr, GError **error)
{
gboolean kernel_bug = FALSE;
g_autofree gchar *data = NULL;
g_autoptr(GError) error_key = NULL;
g_autoptr(GError) error_local = NULL;
g_return_val_if_fail(FU_IS_BIOS_ATTRS(self), FALSE);
g_return_val_if_fail(FWUPD_IS_BIOS_ATTR(attr), FALSE);
g_return_val_if_fail(FU_IS_BIOS_SETTINGS(self), FALSE);
g_return_val_if_fail(FWUPD_IS_BIOS_SETTING(attr), FALSE);
/* lenovo thinklmi seems to be missing it even though it's mandatory :/ */
if (!fu_bios_attr_get_key(attr, "type", &data, &error_key)) {
if (!fu_bios_setting_get_key(attr, "type", &data, &error_key)) {
#if GLIB_CHECK_VERSION(2, 64, 0)
g_warning_once("KERNEL BUG: 'type' attribute not exported: (%s)",
error_key->message);
@ -282,18 +282,18 @@ fu_bios_attr_set_type(FuBiosAttrs *self, FwupdBiosAttr *attr, GError **error)
}
if (g_strcmp0(data, "enumeration") == 0 || kernel_bug) {
if (!fu_bios_attr_set_enumeration_attrs(attr, &error_local)) {
if (!fu_bios_setting_set_enumeration_attrs(attr, &error_local)) {
if (g_getenv("FWUPD_BIOS_SETTING_VERBOSE") != NULL)
g_debug("failed to add enumeration attrs: %s",
error_local->message);
}
} else if (g_strcmp0(data, "integer") == 0) {
if (!fu_bios_attr_set_integer_attrs(attr, &error_local)) {
if (!fu_bios_setting_set_integer_attrs(attr, &error_local)) {
if (g_getenv("FWUPD_BIOS_SETTING_VERBOSE") != NULL)
g_debug("failed to add integer attrs: %s", error_local->message);
}
} else if (g_strcmp0(data, "string") == 0) {
if (!fu_bios_attr_set_string_attrs(attr, &error_local)) {
if (!fu_bios_setting_set_string_attrs(attr, &error_local)) {
if (g_getenv("FWUPD_BIOS_SETTING_VERBOSE") != NULL)
g_debug("failed to add string attrs: %s", error_local->message);
}
@ -305,70 +305,70 @@ fu_bios_attr_set_type(FuBiosAttrs *self, FwupdBiosAttr *attr, GError **error)
* https://github.com/torvalds/linux/blob/v5.18/Documentation/ABI/testing/sysfs-class-firmware-attributes#L300
*/
static gboolean
fu_bios_attr_set_file_attributes(FwupdBiosAttr *attr, GError **error)
fu_bios_setting_set_file_attributes(FwupdBiosSetting *attr, GError **error)
{
g_autofree gchar *value = NULL;
if (g_strcmp0(fwupd_bios_attr_get_name(attr), FWUPD_BIOS_ATTR_PENDING_REBOOT) != 0) {
if (g_strcmp0(fwupd_bios_setting_get_name(attr), FWUPD_BIOS_SETTING_PENDING_REBOOT) != 0) {
g_set_error(error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"%s attribute is not supported",
fwupd_bios_attr_get_name(attr));
fwupd_bios_setting_get_name(attr));
return FALSE;
}
if (!fu_bios_attr_get_key(attr, NULL, &value, error))
if (!fu_bios_setting_get_key(attr, NULL, &value, error))
return FALSE;
fwupd_bios_attr_set_current_value(attr, value);
fwupd_bios_attr_set_read_only(attr, TRUE);
fwupd_bios_setting_set_current_value(attr, value);
fwupd_bios_setting_set_read_only(attr, TRUE);
return TRUE;
}
static gboolean
fu_bios_attrs_set_folder_attributes(FuBiosAttrs *self, FwupdBiosAttr *attr, GError **error)
fu_bios_settings_set_folder_attributes(FuBiosSettings *self, FwupdBiosSetting *attr, GError **error)
{
g_autoptr(GError) error_local = NULL;
if (!fu_bios_attr_set_type(self, attr, error))
if (!fu_bios_setting_set_type(self, attr, error))
return FALSE;
if (!fu_bios_attr_set_current_value(attr, error))
if (!fu_bios_setting_set_current_value(attr, error))
return FALSE;
if (!fu_bios_attr_set_description(attr, &error_local))
if (!fu_bios_setting_set_description(attr, &error_local))
g_debug("%s", error_local->message);
if (!fu_bios_attrs_run_folder_fixups(attr, error))
if (!fu_bios_settings_run_folder_fixups(attr, error))
return FALSE;
return TRUE;
}
static gboolean
fu_bios_attrs_populate_attribute(FuBiosAttrs *self,
const gchar *driver,
const gchar *path,
const gchar *name,
GError **error)
fu_bios_settings_populate_attribute(FuBiosSettings *self,
const gchar *driver,
const gchar *path,
const gchar *name,
GError **error)
{
g_autoptr(FwupdBiosAttr) attr = NULL;
g_autoptr(FwupdBiosSetting) attr = NULL;
g_autofree gchar *id = NULL;
g_return_val_if_fail(FU_IS_BIOS_ATTRS(self), FALSE);
g_return_val_if_fail(FU_IS_BIOS_SETTINGS(self), FALSE);
g_return_val_if_fail(name != NULL, FALSE);
g_return_val_if_fail(path != NULL, FALSE);
g_return_val_if_fail(driver != NULL, FALSE);
attr = fwupd_bios_attr_new(name, path);
attr = fwupd_bios_setting_new(name, path);
if (g_file_test(path, G_FILE_TEST_IS_DIR)) {
if (!fu_bios_attrs_set_folder_attributes(self, attr, error))
if (!fu_bios_settings_set_folder_attributes(self, attr, error))
return FALSE;
} else {
if (!fu_bios_attr_set_file_attributes(attr, error))
if (!fu_bios_setting_set_file_attributes(attr, error))
return FALSE;
}
id = g_strdup_printf("com.%s.%s", driver, name);
fwupd_bios_attr_set_id(attr, id);
fu_bios_attr_fixup_read_only(attr);
fwupd_bios_setting_set_id(attr, id);
fu_bios_setting_fixup_read_only(attr);
g_ptr_array_add(self->attrs, g_object_ref(attr));
@ -376,8 +376,8 @@ fu_bios_attrs_populate_attribute(FuBiosAttrs *self,
}
/**
* fu_bios_attrs_setup:
* @self: a #FuBiosAttrs
* fu_bios_settings_setup:
* @self: a #FuBiosSettings
*
* Clears all attributes and re-initializes them.
* Mostly used for the test suite, but could potentially be connected to udev
@ -386,13 +386,13 @@ fu_bios_attrs_populate_attribute(FuBiosAttrs *self,
* Since: 1.8.4
**/
gboolean
fu_bios_attrs_setup(FuBiosAttrs *self, GError **error)
fu_bios_settings_setup(FuBiosSettings *self, GError **error)
{
guint count = 0;
g_autofree gchar *sysfsfwdir = NULL;
g_autoptr(GDir) class_dir = NULL;
g_return_val_if_fail(FU_IS_BIOS_ATTRS(self), FALSE);
g_return_val_if_fail(FU_IS_BIOS_SETTINGS(self), FALSE);
if (self->attrs->len > 0) {
g_debug("re-initializing attributes");
@ -425,11 +425,11 @@ fu_bios_attrs_setup(FuBiosAttrs *self, GError **error)
if (name == NULL)
break;
full_path = g_build_filename(path, name, NULL);
if (!fu_bios_attrs_populate_attribute(self,
driver,
full_path,
name,
&error_local)) {
if (!fu_bios_settings_populate_attribute(self,
driver,
full_path,
name,
&error_local)) {
if (g_error_matches(error_local,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED)) {
@ -447,30 +447,30 @@ fu_bios_attrs_setup(FuBiosAttrs *self, GError **error)
}
static void
fu_bios_attrs_init(FuBiosAttrs *self)
fu_bios_settings_init(FuBiosSettings *self)
{
self->attrs = g_ptr_array_new_with_free_func((GDestroyNotify)g_object_unref);
}
/**
* fu_bios_attrs_get_attr:
* @self: a #FuBiosAttrs
* fu_bios_settings_get_attr:
* @self: a #FuBiosSettings
* @val: the attribute ID or name to check for
*
* Returns: (transfer none): the attribute with the given ID or name or NULL if it doesn't exist.
*
* Since: 1.8.4
**/
FwupdBiosAttr *
fu_bios_attrs_get_attr(FuBiosAttrs *self, const gchar *val)
FwupdBiosSetting *
fu_bios_settings_get_attr(FuBiosSettings *self, const gchar *val)
{
g_return_val_if_fail(FU_IS_BIOS_ATTRS(self), NULL);
g_return_val_if_fail(FU_IS_BIOS_SETTINGS(self), NULL);
g_return_val_if_fail(val != NULL, NULL);
for (guint i = 0; i < self->attrs->len; i++) {
FwupdBiosAttr *attr = g_ptr_array_index(self->attrs, i);
const gchar *tmp_id = fwupd_bios_attr_get_id(attr);
const gchar *tmp_name = fwupd_bios_attr_get_name(attr);
FwupdBiosSetting *attr = g_ptr_array_index(self->attrs, i);
const gchar *tmp_id = fwupd_bios_setting_get_id(attr);
const gchar *tmp_name = fwupd_bios_setting_get_name(attr);
if (g_strcmp0(val, tmp_id) == 0 || g_strcmp0(val, tmp_name) == 0)
return attr;
}
@ -478,25 +478,25 @@ fu_bios_attrs_get_attr(FuBiosAttrs *self, const gchar *val)
}
/**
* fu_bios_attrs_get_all:
* @self: a #FuBiosAttrs
* fu_bios_settings_get_all:
* @self: a #FuBiosSettings
*
* Gets all the attributes in the object.
*
* Returns: (transfer container) (element-type FwupdBiosAttr): attributes
* Returns: (transfer container) (element-type FwupdBiosSetting): attributes
*
* Since: 1.8.4
**/
GPtrArray *
fu_bios_attrs_get_all(FuBiosAttrs *self)
fu_bios_settings_get_all(FuBiosSettings *self)
{
g_return_val_if_fail(FU_IS_BIOS_ATTRS(self), NULL);
g_return_val_if_fail(FU_IS_BIOS_SETTINGS(self), NULL);
return g_ptr_array_ref(self->attrs);
}
/**
* fu_bios_attrs_get_pending_reboot:
* @self: a #FuBiosAttrs
* fu_bios_settings_get_pending_reboot:
* @self: a #FuBiosSettings
* @result: (out): Whether a reboot is pending
* @error: (nullable): optional return location for an error
*
@ -505,21 +505,21 @@ fu_bios_attrs_get_all(FuBiosAttrs *self)
* Since: 1.8.4
**/
gboolean
fu_bios_attrs_get_pending_reboot(FuBiosAttrs *self, gboolean *result, GError **error)
fu_bios_settings_get_pending_reboot(FuBiosSettings *self, gboolean *result, GError **error)
{
FwupdBiosAttr *attr;
FwupdBiosSetting *attr;
const gchar *data;
guint64 val = 0;
g_return_val_if_fail(result != NULL, FALSE);
g_return_val_if_fail(FU_IS_BIOS_ATTRS(self), FALSE);
g_return_val_if_fail(FU_IS_BIOS_SETTINGS(self), FALSE);
for (guint i = 0; i < self->attrs->len; i++) {
const gchar *tmp;
attr = g_ptr_array_index(self->attrs, i);
tmp = fwupd_bios_attr_get_name(attr);
if (g_strcmp0(tmp, FWUPD_BIOS_ATTR_PENDING_REBOOT) == 0)
tmp = fwupd_bios_setting_get_name(attr);
if (g_strcmp0(tmp, FWUPD_BIOS_SETTING_PENDING_REBOOT) == 0)
break;
attr = NULL;
}
@ -532,7 +532,7 @@ fu_bios_attrs_get_pending_reboot(FuBiosAttrs *self, gboolean *result, GError **e
return FALSE;
}
data = fwupd_bios_attr_get_current_value(attr);
data = fwupd_bios_setting_get_current_value(attr);
if (!fu_strtoull(data, &val, 0, G_MAXUINT32, error))
return FALSE;
@ -542,44 +542,44 @@ fu_bios_attrs_get_pending_reboot(FuBiosAttrs *self, gboolean *result, GError **e
}
/**
* fu_bios_attrs_to_variant:
* @self: a #FuBiosAttrs
* fu_bios_settings_to_variant:
* @self: a #FuBiosSettings
* @trusted: whether the caller should receive trusted values
*
* Serializes the #FwupdBiosAttr objects.
* Serializes the #FwupdBiosSetting objects.
*
* Returns: a #GVariant or %NULL
*
* Since: 1.8.4
**/
GVariant *
fu_bios_attrs_to_variant(FuBiosAttrs *self, gboolean trusted)
fu_bios_settings_to_variant(FuBiosSettings *self, gboolean trusted)
{
GVariantBuilder builder;
g_return_val_if_fail(FU_IS_BIOS_ATTRS(self), NULL);
g_return_val_if_fail(FU_IS_BIOS_SETTINGS(self), NULL);
g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
for (guint i = 0; i < self->attrs->len; i++) {
FwupdBiosAttr *bios_attr = g_ptr_array_index(self->attrs, i);
FwupdBiosSetting *bios_setting = g_ptr_array_index(self->attrs, i);
g_variant_builder_add_value(&builder,
fwupd_bios_attr_to_variant(bios_attr, trusted));
fwupd_bios_setting_to_variant(bios_setting, trusted));
}
return g_variant_new("(aa{sv})", &builder);
}
/**
* fu_bios_attrs_from_json:
* @self: a #FuBiosAttrs
* fu_bios_settings_from_json:
* @self: a #FuBiosSettings
*
* Loads #FwupdBiosAttr objects from a JSON node.
* Loads #FwupdBiosSetting objects from a JSON node.
*
* Returns: TRUE if the objects were imported
*
* Since: 1.8.4
**/
gboolean
fu_bios_attrs_from_json(FuBiosAttrs *self, JsonNode *json_node, GError **error)
fu_bios_settings_from_json(FuBiosSettings *self, JsonNode *json_node, GError **error)
{
JsonArray *array;
JsonObject *obj;
@ -592,18 +592,18 @@ fu_bios_attrs_from_json(FuBiosAttrs *self, JsonNode *json_node, GError **error)
obj = json_node_get_object(json_node);
/* this has to exist */
if (!json_object_has_member(obj, "BiosAttributes")) {
if (!json_object_has_member(obj, "BiosSettings")) {
g_set_error_literal(error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"no BiosAttributes property in object");
"no BiosSettings property in object");
return FALSE;
}
array = json_object_get_array_member(obj, "BiosAttributes");
array = json_object_get_array_member(obj, "BiosSettings");
for (guint i = 0; i < json_array_get_length(array); i++) {
JsonNode *node_tmp = json_array_get_element(array, i);
g_autoptr(FwupdBiosAttr) attr = fwupd_bios_attr_new(NULL, NULL);
if (!fwupd_bios_attr_from_json(attr, node_tmp, error))
g_autoptr(FwupdBiosSetting) attr = fwupd_bios_setting_new(NULL, NULL);
if (!fwupd_bios_setting_from_json(attr, node_tmp, error))
return FALSE;
g_ptr_array_add(self->attrs, g_steal_pointer(&attr));
}
@ -613,14 +613,14 @@ fu_bios_attrs_from_json(FuBiosAttrs *self, JsonNode *json_node, GError **error)
}
/**
* fu_bios_attrs_new:
* fu_bios_settings_new:
*
* Returns: #FuBiosAttrs
* Returns: #FuBiosSettings
*
* Since: 1.8.4
**/
FuBiosAttrs *
fu_bios_attrs_new(void)
FuBiosSettings *
fu_bios_settings_new(void)
{
return g_object_new(FU_TYPE_FIRMWARE_ATTRS, NULL);
}

20
libfwupdplugin/fu-bios-settings.h Normal file
View File

@ -0,0 +1,20 @@
/*
* Copyright (C) 2022 Mario Limonciello <mario.limonciello@amd.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <libfwupd/fwupd-bios-setting.h>
#define FU_TYPE_FIRMWARE_ATTRS (fu_bios_settings_get_type())
G_DECLARE_FINAL_TYPE(FuBiosSettings, fu_bios_settings, FU, BIOS_SETTINGS, GObject)
FuBiosSettings *
fu_bios_settings_new(void);
gboolean
fu_bios_settings_get_pending_reboot(FuBiosSettings *self, gboolean *result, GError **error);
FwupdBiosSetting *
fu_bios_settings_get_attr(FuBiosSettings *self, const gchar *val);

2
libfwupdplugin/fu-context-private.h
View File

@ -13,7 +13,7 @@
FuContext *
fu_context_new(void);
gboolean
fu_context_reload_bios_attrs(FuContext *self, GError **error);
fu_context_reload_bios_settings(FuContext *self, GError **error);
gboolean
fu_context_load_hwinfo(FuContext *self, GError **error);
gboolean

46
libfwupdplugin/fu-context.c
View File

@ -8,7 +8,7 @@
#include "config.h"
#include "fu-bios-attrs-private.h"
#include "fu-bios-settings-private.h"
#include "fu-context-private.h"
#include "fu-hwids.h"
#include "fu-smbios-private.h"
@ -33,7 +33,7 @@ typedef struct {
FuLidState lid_state;
guint battery_level;
guint battery_threshold;
FuBiosAttrs *host_bios_attrs;
FuBiosSettings *host_bios_settings;
} FuContextPrivate;
enum { SIGNAL_SECURITY_CHANGED, SIGNAL_LAST };
@ -119,7 +119,7 @@ fu_context_get_smbios_integer(FuContext *self, guint8 type, guint8 offset)
}
/**
* fu_context_reload_bios_attrs:
* fu_context_reload_bios_settings:
* @self: a #FuContext
* @error: (nullable): optional return location for an error
*
@ -128,68 +128,68 @@ fu_context_get_smbios_integer(FuContext *self, guint8 type, guint8 offset)
* Since: 1.8.4
**/
gboolean
fu_context_reload_bios_attrs(FuContext *self, GError **error)
fu_context_reload_bios_settings(FuContext *self, GError **error)
{
FuContextPrivate *priv = GET_PRIVATE(self);
g_return_val_if_fail(FU_IS_CONTEXT(self), FALSE);
return fu_bios_attrs_setup(priv->host_bios_attrs, error);
return fu_bios_settings_setup(priv->host_bios_settings, error);
}
/**
* fu_context_get_bios_attrs:
* fu_context_get_bios_settings:
* @self: a #FuContext
*
* Returns all the firmware attributes defined in the system.
*
* Returns: (transfer full): A #FuBiosAttrs
* Returns: (transfer full): A #FuBiosSettings
*
* Since: 1.8.4
**/
FuBiosAttrs *
fu_context_get_bios_attrs(FuContext *self)
FuBiosSettings *
fu_context_get_bios_settings(FuContext *self)
{
FuContextPrivate *priv = GET_PRIVATE(self);
g_return_val_if_fail(FU_IS_CONTEXT(self), NULL);
return g_object_ref(priv->host_bios_attrs);
return g_object_ref(priv->host_bios_settings);
}
/**
* fu_context_get_bios_attr:
* fu_context_get_bios_setting:
* @self: a #FuContext
* @name: a BIOS attribute title, e.g. `BootOrderLock`
* @name: a BIOS setting title, e.g. `BootOrderLock`
*
* Finds out if a system supports a given BIOS attribute.
* Finds out if a system supports a given BIOS setting.
*
* Returns: (transfer none): #FwupdBiosAttr if the attr exists.
* Returns: (transfer none): #FwupdBiosSetting if the attr exists.
*
* Since: 1.8.4
**/
FwupdBiosAttr *
fu_context_get_bios_attr(FuContext *self, const gchar *name)
FwupdBiosSetting *
fu_context_get_bios_setting(FuContext *self, const gchar *name)
{
FuContextPrivate *priv = GET_PRIVATE(self);
g_return_val_if_fail(FU_IS_CONTEXT(self), NULL);
g_return_val_if_fail(name != NULL, NULL);
return fu_bios_attrs_get_attr(priv->host_bios_attrs, name);
return fu_bios_settings_get_attr(priv->host_bios_settings, name);
}
/**
* fu_context_get_bios_attr_pending_reboot:
* fu_context_get_bios_setting_pending_reboot:
* @self: a #FuContext
*
* Determine if updates to BIOS attributes are pending until next boot.
* Determine if updates to BIOS settings are pending until next boot.
*
* Returns: %TRUE if updates are pending.
*
* Since: 1.8.4
**/
gboolean
fu_context_get_bios_attr_pending_reboot(FuContext *self)
fu_context_get_bios_setting_pending_reboot(FuContext *self)
{
FuContextPrivate *priv = GET_PRIVATE(self);
gboolean ret;
g_return_val_if_fail(FU_IS_CONTEXT(self), FALSE);
fu_bios_attrs_get_pending_reboot(priv->host_bios_attrs, &ret, NULL);
fu_bios_settings_get_pending_reboot(priv->host_bios_settings, &ret, NULL);
return ret;
}
@ -889,7 +889,7 @@ fu_context_finalize(GObject *object)
g_hash_table_unref(priv->hwid_flags);
g_object_unref(priv->quirks);
g_object_unref(priv->smbios);
g_object_unref(priv->host_bios_attrs);
g_object_unref(priv->host_bios_settings);
g_hash_table_unref(priv->firmware_gtypes);
g_ptr_array_unref(priv->udev_subsystems);
@ -1004,7 +1004,7 @@ fu_context_init(FuContext *self)
priv->udev_subsystems = g_ptr_array_new_with_free_func(g_free);
priv->firmware_gtypes = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
priv->quirks = fu_quirks_new();
priv->host_bios_attrs = fu_bios_attrs_new();
priv->host_bios_settings = fu_bios_settings_new();
}
/**

12
libfwupdplugin/fu-context.h
View File

@ -8,7 +8,7 @@
#include <gio/gio.h>
#include "fu-bios-attrs.h"
#include "fu-bios-settings.h"
#include "fu-common.h"
#define FU_TYPE_CONTEXT (fu_context_get_type())
@ -87,9 +87,9 @@ fu_context_get_battery_threshold(FuContext *self);
void
fu_context_set_battery_threshold(FuContext *self, guint battery_threshold);
FuBiosAttrs *
fu_context_get_bios_attrs(FuContext *self);
FuBiosSettings *
fu_context_get_bios_settings(FuContext *self);
gboolean
fu_context_get_bios_attr_pending_reboot(FuContext *self);
FwupdBiosAttr *
fu_context_get_bios_attr(FuContext *self, const gchar *name);
fu_context_get_bios_setting_pending_reboot(FuContext *self);
FwupdBiosSetting *
fu_context_get_bios_setting(FuContext *self, const gchar *name);

22
libfwupdplugin/fu-security-attr.c
View File

@ -21,7 +21,7 @@ G_DEFINE_TYPE_WITH_PRIVATE(FuSecurityAttr, fu_security_attr, FWUPD_TYPE_SECURITY
/**
* fu_security_attr_add_bios_target_value:
* @attr: a #FwupdSecurityAttr
* @id: a #FwupdBiosAttr ID or name
* @id: a #FwupdBiosSetting ID or name
* @needle: The substring of a target value
*
* Checks all configured possible values of an enumeration attribute and
@ -36,26 +36,26 @@ fu_security_attr_add_bios_target_value(FwupdSecurityAttr *attr,
{
FuSecurityAttr *self = FU_SECURITY_ATTR(attr);
FuSecurityAttrPrivate *priv = GET_PRIVATE(self);
FwupdBiosAttr *bios_attr;
FwupdBiosSetting *bios_setting;
GPtrArray *values;
bios_attr = fu_context_get_bios_attr(priv->ctx, id);
if (bios_attr == NULL)
bios_setting = fu_context_get_bios_setting(priv->ctx, id);
if (bios_setting == NULL)
return;
fwupd_security_attr_set_bios_attr_id(attr, fwupd_bios_attr_get_id(bios_attr));
fwupd_security_attr_set_bios_attr_current_value(
fwupd_security_attr_set_bios_setting_id(attr, fwupd_bios_setting_get_id(bios_setting));
fwupd_security_attr_set_bios_setting_current_value(
attr,
fwupd_bios_attr_get_current_value(bios_attr));
if (fwupd_bios_attr_get_kind(bios_attr) != FWUPD_BIOS_ATTR_KIND_ENUMERATION)
fwupd_bios_setting_get_current_value(bios_setting));
if (fwupd_bios_setting_get_kind(bios_setting) != FWUPD_BIOS_SETTING_KIND_ENUMERATION)
return;
if (fwupd_bios_attr_get_read_only(bios_attr))
if (fwupd_bios_setting_get_read_only(bios_setting))
return;
values = fwupd_bios_attr_get_possible_values(bios_attr);
values = fwupd_bios_setting_get_possible_values(bios_setting);
for (guint i = 0; i < values->len; i++) {
const gchar *possible = g_ptr_array_index(values, i);
g_autofree gchar *lower = g_utf8_strdown(possible, -1);
if (g_strrstr(lower, needle)) {
fwupd_security_attr_set_bios_attr_target_value(attr, possible);
fwupd_security_attr_set_bios_setting_target_value(attr, possible);
return;
}
}

148
libfwupdplugin/fu-self-test.c
View File

@ -12,10 +12,10 @@
#include <libgcab.h>
#include <string.h>
#include "fwupd-bios-attr-private.h"
#include "fwupd-bios-setting-private.h"
#include "fwupd-security-attr-private.h"
#include "fu-bios-attrs-private.h"
#include "fu-bios-settings-private.h"
#include "fu-cabinet.h"
#include "fu-common-private.h"
#include "fu-context-private.h"
@ -2911,52 +2911,52 @@ fu_device_retry_hardware_func(void)
}
static void
fu_bios_attrs_load_func(void)
fu_bios_settings_load_func(void)
{
gboolean ret;
gint integer;
const gchar *tmp;
GPtrArray *values;
FwupdBiosAttr *attr;
FwupdBiosAttrKind kind;
FwupdBiosSetting *setting;
FwupdBiosSettingKind kind;
g_autofree gchar *test_dir = NULL;
g_autoptr(FuContext) ctx = fu_context_new();
g_autoptr(GError) error = NULL;
g_autoptr(FuBiosAttrs) p620_attrs = NULL;
g_autoptr(FuBiosAttrs) p14s_attrs = NULL;
g_autoptr(FuBiosAttrs) xps9310_attrs = NULL;
g_autoptr(FuBiosSettings) p620_settings = NULL;
g_autoptr(FuBiosSettings) p14s_settings = NULL;
g_autoptr(FuBiosSettings) xp29310_settings = NULL;
g_autoptr(GPtrArray) p14s_items = NULL;
g_autoptr(GPtrArray) p620_items = NULL;
g_autoptr(GPtrArray) xps9310_items = NULL;
/* Load attrs from a Lenovo P620 (with thinklmi driver problems) */
/* load BIOS settings from a Lenovo P620 (with thinklmi driver problems) */
test_dir = g_test_build_filename(G_TEST_DIST, "tests", "bios-attrs", "lenovo-p620", NULL);
(void)g_setenv("FWUPD_SYSFSFWATTRIBDIR", test_dir, TRUE);
g_test_expect_message("FuBiosAttrs", G_LOG_LEVEL_WARNING, "*BUG*");
ret = fu_context_reload_bios_attrs(ctx, &error);
g_test_expect_message("FuBiosSettings", G_LOG_LEVEL_WARNING, "*BUG*");
ret = fu_context_reload_bios_settings(ctx, &error);
g_assert_no_error(error);
g_assert_true(ret);
g_test_assert_expected_messages();
p620_attrs = fu_context_get_bios_attrs(ctx);
p620_items = fu_bios_attrs_get_all(p620_attrs);
p620_settings = fu_context_get_bios_settings(ctx);
p620_items = fu_bios_settings_get_all(p620_settings);
g_assert_cmpint(p620_items->len, ==, 128);
/* make sure nothing pending */
ret = fu_context_get_bios_attr_pending_reboot(ctx);
ret = fu_context_get_bios_setting_pending_reboot(ctx);
g_assert_false(ret);
/* check an attribute reads from kernel as expected by fwupd today */
attr = fu_context_get_bios_attr(ctx, "com.thinklmi.AMDMemoryGuard");
g_assert_nonnull(attr);
tmp = fwupd_bios_attr_get_name(attr);
/* check a BIOS setting reads from kernel as expected by fwupd today */
setting = fu_context_get_bios_setting(ctx, "com.thinklmi.AMDMemoryGuard");
g_assert_nonnull(setting);
tmp = fwupd_bios_setting_get_name(setting);
g_assert_cmpstr(tmp, ==, "AMDMemoryGuard");
tmp = fwupd_bios_attr_get_description(attr);
tmp = fwupd_bios_setting_get_description(setting);
g_assert_cmpstr(tmp, ==, "AMDMemoryGuard");
tmp = fwupd_bios_attr_get_current_value(attr);
tmp = fwupd_bios_setting_get_current_value(setting);
g_assert_cmpstr(tmp, ==, "Disable");
values = fwupd_bios_attr_get_possible_values(attr);
values = fwupd_bios_setting_get_possible_values(setting);
for (guint i = 0; i < values->len; i++) {
const gchar *possible = g_ptr_array_index(values, i);
if (i == 0)
@ -2965,14 +2965,14 @@ fu_bios_attrs_load_func(void)
g_assert_cmpstr(possible, ==, "Enable");
}
/* try to read an attribute known to have ][Status] to make sure we worked
/* try to read an BIOS setting known to have ][Status] to make sure we worked
* around the thinklmi bug sufficiently
*/
attr = fu_context_get_bios_attr(ctx, "com.thinklmi.StartupSequence");
g_assert_nonnull(attr);
tmp = fwupd_bios_attr_get_current_value(attr);
setting = fu_context_get_bios_setting(ctx, "com.thinklmi.StartupSequence");
g_assert_nonnull(setting);
tmp = fwupd_bios_setting_get_current_value(setting);
g_assert_cmpstr(tmp, ==, "Primary");
values = fwupd_bios_attr_get_possible_values(attr);
values = fwupd_bios_setting_get_possible_values(setting);
for (guint i = 0; i < values->len; i++) {
const gchar *possible = g_ptr_array_index(values, i);
if (i == 0)
@ -2981,40 +2981,40 @@ fu_bios_attrs_load_func(void)
g_assert_cmpstr(possible, ==, "Automatic");
}
/* check no attributes have [Status in them */
/* check no BIOS settings have [Status in them */
for (guint i = 0; i < p620_items->len; i++) {
attr = g_ptr_array_index(p620_items, i);
tmp = fwupd_bios_attr_get_current_value(attr);
setting = g_ptr_array_index(p620_items, i);
tmp = fwupd_bios_setting_get_current_value(setting);
g_debug("%s", tmp);
g_assert_null(g_strrstr(tmp, "[Status"));
}
g_free(test_dir);
/* Load attrs from a Lenovo P14s Gen1 */
/* load BIOS settings from a Lenovo P14s Gen1 */
test_dir =
g_test_build_filename(G_TEST_DIST, "tests", "bios-attrs", "lenovo-p14s-gen1", NULL);
(void)g_setenv("FWUPD_SYSFSFWATTRIBDIR", test_dir, TRUE);
ret = fu_context_reload_bios_attrs(ctx, &error);
ret = fu_context_reload_bios_settings(ctx, &error);
g_assert_no_error(error);
g_assert_true(ret);
p14s_attrs = fu_context_get_bios_attrs(ctx);
p14s_items = fu_bios_attrs_get_all(p14s_attrs);
p14s_settings = fu_context_get_bios_settings(ctx);
p14s_items = fu_bios_settings_get_all(p14s_settings);
g_assert_cmpint(p14s_items->len, ==, 75);
/* reboot should be pending on this one */
ret = fu_context_get_bios_attr_pending_reboot(ctx);
ret = fu_context_get_bios_setting_pending_reboot(ctx);
g_assert_true(ret);
/* look for an enumeration attribute with a space */
attr = fu_context_get_bios_attr(ctx, "com.thinklmi.SleepState");
g_assert_nonnull(attr);
tmp = fwupd_bios_attr_get_name(attr);
/* look for an enumeration BIOS setting with a space */
setting = fu_context_get_bios_setting(ctx, "com.thinklmi.SleepState");
g_assert_nonnull(setting);
tmp = fwupd_bios_setting_get_name(setting);
g_assert_cmpstr(tmp, ==, "SleepState");
tmp = fwupd_bios_attr_get_description(attr);
tmp = fwupd_bios_setting_get_description(setting);
g_assert_cmpstr(tmp, ==, "SleepState");
values = fwupd_bios_attr_get_possible_values(attr);
values = fwupd_bios_setting_get_possible_values(setting);
for (guint i = 0; i < values->len; i++) {
const gchar *possible = g_ptr_array_index(values, i);
if (i == 0)
@ -3024,57 +3024,57 @@ fu_bios_attrs_load_func(void)
}
/* make sure we defaulted UEFI Secure boot to read only if enabled */
attr = fu_context_get_bios_attr(ctx, "com.thinklmi.SecureBoot");
g_assert_nonnull(attr);
ret = fwupd_bios_attr_get_read_only(attr);
setting = fu_context_get_bios_setting(ctx, "com.thinklmi.SecureBoot");
g_assert_nonnull(setting);
ret = fwupd_bios_setting_get_read_only(setting);
g_assert_true(ret);
g_free(test_dir);
/* load attrs from a Dell XPS 9310 */
/* load BIOS settings from a Dell XPS 9310 */
test_dir =
g_test_build_filename(G_TEST_DIST, "tests", "bios-attrs", "dell-xps13-9310", NULL);
(void)g_setenv("FWUPD_SYSFSFWATTRIBDIR", test_dir, TRUE);
ret = fu_context_reload_bios_attrs(ctx, &error);
ret = fu_context_reload_bios_settings(ctx, &error);
g_assert_no_error(error);
g_assert_true(ret);
xps9310_attrs = fu_context_get_bios_attrs(ctx);
xps9310_items = fu_bios_attrs_get_all(xps9310_attrs);
xp29310_settings = fu_context_get_bios_settings(ctx);
xps9310_items = fu_bios_settings_get_all(xp29310_settings);
g_assert_cmpint(xps9310_items->len, ==, 109);
/* make sure that we DIDN'T parse reset_bios attribute */
attr = fu_context_get_bios_attr(ctx, FWUPD_BIOS_ATTR_RESET_BIOS);
g_assert_null(attr);
/* make sure that we DIDN'T parse reset_bios setting */
setting = fu_context_get_bios_setting(ctx, FWUPD_BIOS_SETTING_RESET_BIOS);
g_assert_null(setting);
/* look at a integer attribute */
attr = fu_context_get_bios_attr(ctx, "com.dell-wmi-sysman.CustomChargeStop");
g_assert_nonnull(attr);
kind = fwupd_bios_attr_get_kind(attr);
g_assert_cmpint(kind, ==, FWUPD_BIOS_ATTR_KIND_INTEGER);
integer = fwupd_bios_attr_get_lower_bound(attr);
/* look at a integer BIOS setting */
setting = fu_context_get_bios_setting(ctx, "com.dell-wmi-sysman.CustomChargeStop");
g_assert_nonnull(setting);
kind = fwupd_bios_setting_get_kind(setting);
g_assert_cmpint(kind, ==, FWUPD_BIOS_SETTING_KIND_INTEGER);
integer = fwupd_bios_setting_get_lower_bound(setting);
g_assert_cmpint(integer, ==, 55);
integer = fwupd_bios_attr_get_upper_bound(attr);
integer = fwupd_bios_setting_get_upper_bound(setting);
g_assert_cmpint(integer, ==, 100);
integer = fwupd_bios_attr_get_scalar_increment(attr);
integer = fwupd_bios_setting_get_scalar_increment(setting);
g_assert_cmpint(integer, ==, 1);
/* look at a string attribute */
attr = fu_context_get_bios_attr(ctx, "com.dell-wmi-sysman.Asset");
g_assert_nonnull(attr);
integer = fwupd_bios_attr_get_lower_bound(attr);
/* look at a string BIOS setting */
setting = fu_context_get_bios_setting(ctx, "com.dell-wmi-sysman.Asset");
g_assert_nonnull(setting);
integer = fwupd_bios_setting_get_lower_bound(setting);
g_assert_cmpint(integer, ==, 1);
integer = fwupd_bios_attr_get_upper_bound(attr);
integer = fwupd_bios_setting_get_upper_bound(setting);
g_assert_cmpint(integer, ==, 64);
tmp = fwupd_bios_attr_get_description(attr);
tmp = fwupd_bios_setting_get_description(setting);
g_assert_cmpstr(tmp, ==, "Asset Tag");
/* look at a enumeration attribute */
attr = fu_context_get_bios_attr(ctx, "com.dell-wmi-sysman.BiosRcvrFrmHdd");
g_assert_nonnull(attr);
kind = fwupd_bios_attr_get_kind(attr);
g_assert_cmpint(kind, ==, FWUPD_BIOS_ATTR_KIND_ENUMERATION);
values = fwupd_bios_attr_get_possible_values(attr);
/* look at a enumeration BIOS setting */
setting = fu_context_get_bios_setting(ctx, "com.dell-wmi-sysman.BiosRcvrFrmHdd");
g_assert_nonnull(setting);
kind = fwupd_bios_setting_get_kind(setting);
g_assert_cmpint(kind, ==, FWUPD_BIOS_SETTING_KIND_ENUMERATION);
values = fwupd_bios_setting_get_possible_values(setting);
for (guint i = 0; i < values->len; i++) {
const gchar *possible = g_ptr_array_index(values, i);
if (i == 0)
@ -3084,9 +3084,9 @@ fu_bios_attrs_load_func(void)
}
/* make sure we defaulted UEFI Secure boot to read only if enabled */
attr = fu_context_get_bios_attr(ctx, "com.dell-wmi-sysman.SecureBoot");
g_assert_nonnull(attr);
ret = fwupd_bios_attr_get_read_only(attr);
setting = fu_context_get_bios_setting(ctx, "com.dell-wmi-sysman.SecureBoot");
g_assert_nonnull(setting);
ret = fwupd_bios_setting_get_read_only(setting);
g_assert_true(ret);
}
@ -3586,7 +3586,7 @@ main(int argc, char **argv)
g_test_add_func("/fwupd/progress{parent-1-step}", fu_progress_parent_one_step_proxy_func);
g_test_add_func("/fwupd/progress{no-equal}", fu_progress_non_equal_steps_func);
g_test_add_func("/fwupd/progress{finish}", fu_progress_finish_func);
g_test_add_func("/fwupd/bios-attrs{load}", fu_bios_attrs_load_func);
g_test_add_func("/fwupd/bios-attrs{load}", fu_bios_settings_load_func);
g_test_add_func("/fwupd/security-attrs{hsi}", fu_security_attrs_hsi_func);
g_test_add_func("/fwupd/plugin{devices}", fu_plugin_devices_func);
g_test_add_func("/fwupd/plugin{device-inhibit-children}",

2
libfwupdplugin/fwupdplugin.h
View File

@ -12,7 +12,7 @@
#include <libfwupdplugin/fu-archive-firmware.h>
#include <libfwupdplugin/fu-archive.h>
#include <libfwupdplugin/fu-backend.h>
#include <libfwupdplugin/fu-bios-attrs.h>
#include <libfwupdplugin/fu-bios-settings.h>
#include <libfwupdplugin/fu-bluez-device.h>
#include <libfwupdplugin/fu-byte-array.h>
#include <libfwupdplugin/fu-bytes.h>

24
libfwupdplugin/fwupdplugin.map
View File

@ -1071,18 +1071,18 @@ LIBFWUPDPLUGIN_1.8.3 {
LIBFWUPDPLUGIN_1.8.4 {
global:
fu_backend_add_string;
fu_bios_attrs_from_json;
fu_bios_attrs_get_all;
fu_bios_attrs_get_attr;
fu_bios_attrs_get_pending_reboot;
fu_bios_attrs_get_type;
fu_bios_attrs_new;
fu_bios_attrs_setup;
fu_bios_attrs_to_variant;
fu_context_get_bios_attr;
fu_context_get_bios_attr_pending_reboot;
fu_context_get_bios_attrs;
fu_context_reload_bios_attrs;
fu_bios_settings_from_json;
fu_bios_settings_get_all;
fu_bios_settings_get_attr;
fu_bios_settings_get_pending_reboot;
fu_bios_settings_get_type;
fu_bios_settings_new;
fu_bios_settings_setup;
fu_bios_settings_to_variant;
fu_context_get_bios_setting;
fu_context_get_bios_setting_pending_reboot;
fu_context_get_bios_settings;
fu_context_reload_bios_settings;
fu_device_security_attr_new;
fu_plugin_add_string;
fu_plugin_security_attr_new;

6
libfwupdplugin/meson.build
View File

@ -41,7 +41,7 @@ fwupdplugin_src = [
'fu-cfu-payload.c', # fuzzing
'fu-volume.c', # fuzzing
'fu-firmware.c', # fuzzing
'fu-bios-attrs.c', # fuzzing
'fu-bios-settings.c', # fuzzing
'fu-firmware-common.c', # fuzzing
'fu-dfuse-firmware.c', # fuzzing
'fu-fmap-firmware.c', # fuzzing
@ -145,7 +145,7 @@ fwupdplugin_headers = [
'fu-linear-firmware.h',
'fu-volume.h',
'fu-firmware.h',
'fu-bios-attrs.h',
'fu-bios-settings.h',
'fu-firmware-common.h',
'fu-fmap-firmware.h',
'fu-dfuse-firmware.h',
@ -193,7 +193,7 @@ fwupdplugin_headers_private = [
'fu-device-private.h',
'fu-kenv.h',
'fu-plugin-private.h',
'fu-bios-attrs-private.h',
'fu-bios-settings-private.h',
'fu-security-attrs-private.h',
'fu-smbios-private.h',
'fu-udev-device-private.h',

10
plugins/lenovo-thinklmi/fu-plugin-lenovo-thinklmi.c
View File

@ -15,7 +15,7 @@ fu_plugin_lenovo_thinklmi_startup(FuPlugin *plugin, FuProgress *progress, GError
{
FuContext *ctx = fu_plugin_get_context(plugin);
if (fu_context_get_bios_attr(ctx, BOOT_ORDER_LOCK) == NULL) {
if (fu_context_get_bios_setting(ctx, BOOT_ORDER_LOCK) == NULL) {
g_set_error_literal(error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
@ -30,25 +30,25 @@ static void
fu_plugin_lenovo_thinklmi_device_registered(FuPlugin *plugin, FuDevice *device)
{
FuContext *ctx = fu_plugin_get_context(plugin);
FwupdBiosAttr *attr;
FwupdBiosSetting *attr;
g_autoptr(GError) error_local = NULL;
if (g_strcmp0(fu_device_get_plugin(device), "uefi_capsule") != 0)
return;
/* check if boot order lock is turned on */
attr = fu_context_get_bios_attr(ctx, BOOT_ORDER_LOCK);
attr = fu_context_get_bios_setting(ctx, BOOT_ORDER_LOCK);
if (!attr) {
g_debug("failed to find %s in cache\n", BOOT_ORDER_LOCK);
return;
}
if (g_strcmp0(fwupd_bios_attr_get_current_value(attr), "Enable") == 0)
if (g_strcmp0(fwupd_bios_setting_get_current_value(attr), "Enable") == 0)
fu_device_inhibit(device,
"uefi-capsule-bootorder",
"BootOrder is locked in firmware setup");
/* check if we're pending for a reboot */
if (fu_context_get_bios_attr_pending_reboot(ctx))
if (fu_context_get_bios_setting_pending_reboot(ctx))
fu_device_inhibit(device,
"uefi-capsule-pending-reboot",
"UEFI BIOS settings update pending reboot");

12
plugins/lenovo-thinklmi/fu-self-test.c
View File

@ -11,7 +11,7 @@
#include <glib/gstdio.h>
#include <stdlib.h>
#include "fu-bios-attrs-private.h"
#include "fu-bios-settings-private.h"
#include "fu-context-private.h"
#include "fu-device-private.h"
#include "fu-plugin-private.h"
@ -39,7 +39,7 @@ fu_test_self_init(FuTest *self, GError **error_global)
g_autofree gchar *pluginfn_uefi = NULL;
g_autofree gchar *pluginfn_lenovo = NULL;
g_test_expect_message("FuBiosAttrs", G_LOG_LEVEL_WARNING, "*KERNEL*BUG*");
g_test_expect_message("FuBiosSettings", G_LOG_LEVEL_WARNING, "*KERNEL*BUG*");
ret = fu_context_load_quirks(ctx,
FU_QUIRKS_LOAD_FLAG_NO_CACHE | FU_QUIRKS_LOAD_FLAG_NO_VERIFY,
@ -49,7 +49,7 @@ fu_test_self_init(FuTest *self, GError **error_global)
ret = fu_context_load_hwinfo(ctx, &error);
g_assert_no_error(error);
g_assert_true(ret);
ret = fu_context_reload_bios_attrs(ctx, &error);
ret = fu_context_reload_bios_settings(ctx, &error);
g_assert_true(ret);
g_assert_no_error(error);
g_test_assert_expected_messages();
@ -123,7 +123,7 @@ fu_plugin_lenovo_thinklmi_bootorder_locked(gconstpointer user_data)
g_test_build_filename(G_TEST_DIST, "tests", "firmware-attributes", "locked", NULL);
(void)g_setenv("FWUPD_SYSFSFWATTRIBDIR", test_dir, TRUE);
ret = fu_context_reload_bios_attrs(self->ctx, &error);
ret = fu_context_reload_bios_settings(self->ctx, &error);
g_assert_true(ret);
g_assert_no_error(error);
@ -143,7 +143,7 @@ fu_plugin_lenovo_thinklmi_bootorder_unlocked(gconstpointer user_data)
g_test_build_filename(G_TEST_DIST, "tests", "firmware-attributes", "unlocked", NULL);
(void)g_setenv("FWUPD_SYSFSFWATTRIBDIR", test_dir, TRUE);
ret = fu_context_reload_bios_attrs(self->ctx, &error);
ret = fu_context_reload_bios_settings(self->ctx, &error);
g_assert_true(ret);
g_assert_no_error(error);
dev = fu_test_probe_fake_esrt(self);
@ -165,7 +165,7 @@ fu_plugin_lenovo_thinklmi_reboot_pending(gconstpointer user_data)
NULL);
(void)g_setenv("FWUPD_SYSFSFWATTRIBDIR", test_dir, TRUE);
ret = fu_context_reload_bios_attrs(self->ctx, &error);
ret = fu_context_reload_bios_settings(self->ctx, &error);
g_assert_true(ret);
g_assert_no_error(error);
dev = fu_test_probe_fake_esrt(self);

2
po/POTFILES.in
View File

@ -16,5 +16,5 @@ src/fu-remote-list.c
src/fu-security-attr-common.c
src/fu-tool.c
src/fu-util.c
src/fu-util-bios-attr.c
src/fu-util-bios-setting.c
src/fu-util-common.c

12
policy/org.freedesktop.fwupd.policy.in
View File

@ -184,10 +184,10 @@
</defaults>
</action>
<action id="org.freedesktop.fwupd.get-bios-attributes">
<description>Get BIOS attributes</description>
<action id="org.freedesktop.fwupd.get-bios-settings">
<description>Get BIOS settings</description>
<!-- TRANSLATORS: this is the PolicyKit modal dialog -->
<message>Authentication is required to read BIOS attributes</message>
<message>Authentication is required to read BIOS settings</message>
<defaults>
<allow_any>auth_admin</allow_any>
<allow_inactive>no</allow_inactive>
@ -195,8 +195,8 @@
</defaults>
</action>
<action id="org.freedesktop.fwupd.set-bios-attribute">
<description>Set a BIOS attribute</description>
<action id="org.freedesktop.fwupd.set-bios-settings">
<description>Set one or more BIOS settings</description>
<!-- TRANSLATORS: this is the PolicyKit modal dialog -->
<message>Authentication is required to modify BIOS settings</message>
<defaults>
@ -204,7 +204,7 @@
<allow_inactive>no</allow_inactive>
<allow_active>auth_admin</allow_active>
</defaults>
<annotate key="org.freedesktop.policykit.imply">org.freedesktop.fwupd.get-bios-attributes</annotate>
<annotate key="org.freedesktop.policykit.imply">org.freedesktop.fwupd.get-bios-settings</annotate>
</action>
</policyconfig>

45
src/fu-daemon.c
View File

@ -18,7 +18,7 @@
#endif
#include <jcat.h>
#include "fwupd-bios-attr-private.h"
#include "fwupd-bios-setting-private.h"
#include "fwupd-device-private.h"
#include "fwupd-enums-private.h"
#include "fwupd-plugin-private.h"
@ -27,7 +27,7 @@
#include "fwupd-request-private.h"
#include "fwupd-security-attr-private.h"
#include "fu-bios-attrs-private.h"
#include "fu-bios-settings-private.h"
#include "fu-daemon.h"
#include "fu-device-private.h"
#include "fu-engine.h"
@ -505,11 +505,11 @@ fu_daemon_authorize_unlock_cb(GObject *source, GAsyncResult *res, gpointer user_
}
static void
fu_daemon_authorize_get_bios_attrs_cb(GObject *source, GAsyncResult *res, gpointer user_data)
fu_daemon_authorize_get_bios_settings_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
g_autoptr(FuMainAuthHelper) helper = (FuMainAuthHelper *)user_data;
g_autoptr(GError) error = NULL;
g_autoptr(FuBiosAttrs) attrs = NULL;
g_autoptr(FuBiosSettings) attrs = NULL;
FuContext *ctx;
GVariant *val = NULL;
#ifdef HAVE_POLKIT
@ -530,13 +530,13 @@ fu_daemon_authorize_get_bios_attrs_cb(GObject *source, GAsyncResult *res, gpoint
/* authenticated */
ctx = fu_engine_get_context(helper->self->engine);
attrs = fu_context_get_bios_attrs(ctx);
val = fu_bios_attrs_to_variant(attrs, TRUE);
attrs = fu_context_get_bios_settings(ctx);
val = fu_bios_settings_to_variant(attrs, TRUE);
g_dbus_method_invocation_return_value(helper->invocation, val);
}
static void
fu_daemon_authorize_set_bios_attrs_cb(GObject *source, GAsyncResult *res, gpointer user_data)
fu_daemon_authorize_set_bios_settings_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
g_autoptr(FuMainAuthHelper) helper = (FuMainAuthHelper *)user_data;
g_autoptr(GError) error = NULL;
@ -557,7 +557,7 @@ fu_daemon_authorize_set_bios_attrs_cb(GObject *source, GAsyncResult *res, gpoint
#endif /* HAVE_POLKIT */
/* authenticated */
if (!fu_engine_modify_bios_attrs(helper->self->engine, helper->bios_settings, &error)) {
if (!fu_engine_modify_bios_settings(helper->self->engine, helper->bios_settings, &error)) {
g_dbus_method_invocation_return_gerror(helper->invocation, error);
return;
}
@ -1987,17 +1987,18 @@ fu_daemon_daemon_method_call(GDBusConnection *connection,
#endif /* HAVE_GIO_UNIX */
return;
}
if (g_strcmp0(method_name, "GetBiosAttrs") == 0) {
if (g_strcmp0(method_name, "GetBiosSettings") == 0) {
gboolean authenticate = fu_engine_request_get_feature_flags(request) &
FWUPD_FEATURE_FLAG_ALLOW_AUTHENTICATION;
g_debug("Called %s", method_name);
if (!authenticate) {
g_autoptr(FuBiosAttrs) attrs =
fu_context_get_bios_attrs(fu_engine_get_context(self->engine));
val = fu_bios_attrs_to_variant(attrs,
fu_engine_request_get_device_flags(request) &
FWUPD_DEVICE_FLAG_TRUSTED);
g_autoptr(FuBiosSettings) attrs =
fu_context_get_bios_settings(fu_engine_get_context(self->engine));
val = fu_bios_settings_to_variant(
attrs,
fu_engine_request_get_device_flags(request) &
FWUPD_DEVICE_FLAG_TRUSTED);
g_dbus_method_invocation_return_value(invocation, val);
} else {
g_autoptr(FuMainAuthHelper) helper = NULL;
@ -2015,19 +2016,21 @@ fu_daemon_daemon_method_call(GDBusConnection *connection,
polkit_authority_check_authorization(
self->authority,
subject,
"org.freedesktop.fwupd.get-bios-attributes",
"org.freedesktop.fwupd.get-bios-settings",
NULL,
POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION,
NULL,
fu_daemon_authorize_get_bios_attrs_cb,
fu_daemon_authorize_get_bios_settings_cb,
g_steal_pointer(&helper));
#else
fu_daemon_authorize_get_bios_attrs_cb(NULL, NULL, g_steal_pointer(&helper));
fu_daemon_authorize_get_bios_settings_cb(NULL,
NULL,
g_steal_pointer(&helper));
#endif /* HAVE_POLKIT */
}
return;
}
if (g_strcmp0(method_name, "SetBiosAttrs") == 0) {
if (g_strcmp0(method_name, "SetBiosSettings") == 0) {
g_autoptr(FuMainAuthHelper) helper = NULL;
const gchar *key;
const gchar *value;
@ -2056,14 +2059,14 @@ fu_daemon_daemon_method_call(GDBusConnection *connection,
polkit_authority_check_authorization(
self->authority,
subject,
"org.freedesktop.fwupd.set-bios-attribute",
"org.freedesktop.fwupd.set-bios-settings",
NULL,
POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION,
NULL,
fu_daemon_authorize_set_bios_attrs_cb,
fu_daemon_authorize_set_bios_settings_cb,
g_steal_pointer(&helper));
#else
fu_daemon_authorize_set_bios_attrs_cb(NULL, NULL, g_steal_pointer(&helper));
fu_daemon_authorize_set_bios_settings_cb(NULL, NULL, g_steal_pointer(&helper));
#endif /* HAVE_POLKIT */
return;

88
src/fu-engine.c
View File

@ -28,7 +28,7 @@
#include <fwupdplugin.h>
#include "fwupd-bios-attr-private.h"
#include "fwupd-bios-setting-private.h"
#include "fwupd-common-private.h"
#include "fwupd-device-private.h"
#include "fwupd-enums-private.h"
@ -37,7 +37,7 @@
#include "fwupd-resources.h"
#include "fwupd-security-attr-private.h"
#include "fu-bios-attrs-private.h"
#include "fu-bios-settings-private.h"
#include "fu-cabinet.h"
#include "fu-context-private.h"
#include "fu-coswid-firmware.h"
@ -728,15 +728,15 @@ fu_engine_modify_remote(FuEngine *self,
}
static gboolean
fu_engine_update_bios_attr(FwupdBiosAttr *attr, const gchar *value, GError **error)
fu_engine_update_bios_setting(FwupdBiosSetting *attr, const gchar *value, GError **error)
{
int fd;
g_autofree gchar *fn =
g_build_filename(fwupd_bios_attr_get_path(attr), "current_value", NULL);
g_build_filename(fwupd_bios_setting_get_path(attr), "current_value", NULL);
g_autoptr(FuIOChannel) io = NULL;
if (g_strcmp0(fwupd_bios_attr_get_current_value(attr), value) == 0) {
g_debug("%s is already set to %s", fwupd_bios_attr_get_id(attr), value);
if (g_strcmp0(fwupd_bios_setting_get_current_value(attr), value) == 0) {
g_debug("%s is already set to %s", fwupd_bios_setting_get_id(attr), value);
return TRUE;
}
@ -762,9 +762,9 @@ fu_engine_update_bios_attr(FwupdBiosAttr *attr, const gchar *value, GError **err
FU_IO_CHANNEL_FLAG_NONE,
error))
return FALSE;
fwupd_bios_attr_set_current_value(attr, value);
fwupd_bios_setting_set_current_value(attr, value);
g_debug("set %s to %s", fwupd_bios_attr_get_id(attr), value);
g_debug("set %s to %s", fwupd_bios_setting_get_id(attr), value);
return TRUE;
}
@ -774,7 +774,7 @@ fu_engine_update_bios_attr(FwupdBiosAttr *attr, const gchar *value, GError **err
* error messages
*/
static gboolean
fu_engine_validate_bios_attr_input(FwupdBiosAttr *attr, const gchar **value, GError **error)
fu_engine_validate_bios_setting_input(FwupdBiosSetting *attr, const gchar **value, GError **error)
{
guint64 tmp = 0;
@ -788,17 +788,17 @@ fu_engine_validate_bios_attr_input(FwupdBiosAttr *attr, const gchar **value, GEr
"attribute not found");
return FALSE;
}
if (fwupd_bios_attr_get_read_only(attr)) {
if (fwupd_bios_setting_get_read_only(attr)) {
g_set_error(error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"%s is read only",
fwupd_bios_attr_get_name(attr));
fwupd_bios_setting_get_name(attr));
return FALSE;
} else if (fwupd_bios_attr_get_kind(attr) == FWUPD_BIOS_ATTR_KIND_INTEGER) {
} else if (fwupd_bios_setting_get_kind(attr) == FWUPD_BIOS_SETTING_KIND_INTEGER) {
if (!fu_strtoull(*value, &tmp, 0, G_MAXUINT64, error))
return FALSE;
if (tmp < fwupd_bios_attr_get_lower_bound(attr)) {
if (tmp < fwupd_bios_setting_get_lower_bound(attr)) {
g_set_error(error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
@ -806,10 +806,10 @@ fu_engine_validate_bios_attr_input(FwupdBiosAttr *attr, const gchar **value, GEr
"); expected at least %" G_GUINT64_FORMAT,
*value,
tmp,
fwupd_bios_attr_get_lower_bound(attr));
fwupd_bios_setting_get_lower_bound(attr));
return FALSE;
}
if (tmp > fwupd_bios_attr_get_upper_bound(attr)) {
if (tmp > fwupd_bios_setting_get_upper_bound(attr)) {
g_set_error(error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
@ -817,12 +817,12 @@ fu_engine_validate_bios_attr_input(FwupdBiosAttr *attr, const gchar **value, GEr
"); expected no more than %" G_GUINT64_FORMAT,
*value,
tmp,
fwupd_bios_attr_get_upper_bound(attr));
fwupd_bios_setting_get_upper_bound(attr));
return FALSE;
}
} else if (fwupd_bios_attr_get_kind(attr) == FWUPD_BIOS_ATTR_KIND_STRING) {
} else if (fwupd_bios_setting_get_kind(attr) == FWUPD_BIOS_SETTING_KIND_STRING) {
tmp = strlen(*value);
if (tmp < fwupd_bios_attr_get_lower_bound(attr)) {
if (tmp < fwupd_bios_setting_get_lower_bound(attr)) {
g_set_error(error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
@ -830,10 +830,10 @@ fu_engine_validate_bios_attr_input(FwupdBiosAttr *attr, const gchar **value, GEr
"); expected at least %" G_GUINT64_FORMAT,
*value,
tmp,
fwupd_bios_attr_get_lower_bound(attr));
fwupd_bios_setting_get_lower_bound(attr));
return FALSE;
}
if (tmp > fwupd_bios_attr_get_upper_bound(attr)) {
if (tmp > fwupd_bios_setting_get_upper_bound(attr)) {
g_set_error(error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
@ -841,11 +841,11 @@ fu_engine_validate_bios_attr_input(FwupdBiosAttr *attr, const gchar **value, GEr
"); expected no more than %" G_GUINT64_FORMAT,
*value,
tmp,
fwupd_bios_attr_get_upper_bound(attr));
fwupd_bios_setting_get_upper_bound(attr));
return FALSE;
}
} else if (fwupd_bios_attr_get_kind(attr) == FWUPD_BIOS_ATTR_KIND_ENUMERATION) {
const gchar *result = fwupd_bios_attr_map_possible_value(attr, *value, error);
} else if (fwupd_bios_setting_get_kind(attr) == FWUPD_BIOS_SETTING_KIND_ENUMERATION) {
const gchar *result = fwupd_bios_setting_map_possible_value(attr, *value, error);
if (result == NULL)
return FALSE;
*value = result;
@ -860,34 +860,34 @@ fu_engine_validate_bios_attr_input(FwupdBiosAttr *attr, const gchar **value, GEr
}
static gboolean
fu_engine_modify_single_bios_attr(FuEngine *self,
const gchar *key,
const gchar *value,
GError **error)
fu_engine_modify_single_bios_setting(FuEngine *self,
const gchar *key,
const gchar *value,
GError **error)
{
FwupdBiosAttr *attr = fu_context_get_bios_attr(self->ctx, key);
FwupdBiosSetting *attr = fu_context_get_bios_setting(self->ctx, key);
const gchar *tmp = value;
if (!fu_engine_validate_bios_attr_input(attr, &tmp, error))
if (!fu_engine_validate_bios_setting_input(attr, &tmp, error))
return FALSE;
return fu_engine_update_bios_attr(attr, tmp, error);
return fu_engine_update_bios_setting(attr, tmp, error);
}
/**
* fu_engine_modify_bios_attrs:
* fu_engine_modify_bios_settings:
* @self: a #FuEngine
* @settings: Hashtable of settings/values to configure
* @error: (nullable): optional return location for an error
*
* Use the kernel API to set one or more BIOS attributes.
* Use the kernel API to set one or more BIOS settings.
*
* Returns: %TRUE for success
**/
gboolean
fu_engine_modify_bios_attrs(FuEngine *self, GHashTable *settings, GError **error)
fu_engine_modify_bios_settings(FuEngine *self, GHashTable *settings, GError **error)
{
FwupdBiosAttr *pending;
FwupdBiosSetting *pending;
GHashTableIter iter;
gpointer key, value;
@ -905,20 +905,20 @@ fu_engine_modify_bios_attrs(FuEngine *self, GHashTable *settings, GError **error
(const gchar *)key);
return FALSE;
}
if (!fu_engine_modify_single_bios_attr(self, key, value, error))
if (!fu_engine_modify_single_bios_setting(self, key, value, error))
return FALSE;
}
pending = fu_context_get_bios_attr(self->ctx, FWUPD_BIOS_ATTR_PENDING_REBOOT);
pending = fu_context_get_bios_setting(self->ctx, FWUPD_BIOS_SETTING_PENDING_REBOOT);
if (pending == NULL) {
g_set_error(error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_FOUND,
"attribute %s not found",
FWUPD_BIOS_ATTR_PENDING_REBOOT);
FWUPD_BIOS_SETTING_PENDING_REBOOT);
return FALSE;
}
fwupd_bios_attr_set_current_value(pending, "1");
fwupd_bios_setting_set_current_value(pending, "1");
return TRUE;
}
@ -6505,10 +6505,10 @@ fu_engine_security_attrs_from_json(FuEngine *self, JsonNode *json_node, GError *
}
static gboolean
fu_engine_bios_attrs_from_json(FuEngine *self, JsonNode *json_node, GError **error)
fu_engine_bios_settings_from_json(FuEngine *self, JsonNode *json_node, GError **error)
{
JsonObject *obj;
g_autoptr(FuBiosAttrs) bios_attrs = fu_context_get_bios_attrs(self->ctx);
g_autoptr(FuBiosSettings) bios_settings = fu_context_get_bios_settings(self->ctx);
/* sanity check */
if (!JSON_NODE_HOLDS_OBJECT(json_node)) {
@ -6518,9 +6518,9 @@ fu_engine_bios_attrs_from_json(FuEngine *self, JsonNode *json_node, GError **err
/* not supplied */
obj = json_node_get_object(json_node);
if (!json_object_has_member(obj, "BiosAttributes"))
if (!json_object_has_member(obj, "BiosSettings"))
return TRUE;
if (!fu_bios_attrs_from_json(bios_attrs, json_node, error))
if (!fu_bios_settings_from_json(bios_settings, json_node, error))
return FALSE;
/* success */
@ -6595,7 +6595,7 @@ fu_engine_load_host_emulation(FuEngine *self, const gchar *fn, GError **error)
return FALSE;
if (!fu_engine_security_attrs_from_json(self, json_parser_get_root(parser), error))
return FALSE;
if (!fu_engine_bios_attrs_from_json(self, json_parser_get_root(parser), error))
if (!fu_engine_bios_settings_from_json(self, json_parser_get_root(parser), error))
return FALSE;
#ifdef HAVE_HSI
@ -6893,7 +6893,7 @@ fu_engine_check_firmware_attributes(FuEngine *self, FuDevice *device)
subsystem = fu_udev_device_get_subsystem(FU_UDEV_DEVICE(device));
if (g_strcmp0(subsystem, "firmware-attributes") == 0) {
g_autoptr(GError) error = NULL;
if (!fu_context_reload_bios_attrs(self->ctx, &error))
if (!fu_context_reload_bios_settings(self->ctx, &error))
g_debug("%s", error->message);
}
}

2
src/fu-engine.h
View File

@ -244,4 +244,4 @@ fu_engine_schedule_update(FuEngine *self,
GError *
fu_engine_error_array_get_best(GPtrArray *errors);
gboolean
fu_engine_modify_bios_attrs(FuEngine *self, GHashTable *settings, GError **error);
fu_engine_modify_bios_settings(FuEngine *self, GHashTable *settings, GError **error);

71
src/fu-self-test.c
View File

@ -13,10 +13,10 @@
#include <stdlib.h>
#include <string.h>
#include "fwupd-bios-attr-private.h"
#include "fwupd-bios-setting-private.h"
#include "fwupd-security-attr-private.h"
#include "fu-bios-attrs-private.h"
#include "fu-bios-settings-private.h"
#include "fu-cabinet-common.h"
#include "fu-config.h"
#include "fu-context-private.h"
@ -4475,18 +4475,18 @@ fu_common_store_cab_error_wrong_checksum_func(void)
}
static void
fu_engine_modify_bios_attrs_func(void)
fu_engine_modify_bios_settings_func(void)
{
gboolean ret;
const gchar *current;
FwupdBiosAttr *attr1;
FwupdBiosAttr *attr2;
FwupdBiosAttr *attr3;
FwupdBiosAttr *attr4;
FwupdBiosSetting *attr1;
FwupdBiosSetting *attr2;
FwupdBiosSetting *attr3;
FwupdBiosSetting *attr4;
g_autofree gchar *test_dir = NULL;
g_autoptr(FuEngine) engine = fu_engine_new();
g_autoptr(GError) error = NULL;
g_autoptr(FuBiosAttrs) attrs = NULL;
g_autoptr(FuBiosSettings) attrs = NULL;
g_autoptr(GPtrArray) items = NULL;
g_autoptr(GHashTable) bios_settings =
g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
@ -4495,59 +4495,60 @@ fu_engine_modify_bios_attrs_func(void)
test_dir = g_test_build_filename(G_TEST_DIST, "tests", "bios-attrs", NULL);
(void)g_setenv("FWUPD_SYSFSFWATTRIBDIR", test_dir, TRUE);
ret = fu_context_reload_bios_attrs(fu_engine_get_context(engine), &error);
ret = fu_context_reload_bios_settings(fu_engine_get_context(engine), &error);
g_assert_no_error(error);
g_assert_true(ret);
attrs = fu_context_get_bios_attrs(fu_engine_get_context(engine));
items = fu_bios_attrs_get_all(attrs);
attrs = fu_context_get_bios_settings(fu_engine_get_context(engine));
items = fu_bios_settings_get_all(attrs);
g_assert_cmpint(items->len, ==, 4);
/* enumeration */
attr1 =
fu_context_get_bios_attr(fu_engine_get_context(engine), "com.fwupd-internal.Absolute");
attr1 = fu_context_get_bios_setting(fu_engine_get_context(engine),
"com.fwupd-internal.Absolute");
g_assert_nonnull(attr1);
current = fwupd_bios_attr_get_current_value(attr1);
current = fwupd_bios_setting_get_current_value(attr1);
g_assert_nonnull(current);
g_hash_table_insert(bios_settings, g_strdup("Absolute"), g_strdup("Disabled"));
ret = fu_engine_modify_bios_attrs(engine, bios_settings, &error);
ret = fu_engine_modify_bios_settings(engine, bios_settings, &error);
g_assert_no_error(error);
g_assert_true(ret);
g_hash_table_remove_all(bios_settings);
g_hash_table_insert(bios_settings, g_strdup("Absolute"), g_strdup("off"));
ret = fu_engine_modify_bios_attrs(engine, bios_settings, &error);
ret = fu_engine_modify_bios_settings(engine, bios_settings, &error);
g_assert_no_error(error);
g_assert_true(ret);
g_hash_table_remove_all(bios_settings);
g_hash_table_insert(bios_settings, g_strdup("Absolute"), g_strdup("FOO"));
ret = fu_engine_modify_bios_attrs(engine, bios_settings, &error);
ret = fu_engine_modify_bios_settings(engine, bios_settings, &error);
g_assert_false(ret);
g_assert_error(error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED);
g_clear_error(&error);
/* use BiosAttrId instead */
/* use BiosSettingId instead */
g_hash_table_remove_all(bios_settings);
g_hash_table_insert(bios_settings,
g_strdup("com.fwupd-internal.Absolute"),
g_strdup(current));
ret = fu_engine_modify_bios_attrs(engine, bios_settings, &error);
ret = fu_engine_modify_bios_settings(engine, bios_settings, &error);
g_assert_no_error(error);
g_assert_true(ret);
/* string */
attr2 = fu_context_get_bios_attr(fu_engine_get_context(engine), "com.fwupd-internal.Asset");
attr2 =
fu_context_get_bios_setting(fu_engine_get_context(engine), "com.fwupd-internal.Asset");
g_assert_nonnull(attr2);
current = fwupd_bios_attr_get_current_value(attr2);
current = fwupd_bios_setting_get_current_value(attr2);
g_assert_nonnull(current);
g_hash_table_remove_all(bios_settings);
g_hash_table_insert(bios_settings, g_strdup("Asset"), g_strdup("1"));
ret = fu_engine_modify_bios_attrs(engine, bios_settings, &error);
ret = fu_engine_modify_bios_settings(engine, bios_settings, &error);
g_assert_no_error(error);
g_assert_true(ret);
@ -4556,55 +4557,55 @@ fu_engine_modify_bios_attrs_func(void)
bios_settings,
g_strdup("Absolute"),
g_strdup("1234567891123456789112345678911234567891123456789112345678911111"));
ret = fu_engine_modify_bios_attrs(engine, bios_settings, &error);
ret = fu_engine_modify_bios_settings(engine, bios_settings, &error);
g_assert_false(ret);
g_assert_error(error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED);
g_clear_error(&error);
/* integer */
attr3 = fu_context_get_bios_attr(fu_engine_get_context(engine),
"com.fwupd-internal.CustomChargeStop");
attr3 = fu_context_get_bios_setting(fu_engine_get_context(engine),
"com.fwupd-internal.CustomChargeStop");
g_assert_nonnull(attr3);
current = fwupd_bios_attr_get_current_value(attr3);
current = fwupd_bios_setting_get_current_value(attr3);
g_assert_nonnull(current);
g_hash_table_remove_all(bios_settings);
g_hash_table_insert(bios_settings, g_strdup("CustomChargeStop"), g_strdup("70"));
ret = fu_engine_modify_bios_attrs(engine, bios_settings, &error);
ret = fu_engine_modify_bios_settings(engine, bios_settings, &error);
g_assert_true(ret);
g_hash_table_remove_all(bios_settings);
g_hash_table_insert(bios_settings, g_strdup("CustomChargeStop"), g_strdup("110"));
ret = fu_engine_modify_bios_attrs(engine, bios_settings, &error);
ret = fu_engine_modify_bios_settings(engine, bios_settings, &error);
g_assert_false(ret);
g_assert_error(error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED);
g_clear_error(&error);
g_hash_table_remove_all(bios_settings);
g_hash_table_insert(bios_settings, g_strdup("CustomChargeStop"), g_strdup("1"));
ret = fu_engine_modify_bios_attrs(engine, bios_settings, &error);
ret = fu_engine_modify_bios_settings(engine, bios_settings, &error);
g_assert_false(ret);
g_assert_error(error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED);
g_clear_error(&error);
g_hash_table_remove_all(bios_settings);
g_hash_table_insert(bios_settings, g_strdup("CustomChargeStop"), g_strdup(current));
ret = fu_engine_modify_bios_attrs(engine, bios_settings, &error);
ret = fu_engine_modify_bios_settings(engine, bios_settings, &error);
g_assert_true(ret);
g_assert_no_error(error);
/* Read Only */
attr4 = fu_context_get_bios_attr(fu_engine_get_context(engine),
"com.fwupd-internal.pending_reboot");
attr4 = fu_context_get_bios_setting(fu_engine_get_context(engine),
"com.fwupd-internal.pending_reboot");
g_assert_nonnull(attr4);
current = fwupd_bios_attr_get_current_value(attr4);
current = fwupd_bios_setting_get_current_value(attr4);
g_assert_nonnull(current);
g_hash_table_remove_all(bios_settings);
g_hash_table_insert(bios_settings, g_strdup("pending_reboot"), g_strdup("foo"));
ret = fu_engine_modify_bios_attrs(engine, bios_settings, &error);
ret = fu_engine_modify_bios_settings(engine, bios_settings, &error);
g_assert_false(ret);
g_assert_error(error, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED);
g_clear_error(&error);
@ -4793,6 +4794,6 @@ main(int argc, char **argv)
g_test_add_func("/fwupd/common{cab-error-missing-file}",
fu_common_store_cab_error_missing_file_func);
g_test_add_func("/fwupd/common{cab-error-size}", fu_common_store_cab_error_size_func);
g_test_add_func("/fwupd/write-bios-attrs", fu_engine_modify_bios_attrs_func);
g_test_add_func("/fwupd/write-bios-attrs", fu_engine_modify_bios_settings_func);
return g_test_run();
}

36
src/fu-tool.c
View File

@ -21,12 +21,12 @@
#include <stdlib.h>
#include <unistd.h>
#include "fwupd-bios-attr-private.h"
#include "fwupd-bios-setting-private.h"
#include "fwupd-common-private.h"
#include "fwupd-device-private.h"
#include "fwupd-plugin-private.h"
#include "fu-bios-attrs-private.h"
#include "fu-bios-settings-private.h"
#include "fu-cabinet.h"
#include "fu-context-private.h"
#include "fu-debug.h"
@ -39,7 +39,7 @@
#include "fu-security-attr-common.h"
#include "fu-security-attrs-private.h"
#include "fu-smbios-private.h"
#include "fu-util-bios-attr.h"
#include "fu-util-bios-setting.h"
#include "fu-util-common.h"
#ifdef HAVE_SYSTEMD
@ -3224,9 +3224,9 @@ fu_util_switch_branch(FuUtilPrivate *priv, gchar **values, GError **error)
}
static gboolean
fu_util_set_bios_attr(FuUtilPrivate *priv, gchar **input, GError **error)
fu_util_set_bios_setting(FuUtilPrivate *priv, gchar **input, GError **error)
{
g_autoptr(GHashTable) settings = fu_util_bios_attrs_parse_argv(input, error);
g_autoptr(GHashTable) settings = fu_util_bios_settings_parse_argv(input, error);
if (settings == NULL)
return FALSE;
@ -3237,8 +3237,8 @@ fu_util_set_bios_attr(FuUtilPrivate *priv, gchar **input, GError **error)
error))
return FALSE;
if (!fu_engine_modify_bios_attrs(priv->engine, settings, error)) {
g_prefix_error(error, "failed to set BIOS attribute: ");
if (!fu_engine_modify_bios_settings(priv->engine, settings, error)) {
g_prefix_error(error, "failed to set BIOS setting: ");
return FALSE;
}
@ -3250,7 +3250,7 @@ fu_util_set_bios_attr(FuUtilPrivate *priv, gchar **input, GError **error)
while (g_hash_table_iter_next(&iter, &key, &value)) {
g_autofree gchar *msg =
/* TRANSLATORS: Configured a BIOS setting to a value */
g_strdup_printf(_("Set BIOS attribute '%s' using '%s'."),
g_strdup_printf(_("Set BIOS setting '%s' using '%s'."),
(const gchar *)key,
(const gchar *)value);
g_print("\n%s\n", msg);
@ -3267,9 +3267,9 @@ fu_util_set_bios_attr(FuUtilPrivate *priv, gchar **input, GError **error)
}
static gboolean
fu_util_get_bios_attr(FuUtilPrivate *priv, gchar **values, GError **error)
fu_util_get_bios_setting(FuUtilPrivate *priv, gchar **values, GError **error)
{
g_autoptr(FuBiosAttrs) attrs = NULL;
g_autoptr(FuBiosSettings) attrs = NULL;
g_autoptr(GPtrArray) items = NULL;
FuContext *ctx = fu_engine_get_context(priv->engine);
gboolean found = FALSE;
@ -3281,15 +3281,15 @@ fu_util_get_bios_attr(FuUtilPrivate *priv, gchar **values, GError **error)
error))
return FALSE;
attrs = fu_context_get_bios_attrs(ctx);
items = fu_bios_attrs_get_all(attrs);
attrs = fu_context_get_bios_settings(ctx);
items = fu_bios_settings_get_all(attrs);
if (priv->as_json)
return fu_util_get_bios_attr_as_json(values, items, error);
return fu_util_get_bios_setting_as_json(values, items, error);
for (guint i = 0; i < items->len; i++) {
FwupdBiosAttr *attr = g_ptr_array_index(items, i);
if (fu_util_bios_attr_matches_args(attr, values)) {
g_autofree gchar *tmp = fu_util_bios_attr_to_string(attr, 0);
FwupdBiosSetting *attr = g_ptr_array_index(items, i);
if (fu_util_bios_setting_matches_args(attr, values)) {
g_autofree gchar *tmp = fu_util_bios_setting_to_string(attr, 0);
g_print("%s\n", tmp);
found = TRUE;
}
@ -3848,14 +3848,14 @@ main(int argc, char *argv[])
_("[SETTING1] [ SETTING2]..."),
/* TRANSLATORS: command description */
_("Retrieve BIOS settings. If no arguments are passed all settings are returned"),
fu_util_get_bios_attr);
fu_util_get_bios_setting);
fu_util_cmd_array_add(cmd_array,
"set-bios-setting",
/* TRANSLATORS: command argument: uppercase, spaces->dashes */
_("SETTING VALUE"),
/* TRANSLATORS: command description */
_("Set a BIOS setting"),
fu_util_set_bios_attr);
fu_util_set_bios_setting);
/* do stuff on ctrl+c */
priv->cancellable = g_cancellable_new();

20
src/fu-util-bios-attr.h
View File

@ -1,20 +0,0 @@
/*
* Copyright (C) 2017 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
#include "fwupd-bios-attr-private.h"
gchar *
fu_util_bios_attr_to_string(FwupdBiosAttr *attr, guint idt);
gboolean
fu_util_bios_attr_matches_args(FwupdBiosAttr *attr, gchar **values);
gboolean
fu_util_get_bios_attr_as_json(gchar **values, GPtrArray *attrs, GError **error);
GHashTable *
fu_util_bios_attrs_parse_argv(gchar **input, GError **error);

99
src/fu-util-bios-attr.c → src/fu-util-bios-setting.c
View File

@ -10,29 +10,29 @@
#include <glib/gi18n.h>
#include "fu-bios-attrs-private.h"
#include "fu-util-bios-attr.h"
#include "fu-bios-settings-private.h"
#include "fu-util-bios-setting.h"
#include "fu-util-common.h"
static gboolean
fu_util_bios_attr_dup_fields(const gchar *name, const gchar *desc)
fu_util_bios_setting_dup_fields(const gchar *name, const gchar *desc)
{
return g_strcmp0(name, desc) == 0;
}
static void
fu_util_bios_attr_update_description(FwupdBiosAttr *attr)
fu_util_bios_setting_update_description(FwupdBiosSetting *setting)
{
const gchar *name = fwupd_bios_attr_get_name(attr);
const gchar *old = fwupd_bios_attr_get_description(attr);
const gchar *name = fwupd_bios_setting_get_name(setting);
const gchar *old = fwupd_bios_setting_get_description(setting);
const gchar *new = NULL;
if (g_strcmp0(name, FWUPD_BIOS_ATTR_PENDING_REBOOT) == 0) {
if (g_strcmp0(name, FWUPD_BIOS_SETTING_PENDING_REBOOT) == 0) {
/* TRANSLATORS: Settings refers to BIOS settings in this context */
new = _("Settings will apply after system reboots");
}
/* For providing a better description on a number of Lenovo systems */
if (fu_util_bios_attr_dup_fields(name, old)) {
if (fu_util_bios_setting_dup_fields(name, old)) {
if (g_strcmp0(old, "WindowsUEFIFirmwareUpdate") == 0) {
/* TRANSLATORS: description of a BIOS setting */
new = _("BIOS updates delivered via LVFS or Windows Update");
@ -42,21 +42,21 @@ fu_util_bios_attr_update_description(FwupdBiosAttr *attr)
new = gettext(old);
}
if (new != NULL)
fwupd_bios_attr_set_description(attr, new);
fwupd_bios_setting_set_description(setting, new);
}
static const gchar *
fu_util_bios_attr_kind_to_string(FwupdBiosAttrKind kind)
fu_util_bios_setting_kind_to_string(FwupdBiosSettingKind kind)
{
if (kind == FWUPD_BIOS_ATTR_KIND_ENUMERATION) {
if (kind == FWUPD_BIOS_SETTING_KIND_ENUMERATION) {
/* TRANSLATORS: The BIOS setting can only be changed to fixed values */
return _("Enumeration");
}
if (kind == FWUPD_BIOS_ATTR_KIND_INTEGER) {
if (kind == FWUPD_BIOS_SETTING_KIND_INTEGER) {
/* TRANSLATORS: The BIOS setting only accepts integers in a fixed range */
return _("Integer");
}
if (kind == FWUPD_BIOS_ATTR_KIND_STRING) {
if (kind == FWUPD_BIOS_SETTING_KIND_STRING) {
/* TRANSLATORS: The BIOS setting accepts strings */
return _("String");
}
@ -64,14 +64,14 @@ fu_util_bios_attr_kind_to_string(FwupdBiosAttrKind kind)
}
gboolean
fu_util_bios_attr_matches_args(FwupdBiosAttr *attr, gchar **values)
fu_util_bios_setting_matches_args(FwupdBiosSetting *setting, gchar **values)
{
const gchar *name;
/* no arguments set */
if (g_strv_length(values) == 0)
return TRUE;
name = fwupd_bios_attr_get_name(attr);
name = fwupd_bios_setting_get_name(setting);
/* check all arguments */
for (guint j = 0; j < g_strv_length(values); j++) {
@ -82,19 +82,19 @@ fu_util_bios_attr_matches_args(FwupdBiosAttr *attr, gchar **values)
}
gboolean
fu_util_get_bios_attr_as_json(gchar **values, GPtrArray *attrs, GError **error)
fu_util_get_bios_setting_as_json(gchar **values, GPtrArray *settings, GError **error)
{
g_autoptr(JsonBuilder) builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "BiosAttributes");
json_builder_set_member_name(builder, "BiosSettings");
json_builder_begin_array(builder);
for (guint i = 0; i < attrs->len; i++) {
FwupdBiosAttr *attr = g_ptr_array_index(attrs, i);
if (fu_util_bios_attr_matches_args(attr, values)) {
fu_util_bios_attr_update_description(attr);
for (guint i = 0; i < settings->len; i++) {
FwupdBiosSetting *setting = g_ptr_array_index(settings, i);
if (fu_util_bios_setting_matches_args(setting, values)) {
fu_util_bios_setting_update_description(setting);
json_builder_begin_object(builder);
fwupd_bios_attr_to_json(attr, builder);
fwupd_bios_setting_to_json(setting, builder);
json_builder_end_object(builder);
}
}
@ -104,31 +104,31 @@ fu_util_get_bios_attr_as_json(gchar **values, GPtrArray *attrs, GError **error)
}
gchar *
fu_util_bios_attr_to_string(FwupdBiosAttr *attr, guint idt)
fu_util_bios_setting_to_string(FwupdBiosSetting *setting, guint idt)
{
const gchar *tmp;
FwupdBiosAttrKind type;
FwupdBiosSettingKind type;
g_autofree gchar *current_value = NULL;
g_autoptr(GError) error_local = NULL;
g_autoptr(GString) str = g_string_new(NULL);
if (g_getenv("FWUPD_VERBOSE") != NULL) {
g_autofree gchar *debug_str = NULL;
debug_str = fwupd_bios_attr_to_string(attr);
debug_str = fwupd_bios_setting_to_string(setting);
g_debug("%s", debug_str);
return NULL;
}
tmp = fwupd_bios_attr_get_name(attr);
tmp = fwupd_bios_setting_get_name(setting);
fu_string_append(str, idt, tmp, NULL);
type = fwupd_bios_attr_get_kind(attr);
tmp = fu_util_bios_attr_kind_to_string(type);
type = fwupd_bios_setting_get_kind(setting);
tmp = fu_util_bios_setting_kind_to_string(type);
if (tmp != NULL) {
/* TRANSLATORS: type of BIOS setting */
fu_string_append(str, idt + 1, _("Setting type"), tmp);
}
tmp = fwupd_bios_attr_get_current_value(attr);
tmp = fwupd_bios_setting_get_current_value(setting);
if (tmp != NULL) {
current_value = g_strdup(tmp);
} else {
@ -138,14 +138,14 @@ fu_util_bios_attr_to_string(FwupdBiosAttr *attr, guint idt)
/* TRANSLATORS: current value of a BIOS setting */
fu_string_append(str, idt + 1, _("Current Value"), current_value);
fu_util_bios_attr_update_description(attr);
tmp = fwupd_bios_attr_get_description(attr);
fu_util_bios_setting_update_description(setting);
tmp = fwupd_bios_setting_get_description(setting);
if (tmp != NULL) {
/* TRANSLATORS: description of BIOS setting */
fu_string_append(str, idt + 1, _("Description"), tmp);
}
if (fwupd_bios_attr_get_read_only(attr)) {
if (fwupd_bios_setting_get_read_only(setting)) {
/* TRANSLATORS: item is TRUE */
tmp = _("True");
} else {
@ -155,15 +155,17 @@ fu_util_bios_attr_to_string(FwupdBiosAttr *attr, guint idt)
/* TRANSLATORS: BIOS setting is read only */
fu_string_append(str, idt + 1, _("Read Only"), tmp);
if (type == FWUPD_BIOS_ATTR_KIND_INTEGER || type == FWUPD_BIOS_ATTR_KIND_STRING) {
if (type == FWUPD_BIOS_SETTING_KIND_INTEGER || type == FWUPD_BIOS_SETTING_KIND_STRING) {
g_autofree gchar *lower =
g_strdup_printf("%" G_GUINT64_FORMAT, fwupd_bios_attr_get_lower_bound(attr));
g_strdup_printf("%" G_GUINT64_FORMAT,
fwupd_bios_setting_get_lower_bound(setting));
g_autofree gchar *upper =
g_strdup_printf("%" G_GUINT64_FORMAT, fwupd_bios_attr_get_upper_bound(attr));
if (type == FWUPD_BIOS_ATTR_KIND_INTEGER) {
g_strdup_printf("%" G_GUINT64_FORMAT,
fwupd_bios_setting_get_upper_bound(setting));
if (type == FWUPD_BIOS_SETTING_KIND_INTEGER) {
g_autofree gchar *scalar =
g_strdup_printf("%" G_GUINT64_FORMAT,
fwupd_bios_attr_get_scalar_increment(attr));
fwupd_bios_setting_get_scalar_increment(setting));
if (lower != NULL) {
/* TRANSLATORS: Lowest valid integer for BIOS setting */
fu_string_append(str, idt + 1, _("Minimum value"), lower);
@ -186,8 +188,8 @@ fu_util_bios_attr_to_string(FwupdBiosAttr *attr, guint idt)
fu_string_append(str, idt + 1, _("Maximum length"), upper);
}
}
} else if (type == FWUPD_BIOS_ATTR_KIND_ENUMERATION) {
GPtrArray *values = fwupd_bios_attr_get_possible_values(attr);
} else if (type == FWUPD_BIOS_SETTING_KIND_ENUMERATION) {
GPtrArray *values = fwupd_bios_setting_get_possible_values(setting);
if (values != NULL && values->len > 0) {
/* TRANSLATORS: Possible values for a bios setting */
fu_string_append(str, idt + 1, _("Possible Values"), NULL);
@ -202,7 +204,7 @@ fu_util_bios_attr_to_string(FwupdBiosAttr *attr, guint idt)
}
GHashTable *
fu_util_bios_attrs_parse_argv(gchar **input, GError **error)
fu_util_bios_settings_parse_argv(gchar **input, GError **error)
{
g_autoptr(GHashTable) bios_settings =
g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
@ -220,7 +222,7 @@ fu_util_bios_attrs_parse_argv(gchar **input, GError **error)
if (g_strv_length(input) == 1) {
g_autofree gchar *data = NULL;
g_autoptr(JsonParser) parser = json_parser_new();
g_autoptr(FuBiosAttrs) new_bios_attrs = fu_bios_attrs_new();
g_autoptr(FuBiosSettings) new_bios_settings = fu_bios_settings_new();
g_autoptr(GPtrArray) new_items = NULL;
if (!g_file_get_contents(input[0], &data, NULL, error))
@ -230,15 +232,18 @@ fu_util_bios_attrs_parse_argv(gchar **input, GError **error)
return NULL;
}
if (!fu_bios_attrs_from_json(new_bios_attrs, json_parser_get_root(parser), error))
if (!fu_bios_settings_from_json(new_bios_settings,
json_parser_get_root(parser),
error))
return NULL;
new_items = fu_bios_attrs_get_all(new_bios_attrs);
new_items = fu_bios_settings_get_all(new_bios_settings);
for (guint i = 0; i < new_items->len; i++) {
FwupdBiosAttr *item_attr = g_ptr_array_index(new_items, i);
g_hash_table_insert(bios_settings,
g_strdup(fwupd_bios_attr_get_id(item_attr)),
g_strdup(fwupd_bios_attr_get_current_value(item_attr)));
FwupdBiosSetting *item_setting = g_ptr_array_index(new_items, i);
g_hash_table_insert(
bios_settings,
g_strdup(fwupd_bios_setting_get_id(item_setting)),
g_strdup(fwupd_bios_setting_get_current_value(item_setting)));
}
} else {
for (guint i = 0; i < g_strv_length(input); i += 2)

20
src/fu-util-bios-setting.h Normal file
View File

@ -0,0 +1,20 @@
/*
* Copyright (C) 2017 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#pragma once
#include <fwupdplugin.h>
#include "fwupd-bios-setting-private.h"
gchar *
fu_util_bios_setting_to_string(FwupdBiosSetting *setting, guint idt);
gboolean
fu_util_bios_setting_matches_args(FwupdBiosSetting *setting, gchar **values);
gboolean
fu_util_get_bios_setting_as_json(gchar **values, GPtrArray *settings, GError **error);
GHashTable *
fu_util_bios_settings_parse_argv(gchar **input, GError **error);

2
src/fu-util-common.h
View File

@ -10,7 +10,7 @@
#include <json-glib/json-glib.h>
#include "fwupd-bios-attr-private.h"
#include "fwupd-bios-setting-private.h"
#include "fwupd-security-attr-private.h"
/* this is only valid for tools */

53
src/fu-util.c
View File

@ -30,7 +30,7 @@
#include "fu-plugin-private.h"
#include "fu-polkit-agent.h"
#include "fu-progressbar.h"
#include "fu-util-bios-attr.h"
#include "fu-util-bios-setting.h"
#include "fu-util-common.h"
#ifdef HAVE_SYSTEMD
@ -3387,7 +3387,7 @@ fu_util_sync_bkc(FuUtilPrivate *priv, gchar **values, GError **error)
}
static gboolean
fu_util_security_modify_bios_attr(FuUtilPrivate *priv, FwupdSecurityAttr *attr, GError **error)
fu_util_security_modify_bios_setting(FuUtilPrivate *priv, FwupdSecurityAttr *attr, GError **error)
{
g_autoptr(GString) body = g_string_new(NULL);
g_autoptr(GString) title = g_string_new(NULL);
@ -3408,9 +3408,9 @@ fu_util_security_modify_bios_attr(FuUtilPrivate *priv, FwupdSecurityAttr *attr,
_("This tool can change the BIOS setting '%s' from '%s' to '%s' "
"automatically, but it will only be active after restarting the "
"computer."),
fwupd_security_attr_get_bios_attr_id(attr),
fwupd_security_attr_get_bios_attr_current_value(attr),
fwupd_security_attr_get_bios_attr_target_value(attr));
fwupd_security_attr_get_bios_setting_id(attr),
fwupd_security_attr_get_bios_setting_current_value(attr),
fwupd_security_attr_get_bios_setting_target_value(attr));
g_string_append(body, "\n\n");
g_string_append_printf(body,
/* TRANSLATORS: the user has to manually recover; we can't do it */
@ -3426,9 +3426,12 @@ fu_util_security_modify_bios_attr(FuUtilPrivate *priv, FwupdSecurityAttr *attr,
if (!fu_util_prompt_for_boolean(FALSE))
return TRUE;
g_hash_table_insert(bios_settings,
g_strdup(fwupd_security_attr_get_bios_attr_id(attr)),
g_strdup(fwupd_security_attr_get_bios_attr_target_value(attr)));
if (!fwupd_client_modify_bios_attr(priv->client, bios_settings, priv->cancellable, error))
g_strdup(fwupd_security_attr_get_bios_setting_id(attr)),
g_strdup(fwupd_security_attr_get_bios_setting_target_value(attr)));
if (!fwupd_client_modify_bios_setting(priv->client,
bios_settings,
priv->cancellable,
error))
return FALSE;
/* do not offer to upload the report */
@ -3534,10 +3537,10 @@ fu_util_security(FuUtilPrivate *priv, gchar **values, GError **error)
for (guint j = 0; j < attrs->len; j++) {
FwupdSecurityAttr *attr = g_ptr_array_index(attrs, j);
if (!fwupd_security_attr_has_flag(attr, FWUPD_SECURITY_ATTR_FLAG_SUCCESS) &&
fwupd_security_attr_get_bios_attr_id(attr) != NULL &&
fwupd_security_attr_get_bios_attr_current_value(attr) != NULL &&
fwupd_security_attr_get_bios_attr_target_value(attr) != NULL) {
if (!fu_util_security_modify_bios_attr(priv, attr, error))
fwupd_security_attr_get_bios_setting_id(attr) != NULL &&
fwupd_security_attr_get_bios_setting_current_value(attr) != NULL &&
fwupd_security_attr_get_bios_setting_target_value(attr) != NULL) {
if (!fu_util_security_modify_bios_setting(priv, attr, error))
return FALSE;
}
}
@ -3866,15 +3869,15 @@ fu_util_show_plugin_warnings(FuUtilPrivate *priv)
}
static gboolean
fu_util_set_bios_attr(FuUtilPrivate *priv, gchar **input, GError **error)
fu_util_set_bios_setting(FuUtilPrivate *priv, gchar **input, GError **error)
{
g_autoptr(GHashTable) settings = fu_util_bios_attrs_parse_argv(input, error);
g_autoptr(GHashTable) settings = fu_util_bios_settings_parse_argv(input, error);
if (settings == NULL)
return FALSE;
if (!fwupd_client_modify_bios_attr(priv->client, settings, priv->cancellable, error)) {
g_prefix_error(error, "failed to set BIOS attribute: ");
if (!fwupd_client_modify_bios_setting(priv->client, settings, priv->cancellable, error)) {
g_prefix_error(error, "failed to set BIOS setting: ");
return FALSE;
}
@ -3886,7 +3889,7 @@ fu_util_set_bios_attr(FuUtilPrivate *priv, gchar **input, GError **error)
while (g_hash_table_iter_next(&iter, &key, &value)) {
g_autofree gchar *msg =
/* TRANSLATORS: Configured a BIOS setting to a value */
g_strdup_printf(_("Set BIOS attribute '%s' using '%s'."),
g_strdup_printf(_("Set BIOS setting '%s' using '%s'."),
(const gchar *)key,
(const gchar *)value);
g_print("\n%s\n", msg);
@ -3903,21 +3906,21 @@ fu_util_set_bios_attr(FuUtilPrivate *priv, gchar **input, GError **error)
}
static gboolean
fu_util_get_bios_attr(FuUtilPrivate *priv, gchar **values, GError **error)
fu_util_get_bios_setting(FuUtilPrivate *priv, gchar **values, GError **error)
{
g_autoptr(GPtrArray) attrs = NULL;
gboolean found = FALSE;
attrs = fwupd_client_get_bios_attrs(priv->client, priv->cancellable, error);
attrs = fwupd_client_get_bios_settings(priv->client, priv->cancellable, error);
if (attrs == NULL)
return FALSE;
if (priv->as_json)
return fu_util_get_bios_attr_as_json(values, attrs, error);
return fu_util_get_bios_setting_as_json(values, attrs, error);
for (guint i = 0; i < attrs->len; i++) {
FwupdBiosAttr *attr = g_ptr_array_index(attrs, i);
if (fu_util_bios_attr_matches_args(attr, values)) {
g_autofree gchar *tmp = fu_util_bios_attr_to_string(attr, 0);
FwupdBiosSetting *attr = g_ptr_array_index(attrs, i);
if (fu_util_bios_setting_matches_args(attr, values)) {
g_autofree gchar *tmp = fu_util_bios_setting_to_string(attr, 0);
g_print("\n%s\n", tmp);
found = TRUE;
}
@ -4446,14 +4449,14 @@ main(int argc, char *argv[])
_("[SETTING1] [SETTING2] [--no-authenticate]"),
/* TRANSLATORS: command description */
_("Retrieve BIOS settings. If no arguments are passed all settings are returned"),
fu_util_get_bios_attr);
fu_util_get_bios_setting);
fu_util_cmd_array_add(cmd_array,
"set-bios-setting",
/* TRANSLATORS: command argument: uppercase, spaces->dashes */
_("SETTING1 VALUE1 [SETTING2] [VALUE2]"),
/* TRANSLATORS: command description */
_("Sets one or more BIOS settings"),
fu_util_set_bios_attr);
fu_util_set_bios_setting);
/* do stuff on ctrl+c */
priv->cancellable = g_cancellable_new();

4
src/meson.build
View File

@ -85,7 +85,7 @@ fwupdmgr = executable(
'fu-history.c',
'fu-progressbar.c',
'fu-security-attr-common.c',
'fu-util-bios-attr.c',
'fu-util-bios-setting.c',
'fu-util-common.c',
client_src,
systemd_src
@ -188,7 +188,7 @@ fwupdtool = executable(
'fu-tool.c',
'fu-progressbar.c',
'fu-util-common.c',
'fu-util-bios-attr.c',
'fu-util-bios-setting.c',
daemon_src,
],
include_directories: [

12
src/org.freedesktop.fwupd.xml
View File

@ -866,35 +866,35 @@
</method>
<!--***********************************************************-->
<method name='SetBiosAttrs'>
<method name='SetBiosSettings'>
<doc:doc>
<doc:description>
<doc:para>
Modify BIOS attribute
Modify BIOS setting
</doc:para>
</doc:description>
</doc:doc>
<arg type='a{ss}' name='settings' direction='in'>
<doc:doc>
<doc:summary>
<doc:para>An array of BIOS attributes and their new values.</doc:para>
<doc:para>An array of BIOS settings and their new values.</doc:para>
</doc:summary>
</doc:doc>
</arg>
</method>
<method name='GetBiosAttrs'>
<method name='GetBiosSettings'>
<doc:doc>
<doc:description>
<doc:para>
Gets a list of all the BIOS attributes.
Gets a list of all the BIOS settings.
</doc:para>
</doc:description>
</doc:doc>
<arg type='aa{sv}' name='attrs' direction='out'>
<doc:doc>
<doc:summary>
<doc:para>An array of BIOS attributes, with any properties set on each.</doc:para>
<doc:para>An array of BIOS settings, with any properties set on each.</doc:para>
</doc:summary>
</doc:doc>
</arg>