fwupd/src/fu-tool.c
Mario Limonciello 2d4b7a5826 trivial: fu-util/fu-tool: Move --version into a common shared function
This is mostly for usage with the flatpak so it's easy to tell what
version of the flatpak is installed.
2018-09-14 18:22:38 +01:00

1053 lines
28 KiB
C

/*
* Copyright (C) 2015-2018 Richard Hughes <richard@hughsie.com>
*
* SPDX-License-Identifier: LGPL-2.1+
*/
#define G_LOG_DOMAIN "FuMain"
#include "config.h"
#include <fwupd.h>
#include <glib/gi18n.h>
#include <glib-unix.h>
#include <locale.h>
#include <stdlib.h>
#include <unistd.h>
#include <libsoup/soup.h>
#include "fu-engine.h"
#include "fu-plugin-private.h"
#include "fu-progressbar.h"
#include "fu-smbios.h"
#include "fu-util-common.h"
#include "fu-debug.h"
/* this is only valid in this file */
#define FWUPD_ERROR_INVALID_ARGS (FWUPD_ERROR_LAST+1)
/* custom return code */
#define EXIT_NOTHING_TO_DO 2
typedef struct {
GCancellable *cancellable;
GMainLoop *loop;
GOptionContext *context;
GPtrArray *cmd_array;
FuEngine *engine;
FuProgressbar *progressbar;
FwupdInstallFlags flags;
gboolean show_all_devices;
/* only valid in update and downgrade */
FwupdDevice *current_device;
} FuUtilPrivate;
typedef gboolean (*FuUtilPrivateCb) (FuUtilPrivate *util,
gchar **values,
GError **error);
typedef struct {
gchar *name;
gchar *arguments;
gchar *description;
FuUtilPrivateCb callback;
} FuUtilItem;
static void
fu_util_item_free (FuUtilItem *item)
{
g_free (item->name);
g_free (item->arguments);
g_free (item->description);
g_free (item);
}
static gint
fu_sort_command_name_cb (FuUtilItem **item1, FuUtilItem **item2)
{
return g_strcmp0 ((*item1)->name, (*item2)->name);
}
static void
fu_util_maybe_prefix_sandbox_error (const gchar *value, GError **error)
{
g_autofree gchar *path = g_path_get_dirname (value);
if (!g_file_test (path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) {
g_prefix_error (error,
"Unable to access %s. You may need to copy %s to %s: ",
path, value, g_getenv ("HOME"));
}
}
static void
fu_util_add (GPtrArray *array,
const gchar *name,
const gchar *arguments,
const gchar *description,
FuUtilPrivateCb callback)
{
g_auto(GStrv) names = NULL;
g_return_if_fail (name != NULL);
g_return_if_fail (description != NULL);
g_return_if_fail (callback != NULL);
/* add each one */
names = g_strsplit (name, ",", -1);
for (guint i = 0; names[i] != NULL; i++) {
FuUtilItem *item = g_new0 (FuUtilItem, 1);
item->name = g_strdup (names[i]);
if (i == 0) {
item->description = g_strdup (description);
} else {
/* TRANSLATORS: this is a command alias, e.g. 'get-devices' */
item->description = g_strdup_printf (_("Alias to %s"),
names[0]);
}
item->arguments = g_strdup (arguments);
item->callback = callback;
g_ptr_array_add (array, item);
}
}
static gchar *
fu_util_get_descriptions (GPtrArray *array)
{
gsize len;
const gsize max_len = 35;
GString *string;
/* print each command */
string = g_string_new ("");
for (guint i = 0; i < array->len; i++) {
FuUtilItem *item = g_ptr_array_index (array, i);
g_string_append (string, " ");
g_string_append (string, item->name);
len = strlen (item->name) + 2;
if (item->arguments != NULL) {
g_string_append (string, " ");
g_string_append (string, item->arguments);
len += strlen (item->arguments) + 1;
}
if (len < max_len) {
for (gsize j = len; j < max_len + 1; j++)
g_string_append_c (string, ' ');
g_string_append (string, item->description);
g_string_append_c (string, '\n');
} else {
g_string_append_c (string, '\n');
for (gsize j = 0; j < max_len + 1; j++)
g_string_append_c (string, ' ');
g_string_append (string, item->description);
g_string_append_c (string, '\n');
}
}
/* remove trailing newline */
if (string->len > 0)
g_string_set_size (string, string->len - 1);
return g_string_free (string, FALSE);
}
static gboolean
fu_util_run (FuUtilPrivate *priv, const gchar *command, gchar **values, GError **error)
{
/* find command */
for (guint i = 0; i < priv->cmd_array->len; i++) {
FuUtilItem *item = g_ptr_array_index (priv->cmd_array, i);
if (g_strcmp0 (item->name, command) == 0)
return item->callback (priv, values, error);
}
/* not found */
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_ARGS,
/* TRANSLATORS: error message */
_("Command not found"));
return FALSE;
}
static void
fu_util_cancelled_cb (GCancellable *cancellable, gpointer user_data)
{
FuUtilPrivate *priv = (FuUtilPrivate *) user_data;
/* TRANSLATORS: this is when a device ctrl+c's a watch */
g_print ("%s\n", _("Cancelled"));
g_main_loop_quit (priv->loop);
}
static gboolean
fu_util_smbios_dump (FuUtilPrivate *priv, gchar **values, GError **error)
{
g_autofree gchar *tmp = NULL;
g_autoptr(FuSmbios) smbios = NULL;
if (g_strv_length (values) < 1) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_ARGS,
"Invalid arguments");
return FALSE;
}
smbios = fu_smbios_new ();
if (!fu_smbios_setup_from_file (smbios, values[0], error))
return FALSE;
tmp = fu_smbios_to_string (smbios);
g_print ("%s\n", tmp);
return TRUE;
}
static gboolean
fu_util_sigint_cb (gpointer user_data)
{
FuUtilPrivate *priv = (FuUtilPrivate *) user_data;
g_debug ("Handling SIGINT");
g_cancellable_cancel (priv->cancellable);
return FALSE;
}
static void
fu_util_private_free (FuUtilPrivate *priv)
{
if (priv->cmd_array != NULL)
g_ptr_array_unref (priv->cmd_array);
if (priv->current_device != NULL)
g_object_unref (priv->current_device);
if (priv->engine != NULL)
g_object_unref (priv->engine);
if (priv->loop != NULL)
g_main_loop_unref (priv->loop);
if (priv->cancellable != NULL)
g_object_unref (priv->cancellable);
if (priv->progressbar != NULL)
g_object_unref (priv->progressbar);
if (priv->context != NULL)
g_option_context_free (priv->context);
g_free (priv);
}
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-function"
G_DEFINE_AUTOPTR_CLEANUP_FUNC(FuUtilPrivate, fu_util_private_free)
#pragma clang diagnostic pop
static void
fu_main_engine_device_added_cb (FuEngine *engine,
FuDevice *device,
FuUtilPrivate *priv)
{
g_autofree gchar *tmp = fu_device_to_string (device);
g_debug ("ADDED:\n%s", tmp);
}
static void
fu_main_engine_device_removed_cb (FuEngine *engine,
FuDevice *device,
FuUtilPrivate *priv)
{
g_autofree gchar *tmp = fu_device_to_string (device);
g_debug ("REMOVED:\n%s", tmp);
}
static void
fu_main_engine_status_changed_cb (FuEngine *engine,
FwupdStatus status,
FuUtilPrivate *priv)
{
fu_progressbar_update (priv->progressbar, status, 0);
}
static void
fu_main_engine_percentage_changed_cb (FuEngine *engine,
guint percentage,
FuUtilPrivate *priv)
{
fu_progressbar_update (priv->progressbar, FWUPD_STATUS_UNKNOWN, percentage);
}
static gboolean
fu_util_watch (FuUtilPrivate *priv, gchar **values, GError **error)
{
if (!fu_engine_load (priv->engine, error))
return FALSE;
g_main_loop_run (priv->loop);
return TRUE;
}
static gint
fu_util_plugin_name_sort_cb (FuPlugin **item1, FuPlugin **item2)
{
return fu_plugin_name_compare (*item1, *item2);
}
static gboolean
fu_util_get_plugins (FuUtilPrivate *priv, gchar **values, GError **error)
{
GPtrArray *plugins;
guint cnt = 0;
/* load engine */
if (!fu_engine_load_plugins (priv->engine, error))
return FALSE;
/* print */
plugins = fu_engine_get_plugins (priv->engine);
g_ptr_array_sort (plugins, (GCompareFunc) fu_util_plugin_name_sort_cb);
for (guint i = 0; i < plugins->len; i++) {
FuPlugin *plugin = g_ptr_array_index (plugins, i);
if (!fu_plugin_get_enabled (plugin))
continue;
g_print ("%s\n", fu_plugin_get_name (plugin));
cnt++;
}
if (cnt == 0) {
/* TRANSLATORS: nothing found */
g_print ("%s\n", _("No plugins found"));
return TRUE;
}
return TRUE;
}
static gboolean
fu_util_get_details (FuUtilPrivate *priv, gchar **values, GError **error)
{
g_autoptr(GPtrArray) array = NULL;
gint fd;
/* load engine */
if (!fu_engine_load (priv->engine, error))
return FALSE;
/* check args */
if (g_strv_length (values) != 1) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_ARGS,
"Invalid arguments");
return FALSE;
}
/* open file */
fd = open (values[0], O_RDONLY);
if (fd < 0) {
fu_util_maybe_prefix_sandbox_error (values[0], error);
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_FILE,
"failed to open %s",
values[0]);
return FALSE;
}
array = fu_engine_get_details (priv->engine, fd, error);
close (fd);
if (array == NULL)
return FALSE;
for (guint i = 0; i < array->len; i++) {
FwupdDevice *dev = g_ptr_array_index (array, i);
g_autofree gchar *tmp = NULL;
tmp = fwupd_device_to_string (dev);
g_print ("%s\n", tmp);
}
return TRUE;
}
static gboolean
fu_util_get_devices (FuUtilPrivate *priv, gchar **values, GError **error)
{
g_autoptr(GPtrArray) devs = NULL;
/* load engine */
if (!fu_engine_load (priv->engine, error))
return FALSE;
/* print */
devs = fu_engine_get_devices (priv->engine, error);
if (devs == NULL)
return FALSE;
if (devs->len == 0) {
/* TRANSLATORS: nothing attached */
g_print ("%s\n", _("No hardware detected with firmware update capability"));
return TRUE;
}
for (guint i = 0; i < devs->len; i++) {
FwupdDevice *dev = g_ptr_array_index (devs, i);
if (priv->show_all_devices || fu_util_is_interesting_device (dev)) {
g_autofree gchar *tmp = fwupd_device_to_string (dev);
g_print ("%s\n", tmp);
}
}
return TRUE;
}
static void
fu_util_build_device_tree (FuUtilPrivate *priv, GNode *root, GPtrArray *devs, FuDevice *dev)
{
for (guint i = 0; i < devs->len; i++) {
FuDevice *dev_tmp = g_ptr_array_index (devs, i);
if (!priv->show_all_devices &&
!fu_util_is_interesting_device (FWUPD_DEVICE (dev_tmp)))
continue;
if (fu_device_get_parent (dev_tmp) == dev) {
GNode *child = g_node_append_data (root, dev_tmp);
fu_util_build_device_tree (priv, child, devs, dev_tmp);
}
}
}
static gboolean
fu_util_get_topology (FuUtilPrivate *priv, gchar **values, GError **error)
{
g_autoptr(GNode) root = g_node_new (NULL);
g_autoptr(GPtrArray) devs = NULL;
/* load engine */
if (!fu_engine_load (priv->engine, error))
return FALSE;
/* print */
devs = fu_engine_get_devices (priv->engine, error);
if (devs == NULL)
return FALSE;
/* print */
if (devs->len == 0) {
/* TRANSLATORS: nothing attached that can be upgraded */
g_print ("%s\n", _("No hardware detected with firmware update capability"));
return TRUE;
}
fu_util_build_device_tree (priv, root, devs, NULL);
g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
fu_util_print_device_tree, priv);
return TRUE;
}
static FuDevice *
fu_util_prompt_for_device (FuUtilPrivate *priv, GError **error)
{
FuDevice *dev;
guint idx;
g_autoptr(GPtrArray) devices = NULL;
/* get devices from daemon */
devices = fu_engine_get_devices (priv->engine, error);
if (devices == NULL)
return NULL;
/* exactly one */
if (devices->len == 1) {
dev = g_ptr_array_index (devices, 0);
return g_object_ref (dev);
}
/* TRANSLATORS: get interactive prompt */
g_print ("%s\n", _("Choose a device:"));
/* TRANSLATORS: this is to abort the interactive prompt */
g_print ("0.\t%s\n", _("Cancel"));
for (guint i = 0; i < devices->len; i++) {
dev = g_ptr_array_index (devices, i);
g_print ("%u.\t%s (%s)\n",
i + 1,
fu_device_get_id (dev),
fu_device_get_name (dev));
}
idx = fu_util_prompt_for_number (devices->len);
if (idx == 0) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_NOTHING_TO_DO,
"Request canceled");
return NULL;
}
dev = g_ptr_array_index (devices, idx - 1);
return g_object_ref (dev);
}
static void
fu_util_install_device_changed_cb (FwupdClient *client,
FwupdDevice *device,
FuUtilPrivate *priv)
{
g_autofree gchar *str = NULL;
/* same as last time, so ignore */
if (priv->current_device != NULL &&
fwupd_device_compare (priv->current_device, device) == 0)
return;
/* show message in progressbar */
/* TRANSLATORS: %1 is a device name */
str = g_strdup_printf (_("Installing %s"),
fwupd_device_get_name (device));
fu_progressbar_set_title (priv->progressbar, str);
g_set_object (&priv->current_device, device);
}
static gboolean
fu_util_install_blob (FuUtilPrivate *priv, gchar **values, GError **error)
{
g_autoptr(FuDevice) device = NULL;
g_autoptr(GBytes) blob_fw = NULL;
/* invalid args */
if (g_strv_length (values) == 0) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_ARGS,
"Invalid arguments");
return FALSE;
}
/* parse blob */
blob_fw = fu_common_get_contents_bytes (values[0], error);
if (blob_fw == NULL) {
fu_util_maybe_prefix_sandbox_error (values[0], error);
return FALSE;
}
/* load engine */
if (!fu_engine_load (priv->engine, error))
return FALSE;
/* get device */
if (g_strv_length (values) >= 2) {
device = fu_engine_get_device (priv->engine, values[1], error);
if (device == NULL)
return FALSE;
} else {
device = fu_util_prompt_for_device (priv, error);
if (device == NULL)
return FALSE;
}
g_signal_connect (priv->engine, "device-changed",
G_CALLBACK (fu_util_install_device_changed_cb), priv);
/* write bare firmware */
return fu_engine_install_blob (priv->engine, device,
NULL, /* blob_cab */
blob_fw,
NULL, /* version */
priv->flags,
error);
}
static gint
fu_util_install_task_sort_cb (gconstpointer a, gconstpointer b)
{
FuInstallTask *task1 = *((FuInstallTask **) a);
FuInstallTask *task2 = *((FuInstallTask **) b);
return fu_install_task_compare (task1, task2);
}
static gboolean
fu_util_download_out_of_process (const gchar *uri, const gchar *fn, GError **error)
{
const gchar *argv[][5] = { { "wget", uri, "-o", fn, NULL },
{ "curl", uri, "--output", fn, NULL },
{ NULL } };
for (guint i = 0; argv[i][0] != NULL; i++) {
g_autoptr(GError) error_local = NULL;
if (!fu_common_find_program_in_path (argv[i][0], &error_local)) {
g_debug ("%s", error_local->message);
continue;
}
return fu_common_spawn_sync (argv[i], NULL, NULL, NULL, error);
}
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_FOUND,
"no supported out-of-process downloaders found");
return FALSE;
}
static gchar *
fu_util_download_if_required (FuUtilPrivate *priv, const gchar *perhapsfn, GError **error)
{
g_autofree gchar *filename = NULL;
g_autoptr(SoupURI) uri = NULL;
/* a local file */
uri = soup_uri_new (perhapsfn);
if (uri == NULL)
return g_strdup (perhapsfn);
/* download the firmware to a cachedir */
filename = fu_util_get_user_cache_path (perhapsfn);
if (!fu_common_mkdir_parent (filename, error))
return NULL;
if (!fu_util_download_out_of_process (perhapsfn, filename, error))
return NULL;
return g_steal_pointer (&filename);
}
static gboolean
fu_util_install (FuUtilPrivate *priv, gchar **values, GError **error)
{
GPtrArray *apps;
g_autofree gchar *filename = NULL;
g_autoptr(AsStore) store = NULL;
g_autoptr(GBytes) blob_cab = NULL;
g_autoptr(GPtrArray) devices_possible = NULL;
g_autoptr(GPtrArray) errors = NULL;
g_autoptr(GPtrArray) install_tasks = NULL;
/* load engine */
if (!fu_engine_load (priv->engine, error))
return FALSE;
/* handle both forms */
if (g_strv_length (values) == 1) {
devices_possible = fu_engine_get_devices (priv->engine, error);
if (devices_possible == NULL)
return FALSE;
} else if (g_strv_length (values) == 2) {
FuDevice *device = fu_engine_get_device (priv->engine,
values[1],
error);
if (device == NULL)
return FALSE;
devices_possible = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
g_ptr_array_add (devices_possible, device);
} else {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_ARGS,
"Invalid arguments");
return FALSE;
}
/* download if required */
filename = fu_util_download_if_required (priv, values[0], error);
if (filename == NULL)
return FALSE;
/* parse store */
blob_cab = fu_common_get_contents_bytes (filename, error);
if (blob_cab == NULL) {
fu_util_maybe_prefix_sandbox_error (filename, error);
return FALSE;
}
store = fu_engine_get_store_from_blob (priv->engine, blob_cab, error);
if (store == NULL)
return FALSE;
apps = as_store_get_apps (store);
/* for each component in the store */
errors = g_ptr_array_new_with_free_func ((GDestroyNotify) g_error_free);
install_tasks = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
for (guint i = 0; i < apps->len; i++) {
AsApp *app = g_ptr_array_index (apps, i);
/* do any devices pass the requirements */
for (guint j = 0; j < devices_possible->len; j++) {
FuDevice *device = g_ptr_array_index (devices_possible, j);
g_autoptr(FuInstallTask) task = NULL;
g_autoptr(GError) error_local = NULL;
/* is this component valid for the device */
task = fu_install_task_new (device, app);
if (!fu_engine_check_requirements (priv->engine,
task, priv->flags,
&error_local)) {
g_debug ("requirement on %s:%s failed: %s",
fu_device_get_id (device),
as_app_get_id (app),
error_local->message);
g_ptr_array_add (errors, g_steal_pointer (&error_local));
continue;
}
/* success */
g_ptr_array_add (install_tasks, g_steal_pointer (&task));
}
}
/* order the install tasks by the device priority */
g_ptr_array_sort (install_tasks, fu_util_install_task_sort_cb);
/* nothing suitable */
if (install_tasks->len == 0) {
GError *error_tmp = fu_common_error_array_get_best (errors);
g_propagate_error (error, error_tmp);
return FALSE;
}
g_signal_connect (priv->engine, "device-changed",
G_CALLBACK (fu_util_install_device_changed_cb), priv);
/* install all the tasks */
if (!fu_engine_install_tasks (priv->engine, install_tasks, blob_cab, priv->flags, error))
return FALSE;
/* success */
return TRUE;
}
static gboolean
fu_util_detach (FuUtilPrivate *priv, gchar **values, GError **error)
{
g_autoptr(FuDevice) device = NULL;
g_autoptr(FuDeviceLocker) locker = NULL;
/* load engine */
if (!fu_engine_load (priv->engine, error))
return FALSE;
/* invalid args */
if (g_strv_length (values) == 0) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_ARGS,
"Invalid arguments");
return FALSE;
}
/* get device */
if (g_strv_length (values) >= 1) {
device = fu_engine_get_device (priv->engine, values[0], error);
if (device == NULL)
return FALSE;
} else {
device = fu_util_prompt_for_device (priv, error);
if (device == NULL)
return FALSE;
}
/* run vfunc */
locker = fu_device_locker_new (device, error);
if (locker == NULL)
return FALSE;
return fu_device_detach (device, error);
}
static gboolean
fu_util_attach (FuUtilPrivate *priv, gchar **values, GError **error)
{
g_autoptr(FuDevice) device = NULL;
g_autoptr(FuDeviceLocker) locker = NULL;
/* load engine */
if (!fu_engine_load (priv->engine, error))
return FALSE;
/* invalid args */
if (g_strv_length (values) == 0) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_ARGS,
"Invalid arguments");
return FALSE;
}
/* get device */
if (g_strv_length (values) >= 1) {
device = fu_engine_get_device (priv->engine, values[0], error);
if (device == NULL)
return FALSE;
} else {
device = fu_util_prompt_for_device (priv, error);
if (device == NULL)
return FALSE;
}
/* run vfunc */
locker = fu_device_locker_new (device, error);
if (locker == NULL)
return FALSE;
return fu_device_attach (device, error);
}
static gboolean
fu_util_hwids (FuUtilPrivate *priv, gchar **values, GError **error)
{
g_autoptr(FuSmbios) smbios = fu_smbios_new ();
g_autoptr(FuHwids) hwids = fu_hwids_new ();
const gchar *hwid_keys[] = {
FU_HWIDS_KEY_BIOS_VENDOR,
FU_HWIDS_KEY_BIOS_VERSION,
FU_HWIDS_KEY_BIOS_MAJOR_RELEASE,
FU_HWIDS_KEY_BIOS_MINOR_RELEASE,
FU_HWIDS_KEY_MANUFACTURER,
FU_HWIDS_KEY_FAMILY,
FU_HWIDS_KEY_PRODUCT_NAME,
FU_HWIDS_KEY_PRODUCT_SKU,
FU_HWIDS_KEY_ENCLOSURE_KIND,
FU_HWIDS_KEY_BASEBOARD_MANUFACTURER,
FU_HWIDS_KEY_BASEBOARD_PRODUCT,
NULL };
/* read DMI data */
if (g_strv_length (values) == 0) {
if (!fu_smbios_setup (smbios, error))
return FALSE;
} else if (g_strv_length (values) == 1) {
if (!fu_smbios_setup_from_file (smbios, values[0], error))
return FALSE;
} else {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_INVALID_ARGS,
"Invalid arguments");
return FALSE;
}
if (!fu_hwids_setup (hwids, smbios, error))
return FALSE;
/* show debug output */
g_print ("Computer Information\n");
g_print ("--------------------\n");
for (guint i = 0; hwid_keys[i] != NULL; i++) {
const gchar *tmp = fu_hwids_get_value (hwids, hwid_keys[i]);
if (tmp == NULL)
continue;
if (g_strcmp0 (hwid_keys[i], FU_HWIDS_KEY_BIOS_MAJOR_RELEASE) == 0 ||
g_strcmp0 (hwid_keys[i], FU_HWIDS_KEY_BIOS_MINOR_RELEASE) == 0) {
guint64 val = g_ascii_strtoull (tmp, NULL, 16);
g_print ("%s: %" G_GUINT64_FORMAT "\n", hwid_keys[i], val);
} else {
g_print ("%s: %s\n", hwid_keys[i], tmp);
}
}
/* show GUIDs */
g_print ("\nHardware IDs\n");
g_print ("------------\n");
for (guint i = 0; i < 15; i++) {
const gchar *keys = NULL;
g_autofree gchar *guid = NULL;
g_autofree gchar *key = NULL;
g_autofree gchar *keys_str = NULL;
g_auto(GStrv) keysv = NULL;
g_autoptr(GError) error_local = NULL;
/* get the GUID */
key = g_strdup_printf ("HardwareID-%u", i);
keys = fu_hwids_get_replace_keys (hwids, key);
guid = fu_hwids_get_guid (hwids, key, &error_local);
if (guid == NULL) {
g_print ("%s\n", error_local->message);
continue;
}
/* show what makes up the GUID */
keysv = g_strsplit (keys, "&", -1);
keys_str = g_strjoinv (" + ", keysv);
g_print ("{%s} <- %s\n", guid, keys_str);
}
return TRUE;
}
int
main (int argc, char *argv[])
{
gboolean allow_older = FALSE;
gboolean allow_reinstall = FALSE;
gboolean force = FALSE;
gboolean ret;
gboolean version = FALSE;
g_auto(GStrv) plugin_glob = NULL;
g_autoptr(FuUtilPrivate) priv = g_new0 (FuUtilPrivate, 1);
g_autoptr(GError) error = NULL;
g_autofree gchar *cmd_descriptions = NULL;
const GOptionEntry options[] = {
{ "version", '\0', 0, G_OPTION_ARG_NONE, &version,
/* TRANSLATORS: command line option */
_("Show client and daemon versions"), NULL },
{ "allow-reinstall", '\0', 0, G_OPTION_ARG_NONE, &allow_reinstall,
/* TRANSLATORS: command line option */
_("Allow re-installing existing firmware versions"), NULL },
{ "allow-older", '\0', 0, G_OPTION_ARG_NONE, &allow_older,
/* TRANSLATORS: command line option */
_("Allow downgrading firmware versions"), NULL },
{ "force", '\0', 0, G_OPTION_ARG_NONE, &force,
/* TRANSLATORS: command line option */
_("Override plugin warning"), NULL },
{ "show-all-devices", '\0', 0, G_OPTION_ARG_NONE, &priv->show_all_devices,
/* TRANSLATORS: command line option */
_("Show devices that are not updatable"), NULL },
{ "plugin-whitelist", '\0', 0, G_OPTION_ARG_STRING_ARRAY, &plugin_glob,
/* TRANSLATORS: command line option */
_("Manually whitelist specific plugins"), NULL },
{ NULL}
};
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
/* ensure root user */
if (getuid () != 0 || geteuid () != 0)
/* TRANSLATORS: we're poking around as a power user */
g_printerr ("%s\n", _("This program may only work correctly as root"));
/* create helper object */
priv->loop = g_main_loop_new (NULL, FALSE);
priv->progressbar = fu_progressbar_new ();
/* add commands */
priv->cmd_array = g_ptr_array_new_with_free_func ((GDestroyNotify) fu_util_item_free);
fu_util_add (priv->cmd_array,
"smbios-dump",
"FILE",
/* TRANSLATORS: command description */
_("Dump SMBIOS data from a file"),
fu_util_smbios_dump);
fu_util_add (priv->cmd_array,
"get-plugins",
NULL,
/* TRANSLATORS: command description */
_("Get all enabled plugins registered with the system"),
fu_util_get_plugins);
fu_util_add (priv->cmd_array,
"get-details",
NULL,
/* TRANSLATORS: command description */
_("Gets details about a firmware file"),
fu_util_get_details);
fu_util_add (priv->cmd_array,
"get-devices",
NULL,
/* TRANSLATORS: command description */
_("Get all devices that support firmware updates"),
fu_util_get_devices);
fu_util_add (priv->cmd_array,
"get-topology",
NULL,
/* TRANSLATORS: command description */
_("Get all devices according to the system topology"),
fu_util_get_topology);
fu_util_add (priv->cmd_array,
"watch",
NULL,
/* TRANSLATORS: command description */
_("Watch for hardware changes"),
fu_util_watch);
fu_util_add (priv->cmd_array,
"install-blob",
"FILENAME DEVICE-ID",
/* TRANSLATORS: command description */
_("Install a firmware blob on a device"),
fu_util_install_blob);
fu_util_add (priv->cmd_array,
"install",
"FILE [ID]",
/* TRANSLATORS: command description */
_("Install a firmware file on this hardware"),
fu_util_install);
fu_util_add (priv->cmd_array,
"attach",
"DEVICE-ID",
/* TRANSLATORS: command description */
_("Attach to firmware mode"),
fu_util_attach);
fu_util_add (priv->cmd_array,
"detach",
"DEVICE-ID",
/* TRANSLATORS: command description */
_("Detach to bootloader mode"),
fu_util_detach);
fu_util_add (priv->cmd_array,
"hwids",
"[FILE]",
/* TRANSLATORS: command description */
_("Return all the hardware IDs for the machine"),
fu_util_hwids);
/* do stuff on ctrl+c */
priv->cancellable = g_cancellable_new ();
g_unix_signal_add_full (G_PRIORITY_DEFAULT,
SIGINT, fu_util_sigint_cb,
priv, NULL);
g_signal_connect (priv->cancellable, "cancelled",
G_CALLBACK (fu_util_cancelled_cb), priv);
/* sort by command name */
g_ptr_array_sort (priv->cmd_array,
(GCompareFunc) fu_sort_command_name_cb);
/* get a list of the commands */
priv->context = g_option_context_new (NULL);
cmd_descriptions = fu_util_get_descriptions (priv->cmd_array);
g_option_context_set_summary (priv->context, cmd_descriptions);
g_option_context_set_description (priv->context,
"This tool allows an administrator to use the fwupd plugins "
"without being installed on the host system.");
/* TRANSLATORS: program name */
g_set_application_name (_("Firmware Utility"));
g_option_context_add_main_entries (priv->context, options, NULL);
g_option_context_add_group (priv->context, fu_debug_get_option_group ());
ret = g_option_context_parse (priv->context, &argc, &argv, &error);
if (!ret) {
/* TRANSLATORS: the user didn't read the man page */
g_print ("%s: %s\n", _("Failed to parse arguments"),
error->message);
return EXIT_FAILURE;
}
/* set flags */
priv->flags |= FWUPD_INSTALL_FLAG_NO_HISTORY;
if (allow_reinstall)
priv->flags |= FWUPD_INSTALL_FLAG_ALLOW_REINSTALL;
if (allow_older)
priv->flags |= FWUPD_INSTALL_FLAG_ALLOW_OLDER;
if (force)
priv->flags |= FWUPD_INSTALL_FLAG_FORCE;
/* load engine */
priv->engine = fu_engine_new (FU_APP_FLAGS_NO_IDLE_SOURCES);
g_signal_connect (priv->engine, "device-added",
G_CALLBACK (fu_main_engine_device_added_cb),
priv);
g_signal_connect (priv->engine, "device-removed",
G_CALLBACK (fu_main_engine_device_removed_cb),
priv);
g_signal_connect (priv->engine, "status-changed",
G_CALLBACK (fu_main_engine_status_changed_cb),
priv);
g_signal_connect (priv->engine, "percentage-changed",
G_CALLBACK (fu_main_engine_percentage_changed_cb),
priv);
/* just show versions and exit */
if (version) {
g_autofree gchar *version_str = fu_util_get_versions ();
g_print ("%s\n", version_str);
return EXIT_SUCCESS;
}
/* any plugin whitelist specified */
for (guint i = 0; plugin_glob != NULL && plugin_glob[i] != NULL; i++)
fu_engine_add_plugin_filter (priv->engine, plugin_glob[i]);
/* run the specified command */
ret = fu_util_run (priv, argv[1], (gchar**) &argv[2], &error);
if (!ret) {
if (g_error_matches (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_ARGS)) {
g_autofree gchar *tmp = NULL;
tmp = g_option_context_get_help (priv->context, TRUE, NULL);
g_print ("%s\n\n%s", error->message, tmp);
return EXIT_FAILURE;
}
if (g_error_matches (error, FWUPD_ERROR, FWUPD_ERROR_NOTHING_TO_DO)) {
g_print ("%s\n", error->message);
return EXIT_NOTHING_TO_DO;
}
g_print ("%s\n", error->message);
return EXIT_FAILURE;
}
/* success */
return EXIT_SUCCESS;
}