11642543588

Committed 02 Nov 2024 12:07PM UTC coverage: 52.844% (-0.03%) from 52.875%

Build # 11642543588

Build Type

push

github

Committed by

superm1

Commit Message

trivial: add some more test coverage for fwupdtool/fwupdmgr

These are trivial checks that will just add some more coverage to the
tools.

Run Details

20441 of 35747 branches covered (57.18%)

Branch coverage included in aggregate %.

99 of 99 new or added lines in 1 file covered. (100.0%)

1049 existing lines in 16 files now uncovered.

64193 of 124410 relevant lines covered (51.6%)

25819.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.3

/src/fu-debug.c

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

#define G_LOG_DOMAIN "FuDebug"

#include "config.h"

#include <fwupdplugin.h>

#include <fu-debug.h>
#include <glib/gi18n.h>
#include <stdio.h>
#include <unistd.h>

#ifdef _WIN32
#include <fwupd-windows.h>
#include <windows.h>
#endif

typedef struct {
        GOptionGroup *group;
        GLogLevelFlags log_level;
        gboolean console;
        gboolean no_timestamp;
        gboolean no_domain;
        gchar **daemon_verbose;
#ifdef _WIN32
        HANDLE event_source;
#endif
} FuDebug;

static const gchar *
fu_debug_log_level_to_string(GLogLevelFlags log_level)
{
        if (log_level == G_LOG_LEVEL_ERROR)
                return "error";
        if (log_level == G_LOG_LEVEL_CRITICAL)
                return "critical";
        if (log_level == G_LOG_LEVEL_WARNING)
                return "warning";
        if (log_level == G_LOG_LEVEL_MESSAGE)
                return "message";
        if (log_level == G_LOG_LEVEL_INFO)
                return "info";
        if (log_level == G_LOG_LEVEL_DEBUG)
                return "debug";
        return NULL;
}

static void
fu_debug_free(FuDebug *self)
{
        g_option_group_set_parse_hooks(self->group, NULL, NULL);
        g_option_group_unref(self->group);
        g_strfreev(self->daemon_verbose);
#ifdef _WIN32
        DeregisterEventSource(self->event_source);
#endif
        g_free(self);
}

static gboolean
fu_debug_filter_cb(FuDebug *self, const gchar *log_domain, GLogLevelFlags log_level)
{
        /* trivial */
        if (log_level <= self->log_level)
                return TRUE;

        /* filter on domain */
        if (self->daemon_verbose != NULL && log_domain != NULL)
                return g_strv_contains((const char *const *)self->daemon_verbose, log_domain);

        /* nope */
        return FALSE;
}

#ifdef _WIN32
static void
fu_debug_handler_win32(FuDebug *self, GLogLevelFlags log_level, const gchar *msg)
{
        WORD ev_type = 0x0;

        /* nothing to do */
        if (self->event_source == NULL)
                return;

        /* map levels */
        switch (log_level) {
        case G_LOG_LEVEL_INFO:
        case G_LOG_LEVEL_MESSAGE:
                ev_type = EVENTLOG_INFORMATION_TYPE;
                break;
        case G_LOG_LEVEL_WARNING:
                ev_type = EVENTLOG_WARNING_TYPE;
                break;
        case G_LOG_LEVEL_ERROR:
        case G_LOG_LEVEL_CRITICAL:
                ev_type = EVENTLOG_ERROR_TYPE;
                break;
        default:
                return;
                break;
        }

        /* add to log */
        ReportEventA(self->event_source,
                     ev_type,
                     FWUPD_CATEGORY_GENERIC,
                     FWUPD_MESSAGE_GENERIC,
                     NULL,
                     1,
                     0,
                     (const char **)&msg,
                     NULL);
}
#endif

static void
fu_debug_handler_cb(const gchar *log_domain,
                    GLogLevelFlags log_level,
                    const gchar *message,
                    gpointer user_data)
{
        FuDebug *self = (FuDebug *)user_data;
        g_autofree gchar *timestamp = NULL;
        g_autofree gchar *message_safe = NULL;
        g_autoptr(GString) domain = NULL;

        /* should ignore */
        if (!fu_debug_filter_cb(self, log_domain, log_level))
                return;

        /* make sure passwords never appear in logs */
        message_safe = fu_strpassmask(message);

#ifdef _WIN32
        /* use Windows event log */
        fu_debug_handler_win32(self, log_level, message_safe);
#endif

        /* time header */
        if (!self->no_timestamp) {
                g_autoptr(GDateTime) dt = g_date_time_new_now_utc();
                timestamp = g_strdup_printf("%02i:%02i:%02i.%03i",
                                            g_date_time_get_hour(dt),
                                            g_date_time_get_minute(dt),
                                            g_date_time_get_second(dt),
                                            g_date_time_get_microsecond(dt) / 1000);
        }

        /* pad out domain */
        if (!self->no_domain) {
                /* each file should have set this */
                if (log_domain == NULL)
                        log_domain = "FIXME";
                domain = g_string_new(log_domain);
                for (gsize i = domain->len; i < 20; i++)
                        g_string_append(domain, " ");
        }

        /* to file */
        if (!self->console) {
                g_autofree gchar *ascii_message = g_str_to_ascii(message_safe, NULL);
                if (timestamp != NULL)
                        g_printerr("%s ", timestamp);
                if (domain != NULL)
                        g_printerr("%s ", domain->str);
                g_printerr("%s\n", ascii_message);
                return;
        }

        /* plain output */
        if (g_getenv("NO_COLOR") != NULL) {
                if (timestamp != NULL)
                        g_printerr("%s ", timestamp);
                if (domain != NULL)
                        g_printerr("%s ", domain->str);
                g_printerr("%s\n", message_safe);
                return;
        }

        /* to screen */
        switch (log_level) {
        case G_LOG_LEVEL_ERROR:
        case G_LOG_LEVEL_CRITICAL:
        case G_LOG_LEVEL_WARNING:
                /* critical in red */
                if (timestamp != NULL)
                        g_printerr("%c[%dm%s ", 0x1B, 32, timestamp);
                if (domain != NULL)
                        g_printerr("%s ", domain->str);
                g_printerr("%c[%dm%s\n%c[%dm", 0x1B, 31, message_safe, 0x1B, 0);
                break;
        default:
                /* debug in blue */
                if (timestamp != NULL)
                        g_printerr("%c[%dm%s ", 0x1B, 32, timestamp);
                if (domain != NULL)
                        g_printerr("%s ", domain->str);
                g_printerr("%c[%dm%s\n%c[%dm", 0x1B, 34, message_safe, 0x1B, 0);
                break;
        }
}

static gboolean
fu_debug_verbose_arg_cb(const gchar *option_name,
                        const gchar *value,
                        gpointer user_data,
                        GError **error)
{
        FuDebug *self = (FuDebug *)user_data;
        if (self->log_level == G_LOG_LEVEL_MESSAGE) {
                self->log_level = G_LOG_LEVEL_INFO;
                return TRUE;
        }
        if (self->log_level == G_LOG_LEVEL_INFO) {
                self->log_level = G_LOG_LEVEL_DEBUG;
                return TRUE;
        }
        g_set_error_literal(error,
                            G_OPTION_ERROR,
                            G_OPTION_ERROR_FAILED,
                            "No further debug level supported");
        return FALSE;
}

static gboolean
fu_debug_pre_parse_hook(GOptionContext *context, GOptionGroup *group, gpointer data, GError **error)
{
        FuDebug *self = (FuDebug *)data;
        const GOptionEntry entries[] = {
            {"verbose",
             'v',
             G_OPTION_FLAG_NO_ARG,
             G_OPTION_ARG_CALLBACK,
             (GOptionArgFunc)fu_debug_verbose_arg_cb,
             /* TRANSLATORS: turn on all debugging */
             N_("Show debugging information for all domains"),
             NULL},
            {"no-timestamp",
             '\0',
             0,
             G_OPTION_ARG_NONE,
             &self->no_timestamp,
             /* TRANSLATORS: turn on all debugging */
             N_("Do not include timestamp prefix"),
             NULL},
            {"no-domain",
             '\0',
             0,
             G_OPTION_ARG_NONE,
             &self->no_domain,
             /* TRANSLATORS: turn on all debugging */
             N_("Do not include log domain prefix"),
             NULL},
            {"daemon-verbose",
             '\0',
             0,
             G_OPTION_ARG_STRING_ARRAY,
             &self->daemon_verbose,
             /* TRANSLATORS: this is for daemon development */
             N_("Show daemon verbose information for a particular domain"),
             "DOMAIN"},
            {NULL}};

        /* set from FuConfig */
        if (g_strcmp0(g_getenv("FWUPD_VERBOSE"), "*") == 0)
                self->log_level = G_LOG_LEVEL_DEBUG;

        g_option_group_add_entries(group, entries);
        return TRUE;
}

static gboolean
fu_debug_post_parse_hook(GOptionContext *context,
                         GOptionGroup *group,
                         gpointer data,
                         GError **error)
{
        FuDebug *self = (FuDebug *)data;

        /* for compat */
        if (self->log_level == G_LOG_LEVEL_DEBUG)
                (void)g_setenv("FWUPD_VERBOSE", "1", FALSE);

        /* redirect all domains */
        g_log_set_default_handler(fu_debug_handler_cb, self);

        /* are we on an actual TTY? */
        self->console = (isatty(fileno(stderr)) == 1);
        g_info("verbose to %s (on console %i)",
               fu_debug_log_level_to_string(self->log_level),
               self->console);

        return TRUE;
}

#ifdef _WIN32
static void
fu_debug_setup_event_source(FuDebug *self)
{
        HKEY key;
        gchar msgfile[MAX_PATH];
        DWORD dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;

        if (RegCreateKeyExA(HKEY_LOCAL_MACHINE,
                            "SYSTEM\\CurrentControlSet\\Services\\"
                            "EventLog\\Application\\fwupd",
                            0,
                            NULL,
                            REG_OPTION_NON_VOLATILE,
                            KEY_SET_VALUE,
                            NULL,
                            &key,
                            NULL) != ERROR_SUCCESS) {
                g_warning("RegCreateKeyExA failed [%u]", (guint)GetLastError());
                return;
        }
        GetModuleFileNameA(NULL, msgfile, MAX_PATH);
        RegSetValueExA(key,
                       "EventMessageFile",
                       0,
                       REG_EXPAND_SZ,
                       (BYTE *)msgfile,
                       strlen(msgfile) + 1);
        RegSetValueExA(key, "TypesSupported", 0, REG_DWORD, (BYTE *)&dwData, sizeof(dwData));
        RegCloseKey(key);

        /* good to go */
        self->event_source = RegisterEventSourceA(NULL, "fwupd");
}
#endif

/* (transfer): full */
GOptionGroup *
fu_debug_get_option_group(void)
{
        FuDebug *self = g_new0(FuDebug, 1);
        self->log_level = G_LOG_LEVEL_MESSAGE;
        self->group = g_option_group_new("debug",
                                         /* TRANSLATORS: for the --verbose arg */
                                         _("Debugging Options"),
                                         /* TRANSLATORS: for the --verbose arg */
                                         _("Show debugging options"),
                                         self,
                                         (GDestroyNotify)fu_debug_free);
        g_option_group_set_parse_hooks(self->group,
                                       fu_debug_pre_parse_hook,
                                       fu_debug_post_parse_hook);
#ifdef _WIN32
        fu_debug_setup_event_source(self);
#endif
        return g_option_group_ref(self->group);
}

1	/*
2	* Copyright 2010 Richard Hughes <richard@hughsie.com>
3	*
4	* SPDX-License-Identifier: LGPL-2.1-or-later
5	*/
6
7	#define G_LOG_DOMAIN "FuDebug"
8
9	#include "config.h"
10
11	#include <fwupdplugin.h>
12
13	#include <fu-debug.h>
14	#include <glib/gi18n.h>
15	#include <stdio.h>
16	#include <unistd.h>
17
18	#ifdef _WIN32
19	#include <fwupd-windows.h>
20	#include <windows.h>
21	#endif
22
23	typedef struct {
24	GOptionGroup *group;
25	GLogLevelFlags log_level;
26	gboolean console;
27	gboolean no_timestamp;
28	gboolean no_domain;
29	gchar **daemon_verbose;
30	#ifdef _WIN32
31	HANDLE event_source;
32	#endif
33	} FuDebug;
34
35	static const gchar *
36	fu_debug_log_level_to_string(GLogLevelFlags log_level)	89✔
37	{
38	if (log_level == G_LOG_LEVEL_ERROR)	89✔
39	return "error";	×
40	if (log_level == G_LOG_LEVEL_CRITICAL)
41	return "critical";	×
42	if (log_level == G_LOG_LEVEL_WARNING)
43	return "warning";	×
44	if (log_level == G_LOG_LEVEL_MESSAGE)
45	return "message";	58✔
46	if (log_level == G_LOG_LEVEL_INFO)
47	return "info";	2✔
48	if (log_level == G_LOG_LEVEL_DEBUG)
49	return "debug";	29✔
50	return NULL;
51	}
52
53	static void
54	fu_debug_free(FuDebug *self)	×
55	{
56	g_option_group_set_parse_hooks(self->group, NULL, NULL);	×
57	g_option_group_unref(self->group);	×
58	g_strfreev(self->daemon_verbose);	×
59	#ifdef _WIN32
60	DeregisterEventSource(self->event_source);
61	#endif
62	g_free(self);	×
63	}	×
64
65	static gboolean
66	fu_debug_filter_cb(FuDebug self, const gchar log_domain, GLogLevelFlags log_level)	2,368,635✔
67	{
68	/* trivial */
69	if (log_level <= self->log_level)	2,368,635✔
70	return TRUE;
71
72	/* filter on domain */
73	if (self->daemon_verbose != NULL && log_domain != NULL)	2,358,096✔
74	return g_strv_contains((const char const )self->daemon_verbose, log_domain);	×
75
76	/* nope */
77	return FALSE;
78	}
79
80	#ifdef _WIN32
81	static void
82	fu_debug_handler_win32(FuDebug self, GLogLevelFlags log_level, const gchar msg)
83	{
84	WORD ev_type = 0x0;
85
86	/* nothing to do */
87	if (self->event_source == NULL)
88	return;
89
90	/* map levels */
91	switch (log_level) {
92	case G_LOG_LEVEL_INFO:
93	case G_LOG_LEVEL_MESSAGE:
94	ev_type = EVENTLOG_INFORMATION_TYPE;
95	break;
96	case G_LOG_LEVEL_WARNING:
97	ev_type = EVENTLOG_WARNING_TYPE;
98	break;
99	case G_LOG_LEVEL_ERROR:
100	case G_LOG_LEVEL_CRITICAL:
101	ev_type = EVENTLOG_ERROR_TYPE;
102	break;
103	default:
104	return;
105	break;
106	}
107
108	/* add to log */
109	ReportEventA(self->event_source,
110	ev_type,
111	FWUPD_CATEGORY_GENERIC,
112	FWUPD_MESSAGE_GENERIC,
113	NULL,
114	1,
115	0,
116	(const char **)&msg,
117	NULL);
118	}
119	#endif
120
121	static void
122	fu_debug_handler_cb(const gchar *log_domain,	2,368,635✔
123	GLogLevelFlags log_level,
124	const gchar *message,
125	gpointer user_data)
126	{
127	FuDebug self = (FuDebug )user_data;	2,368,635✔
128	g_autofree gchar *timestamp = NULL;	2,368,635✔
129	g_autofree gchar *message_safe = NULL;	2,368,635✔
130	g_autoptr(GString) domain = NULL;	2,368,635✔
131
132	/* should ignore */
133	if (!fu_debug_filter_cb(self, log_domain, log_level))	2,368,635✔
134	return;
135
136	/* make sure passwords never appear in logs */
137	message_safe = fu_strpassmask(message);	10,539✔
138
139	#ifdef _WIN32
140	/* use Windows event log */
141	fu_debug_handler_win32(self, log_level, message_safe);
142	#endif
143
144	/* time header */
145	if (!self->no_timestamp) {	10,539✔
146	g_autoptr(GDateTime) dt = g_date_time_new_now_utc();	10,378✔
147	timestamp = g_strdup_printf("%02i:%02i:%02i.%03i",	10,378✔
148	g_date_time_get_hour(dt),
149	g_date_time_get_minute(dt),
150	g_date_time_get_second(dt),
151	g_date_time_get_microsecond(dt) / 1000);	10,378✔
152	}
153
154	/* pad out domain */
155	if (!self->no_domain) {	10,539✔
156	/* each file should have set this */
157	if (log_domain == NULL)	10,539✔
158	log_domain = "FIXME";	×
159	domain = g_string_new(log_domain);	10,539✔
160	for (gsize i = domain->len; i < 20; i++)	132,087✔
161	g_string_append(domain, " ");	243,096✔
162	}
163
164	/* to file */
165	if (!self->console) {	10,539✔
166	g_autofree gchar *ascii_message = g_str_to_ascii(message_safe, NULL);	20,688✔
167	if (timestamp != NULL)	10,344✔
168	g_printerr("%s ", timestamp);	10,344✔
169	if (domain != NULL)	10,344✔
170	g_printerr("%s ", domain->str);	10,344✔
171	g_printerr("%s\n", ascii_message);	10,344✔
172	return;	10,344✔
173	}
174
175	/* plain output */
176	if (g_getenv("NO_COLOR") != NULL) {	195✔
177	if (timestamp != NULL)	34✔
178	g_printerr("%s ", timestamp);	34✔
179	if (domain != NULL)	34✔
180	g_printerr("%s ", domain->str);	34✔
181	g_printerr("%s\n", message_safe);	34✔
182	return;	34✔
183	}
184
185	/* to screen */
186	switch (log_level) {	161✔
187	case G_LOG_LEVEL_ERROR:	5✔
188	case G_LOG_LEVEL_CRITICAL:
189	case G_LOG_LEVEL_WARNING:
190	/* critical in red */
191	if (timestamp != NULL)	5✔
UNCOV 192	g_printerr("%c[%dm%s ", 0x1B, 32, timestamp);	×
193	if (domain != NULL)	5✔
194	g_printerr("%s ", domain->str);	5✔
195	g_printerr("%c[%dm%s\n%c[%dm", 0x1B, 31, message_safe, 0x1B, 0);	5✔
196	break;	5✔
197	default:	156✔
198	/* debug in blue */
199	if (timestamp != NULL)	156✔
200	g_printerr("%c[%dm%s ", 0x1B, 32, timestamp);	×
201	if (domain != NULL)	156✔
202	g_printerr("%s ", domain->str);	156✔
203	g_printerr("%c[%dm%s\n%c[%dm", 0x1B, 34, message_safe, 0x1B, 0);	156✔
204	break;	156✔
205	}
206	}
207
208	static gboolean
209	fu_debug_verbose_arg_cb(const gchar *option_name,	60✔
210	const gchar *value,
211	gpointer user_data,
212	GError **error)
213	{
214	FuDebug self = (FuDebug )user_data;	60✔
215	if (self->log_level == G_LOG_LEVEL_MESSAGE) {	60✔
216	self->log_level = G_LOG_LEVEL_INFO;	31✔
217	return TRUE;	31✔
218	}
219	if (self->log_level == G_LOG_LEVEL_INFO) {	29✔
220	self->log_level = G_LOG_LEVEL_DEBUG;	29✔
221	return TRUE;	29✔
222	}
223	g_set_error_literal(error,	×
224	G_OPTION_ERROR,
225	G_OPTION_ERROR_FAILED,
226	"No further debug level supported");
227	return FALSE;	×
228	}
229
230	static gboolean
231	fu_debug_pre_parse_hook(GOptionContext context, GOptionGroup group, gpointer data, GError **error)	91✔
232	{
233	FuDebug self = (FuDebug )data;	91✔
234	const GOptionEntry entries[] = {	91✔
235	{"verbose",
236	'v',
237	G_OPTION_FLAG_NO_ARG,
238	G_OPTION_ARG_CALLBACK,
239	(GOptionArgFunc)fu_debug_verbose_arg_cb,
240	/* TRANSLATORS: turn on all debugging */
241	N_("Show debugging information for all domains"),
242	NULL},
243	{"no-timestamp",
244	'\0',
245	0,
246	G_OPTION_ARG_NONE,
247	&self->no_timestamp,	91✔
248	/* TRANSLATORS: turn on all debugging */
249	N_("Do not include timestamp prefix"),
250	NULL},
251	{"no-domain",
252	'\0',
253	0,
254	G_OPTION_ARG_NONE,
255	&self->no_domain,	91✔
256	/* TRANSLATORS: turn on all debugging */
257	N_("Do not include log domain prefix"),
258	NULL},
259	{"daemon-verbose",
260	'\0',
261	0,
262	G_OPTION_ARG_STRING_ARRAY,
263	&self->daemon_verbose,	91✔
264	/* TRANSLATORS: this is for daemon development */
265	N_("Show daemon verbose information for a particular domain"),
266	"DOMAIN"},
267	{NULL}};
268
269	/* set from FuConfig */
270	if (g_strcmp0(g_getenv("FWUPD_VERBOSE"), "*") == 0)	91✔
271	self->log_level = G_LOG_LEVEL_DEBUG;	×
272
273	g_option_group_add_entries(group, entries);	91✔
274	return TRUE;	91✔
275	}
276
277	static gboolean
278	fu_debug_post_parse_hook(GOptionContext *context,	89✔
279	GOptionGroup *group,
280	gpointer data,
281	GError **error)
282	{
283	FuDebug self = (FuDebug )data;	89✔
284
285	/* for compat */
286	if (self->log_level == G_LOG_LEVEL_DEBUG)	89✔
287	(void)g_setenv("FWUPD_VERBOSE", "1", FALSE);	29✔
288
289	/* redirect all domains */
290	g_log_set_default_handler(fu_debug_handler_cb, self);	89✔
291
292	/* are we on an actual TTY? */
293	self->console = (isatty(fileno(stderr)) == 1);	89✔
294	g_info("verbose to %s (on console %i)",	89✔
295	fu_debug_log_level_to_string(self->log_level),
296	self->console);
297
298	return TRUE;	89✔
299	}
300
301	#ifdef _WIN32
302	static void
303	fu_debug_setup_event_source(FuDebug *self)
304	{
305	HKEY key;
306	gchar msgfile[MAX_PATH];
307	DWORD dwData = EVENTLOG_ERROR_TYPE \| EVENTLOG_WARNING_TYPE \| EVENTLOG_INFORMATION_TYPE;
308
309	if (RegCreateKeyExA(HKEY_LOCAL_MACHINE,
310	"SYSTEM\\CurrentControlSet\\Services\\"
311	"EventLog\\Application\\fwupd",
312	0,
313	NULL,
314	REG_OPTION_NON_VOLATILE,
315	KEY_SET_VALUE,
316	NULL,
317	&key,
318	NULL) != ERROR_SUCCESS) {
319	g_warning("RegCreateKeyExA failed [%u]", (guint)GetLastError());
320	return;
321	}
322	GetModuleFileNameA(NULL, msgfile, MAX_PATH);
323	RegSetValueExA(key,
324	"EventMessageFile",
325	0,
326	REG_EXPAND_SZ,
327	(BYTE *)msgfile,
328	strlen(msgfile) + 1);
329	RegSetValueExA(key, "TypesSupported", 0, REG_DWORD, (BYTE *)&dwData, sizeof(dwData));
330	RegCloseKey(key);
331
332	/* good to go */
333	self->event_source = RegisterEventSourceA(NULL, "fwupd");
334	}
335	#endif
336
337	/* (transfer): full */
338	GOptionGroup *
339	fu_debug_get_option_group(void)	91✔
340	{
341	FuDebug *self = g_new0(FuDebug, 1);	91✔
342	self->log_level = G_LOG_LEVEL_MESSAGE;	91✔
343	self->group = g_option_group_new("debug",	91✔
344	/* TRANSLATORS: for the --verbose arg */
345	_("Debugging Options"),	91✔
346	/* TRANSLATORS: for the --verbose arg */
347	_("Show debugging options"),	91✔
348	self,
349	(GDestroyNotify)fu_debug_free);
350	g_option_group_set_parse_hooks(self->group,	91✔
351	fu_debug_pre_parse_hook,
352	fu_debug_post_parse_hook);
353	#ifdef _WIN32
354	fu_debug_setup_event_source(self);
355	#endif
356	return g_option_group_ref(self->group);	91✔
357	}

fwupd / fwupd / 11642543588

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous