1/*-
2 * Copyright (c) 2016-2021 Netflix, Inc.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 *    notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 *    notice, this list of conditions and the following disclaimer in the
11 *    documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23 * SUCH DAMAGE.
24 */
25
26#include <sys/cdefs.h>
27#include <ctype.h>
28#include <efivar.h>
29#include <efivar-dp.h>
30#include <err.h>
31#include <errno.h>
32#include <fcntl.h>
33#include <getopt.h>
34#include <stdarg.h>
35#include <stdbool.h>
36#include <stddef.h>
37#include <stdio.h>
38#include <stdlib.h>
39#include <string.h>
40#include <unistd.h>
41#include "efiutil.h"
42#include "efichar.h"
43
44/* options descriptor */
45static struct option longopts[] = {
46	{ "append",		no_argument,		NULL,	'a' },
47	{ "ascii",		no_argument,		NULL,	'A' },
48	{ "attributes",		required_argument,	NULL,	't' },
49	{ "binary",		no_argument,		NULL,	'b' },
50	{ "delete",		no_argument,		NULL,   'D' },
51	{ "device",		no_argument,		NULL,   'd' },
52	{ "device-path",	no_argument,		NULL,   'd' },
53	{ "fromfile",		required_argument,	NULL,	'f' },
54	{ "guid",		no_argument,		NULL,	'g' },
55	{ "hex",		no_argument,		NULL,	'H' },
56	{ "list-guids",		no_argument,		NULL,	'L' },
57	{ "list",		no_argument,		NULL,	'l' },
58	{ "load-option",	no_argument,		NULL,	'O' },
59	{ "name",		required_argument,	NULL,	'n' },
60	{ "no-name",		no_argument,		NULL,	'N' },
61	{ "print",		no_argument,		NULL,	'p' },
62//	{ "print-decimal",	no_argument,		NULL,	'd' }, /* unimplemnted clash with linux version */
63	{ "quiet",		no_argument,		NULL,	'q' },
64	{ "raw-guid",		no_argument,		NULL,   'R' },
65	{ "utf8",		no_argument,		NULL,	'u' },
66	{ "write",		no_argument,		NULL,	'w' },
67	{ NULL,			0,			NULL,	0 }
68};
69
70
71static bool aflag, Aflag, bflag, dflag, Dflag, gflag, Hflag, Nflag,
72	lflag, Lflag, Rflag, wflag, pflag, uflag, load_opt_flag, quiet;
73static char *varname;
74static char *fromfile;
75static u_long attrib = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;
76
77static void
78usage(void)
79{
80
81	errx(1, "efivar [-abdDHlLNpqRtuw] [-n name] [-f file] [--append] [--ascii]\n"
82	    "\t[--attributes] [--binary] [--delete] [--fromfile file] [--hex]\n"
83	    "\t[--list-guids] [--list] [--load-option] [--name name] [--no-name]\n"
84	    "\t[--print] [--print-decimal] [--raw-guid] [--utf8] [--write]\n"
85	    "\t[--quiet]\n"
86	    "\tname[=value]");
87}
88
89static void
90rep_err(int eval, const char *fmt, ...)
91{
92	va_list ap;
93
94	if (quiet)
95		exit(eval);
96
97	va_start(ap, fmt);
98	verr(eval, fmt, ap);
99	va_end(ap);
100}
101
102static void
103rep_errx(int eval, const char *fmt, ...)
104{
105	va_list ap;
106
107	if (quiet)
108		exit(eval);
109
110	va_start(ap, fmt);
111	verrx(eval, fmt, ap);
112	va_end(ap);
113}
114
115static void
116breakdown_name(char *name, efi_guid_t *guid, char **vname)
117{
118	char *cp, *ocp;
119
120	ocp = NULL;
121	while (true) {
122		cp = strrchr(name, '-');
123		if (cp == NULL) {
124			if (ocp != NULL)
125				*ocp = '-';
126			rep_errx(1, "Invalid guid in: %s", name);
127		}
128		if (ocp != NULL)
129			*ocp = '-';
130		*vname = cp + 1;
131		*cp = '\0';
132		ocp = cp;
133		if (efi_name_to_guid(name, guid) >= 0)
134			break;
135	}
136}
137
138static uint8_t *
139get_value(char *val, size_t *datalen)
140{
141	static char buffer[16*1024];
142
143	if (val != NULL) {
144		*datalen = strlen(val);
145		return ((uint8_t *)val);
146	}
147	/* Read from stdin */
148	*datalen = sizeof(buffer);
149	*datalen = read(0, buffer, *datalen);
150	return ((uint8_t *)buffer);
151}
152
153static void
154append_variable(char *name, char *val)
155{
156	char *vname;
157	efi_guid_t guid;
158	size_t datalen;
159	uint8_t *data;
160
161	breakdown_name(name, &guid, &vname);
162	data = get_value(val, &datalen);
163	if (efi_append_variable(guid, vname, data, datalen, attrib) < 0)
164		rep_err(1, "efi_append_variable");
165}
166
167static void
168delete_variable(char *name)
169{
170	char *vname;
171	efi_guid_t guid;
172
173	breakdown_name(name, &guid, &vname);
174	if (efi_del_variable(guid, vname) < 0)
175		rep_err(1, "efi_del_variable");
176}
177
178static void
179write_variable(char *name, char *val)
180{
181	char *vname;
182	efi_guid_t guid;
183	size_t datalen;
184	uint8_t *data;
185
186	breakdown_name(name, &guid, &vname);
187	data = get_value(val, &datalen);
188	if (efi_set_variable(guid, vname, data, datalen, attrib) < 0)
189		rep_err(1, "efi_set_variable");
190}
191
192static void
193devpath_dump(uint8_t *data, size_t datalen)
194{
195	char buffer[1024];
196
197	efidp_format_device_path(buffer, sizeof(buffer),
198	    (const_efidp)data, datalen);
199	if (!Nflag)
200		printf(": ");
201	printf("%s\n", buffer);
202}
203
204static void
205pretty_guid(efi_guid_t *guid, char **gname)
206{
207	char *pretty = NULL;
208
209	if (gflag)
210		efi_guid_to_name(guid, &pretty);
211
212	if (pretty == NULL)
213		efi_guid_to_str(guid, gname);
214	else
215		*gname = pretty;
216}
217
218static void
219print_var(efi_guid_t *guid, char *name)
220{
221	uint32_t att;
222	uint8_t *data;
223	size_t datalen;
224	char *gname = NULL;
225	int rv;
226
227	if (guid)
228		pretty_guid(guid, &gname);
229	if (pflag || fromfile) {
230		if (fromfile) {
231			int fd;
232
233			fd = open(fromfile, O_RDONLY);
234			if (fd < 0)
235				rep_err(1, "open %s", fromfile);
236			data = malloc(64 * 1024);
237			if (data == NULL)
238				rep_err(1, "malloc");
239			datalen = read(fd, data, 64 * 1024);
240			if ((ssize_t)datalen < 0)
241				rep_err(1, "read");
242			if (datalen == 0)
243				rep_errx(1, "empty file");
244			close(fd);
245		} else {
246			rv = efi_get_variable(*guid, name, &data, &datalen, &att);
247			if (rv < 0)
248				rep_err(1, "fetching %s-%s", gname, name);
249		}
250
251
252		if (!Nflag)
253			printf("%s-%s\n", gname, name);
254		if (load_opt_flag)
255			efi_print_load_option(data, datalen, Aflag, bflag, uflag);
256		else if (Aflag)
257			asciidump(data, datalen);
258		else if (uflag)
259			utf8dump(data, datalen);
260		else if (bflag)
261			bindump(data, datalen);
262		else if (dflag)
263			devpath_dump(data, datalen);
264		else
265			hexdump(data, datalen);
266	} else {
267		printf("%s-%s", gname, name);
268	}
269	free(gname);
270	if (!Nflag)
271		printf("\n");
272}
273
274static void
275print_variable(char *name)
276{
277	char *vname;
278	efi_guid_t guid;
279
280	breakdown_name(name, &guid, &vname);
281	print_var(&guid, vname);
282}
283
284static void
285print_variables(void)
286{
287	int rv;
288	char *name = NULL;
289	efi_guid_t *guid = NULL;
290
291	while ((rv = efi_get_next_variable_name(&guid, &name)) > 0)
292		print_var(guid, name);
293
294	if (rv < 0)
295		rep_err(1, "Error listing names");
296}
297
298static void
299print_known_guid(void)
300{
301	struct uuid_table *tbl;
302	int i, n;
303
304	n = efi_known_guid(&tbl);
305	for (i = 0; i < n; i++)
306		printf("%s %s\n", tbl[i].uuid_str, tbl[i].name);
307}
308
309static void
310parse_args(int argc, char **argv)
311{
312	int ch, i;
313
314	while ((ch = getopt_long(argc, argv, "aAbdDf:gHlLNn:OpqRt:uw",
315		    longopts, NULL)) != -1) {
316		switch (ch) {
317		case 'a':
318			aflag = true;
319			break;
320		case 'A':
321			Aflag = true;
322			break;
323		case 'b':
324			bflag = true;
325			break;
326		case 'd':
327			dflag = true;
328			break;
329		case 'D':
330			Dflag = true;
331			break;
332		case 'g':
333			gflag = true;
334			break;
335		case 'H':
336			Hflag = true;
337			break;
338		case 'l':
339			lflag = true;
340			break;
341		case 'L':
342			Lflag = true;
343			break;
344		case 'n':
345			varname = optarg;
346			break;
347		case 'N':
348			Nflag = true;
349			break;
350		case 'O':
351			load_opt_flag = true;
352			break;
353		case 'p':
354			pflag = true;
355			break;
356		case 'q':
357			quiet = true;
358			break;
359		case 'R':
360			Rflag = true;
361			break;
362		case 't':
363			attrib = strtoul(optarg, NULL, 16);
364			break;
365		case 'u':
366			uflag = true;
367			break;
368		case 'w':
369			wflag = true;
370			break;
371		case 'f':
372			free(fromfile);
373			fromfile = strdup(optarg);
374			break;
375		case 0:
376			rep_errx(1, "unknown or unimplemented option\n");
377			break;
378		default:
379			usage();
380		}
381	}
382	argc -= optind;
383	argv += optind;
384
385	if (argc == 1)
386		varname = argv[0];
387
388	if ((int)aflag + (int)Dflag + (int)wflag > 1) {
389		warnx("Can only use one of -a (--append), "
390		    "-D (--delete) and -w (--write)");
391		usage();
392	}
393
394	if ((int)aflag + (int)Dflag + (int)wflag > 0 && varname == NULL) {
395		warnx("Must specify a variable for -a (--append), "
396		    "-D (--delete) or -w (--write)");
397		usage();
398	}
399
400	if (aflag)
401		append_variable(varname, NULL);
402	else if (Dflag)
403		delete_variable(varname);
404	else if (wflag)
405		write_variable(varname, NULL);
406	else if (Lflag)
407		print_known_guid();
408	else if (fromfile) {
409		Nflag = true;
410		print_var(NULL, NULL);
411	} else if (varname) {
412		pflag = true;
413		print_variable(varname);
414	} else if (argc > 0) {
415		pflag = true;
416		for (i = 0; i < argc; i++)
417			print_variable(argv[i]);
418	} else
419		print_variables();
420}
421
422int
423main(int argc, char **argv)
424{
425
426	parse_args(argc, argv);
427}
428