Index: head/lib/libefivar/efivar.c =================================================================== --- head/lib/libefivar/efivar.c (revision 325683) +++ head/lib/libefivar/efivar.c (revision 325684) @@ -1,400 +1,400 @@ /*- * Copyright (c) 2016 Netflix, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include "efichar.h" static int efi_fd = -2; #define Z { 0, 0, 0, 0, 0, { 0 } } const efi_guid_t efi_guid_empty = Z; static struct uuid_table guid_tbl [] = { { "00000000-0000-0000-0000-000000000000", "zero", Z }, { "093e0fae-a6c4-4f50-9f1b-d41e2b89c19a", "sha512", Z }, { "0abba7dc-e516-4167-bbf5-4d9d1c739416", "redhat", Z }, { "0b6e5233-a65c-44c9-9407-d9ab83bfc8bd", "sha224", Z }, { "126a762d-5758-4fca-8531-201a7f57f850", "lenovo_boot_menu", Z }, { "3bd2a492-96c0-4079-b420-fcf98ef103ed", "x509_sha256", Z }, { "3c5766e8-269c-4e34-aa14-ed776e85b3b6", "rsa2048", Z }, { "3CC24E96-22C7-41D8-8863-8E39DCDCC2CF", "lenovo", Z }, { "3f7e615b-0d45-4f80-88dc-26b234958560", "lenovo_diag", Z }, { "446dbf63-2502-4cda-bcfa-2465d2b0fe9d", "x509_sha512", Z }, { "4aafd29d-68df-49ee-8aa9-347d375665a7", "pkcs7_cert", Z }, { "605dab50-e046-4300-abb6-3dd810dd8b23", "shim", Z }, { "665d3f60-ad3e-4cad-8e26-db46eee9f1b5", "lenovo_rescue", Z }, { "67f8444f-8743-48f1-a328-1eaab8736080", "rsa2048_sha1", Z }, { "7076876e-80c2-4ee6-aad2-28b349a6865b", "x509_sha384", Z }, { "721c8b66-426c-4e86-8e99-3457c46ab0b9", "lenovo_setup", Z }, { "77fa9abd-0359-4d32-bd60-28f4e78f784b", "microsoft", Z }, { "7FACC7B6-127F-4E9C-9C5D-080F98994345", "lenovo_2", Z }, { "826ca512-cf10-4ac9-b187-be01496631bd", "sha1", Z }, { "82988420-7467-4490-9059-feb448dd1963", "lenovo_me_config", Z }, { "8be4df61-93ca-11d2-aa0d-00e098032b8c", "global", Z }, { "a5c059a1-94e4-4aa7-87b5-ab155c2bf072", "x509_cert", Z }, { "a7717414-c616-4977-9420-844712a735bf", "rsa2048_sha256_cert", Z }, { "a7d8d9a6-6ab0-4aeb-ad9d-163e59a7a380", "lenovo_diag_splash", Z }, { "ade9e48f-9cb8-98e6-31af-b4e6009e2fe3", "redhat_2", Z }, { "bc7838d2-0f82-4d60-8316-c068ee79d25b", "lenovo_msg", Z }, { "c1c41626-504c-4092-aca9-41f936934328", "sha256", Z }, { "c57ad6b7-0515-40a8-9d21-551652854e37", "shell", Z }, { "d719b2cb-3d3a-4596-a3bc-dad00e67656f", "security", Z }, { "e2b36190-879b-4a3d-ad8d-f2e7bba32784", "rsa2048_sha256", Z }, { "ff3e5307-9fd0-48c9-85f1-8ad56c701e01", "sha384", Z }, { "f46ee6f4-4785-43a3-923d-7f786c3c8479", "lenovo_startup_interrupt", Z }, { "ffffffff-ffff-ffff-ffff-ffffffffffff", "zzignore-this-guid", Z }, }; #undef Z static void efi_guid_tbl_compile(void) { size_t i; uint32_t status; static int done = 0; if (done) return; for (i = 0; i < nitems(guid_tbl); i++) { uuid_from_string(guid_tbl[i].uuid_str, &guid_tbl[i].guid, &status); /* all f's is a bad version, so ignore that error */ if (status != uuid_s_ok && status != uuid_s_bad_version) fprintf(stderr, "Can't convert %s to a uuid for %s: %d\n", guid_tbl[i].uuid_str, guid_tbl[i].name, (int)status); } done = 1; } int efi_known_guid(struct uuid_table **tbl) { *tbl = guid_tbl; return (nitems(guid_tbl)); } static int efi_open_dev(void) { if (efi_fd == -2) efi_fd = open("/dev/efi", O_RDWR); if (efi_fd < 0) efi_fd = -1; else efi_guid_tbl_compile(); return (efi_fd); } static void efi_var_reset(struct efi_var_ioc *var) { var->name = NULL; var->namesize = 0; memset(&var->vendor, 0, sizeof(var->vendor)); var->attrib = 0; var->data = NULL; var->datasize = 0; } static int rv_to_linux_rv(int rv) { if (rv == 0) rv = 1; else rv = -errno; return (rv); } int efi_append_variable(efi_guid_t guid, const char *name, uint8_t *data, size_t data_size, uint32_t attributes) { return efi_set_variable(guid, name, data, data_size, - attributes | EFI_VARIABLE_APPEND_WRITE, 0); + attributes | EFI_VARIABLE_APPEND_WRITE); } int efi_del_variable(efi_guid_t guid, const char *name) { /* data_size of 0 deletes the variable */ - return efi_set_variable(guid, name, NULL, 0, 0, 0); + return efi_set_variable(guid, name, NULL, 0, 0); } int efi_get_variable(efi_guid_t guid, const char *name, uint8_t **data, size_t *data_size, uint32_t *attributes) { struct efi_var_ioc var; int rv; static uint8_t buf[1024*32]; if (efi_open_dev() == -1) return -1; efi_var_reset(&var); rv = utf8_to_ucs2(name, &var.name, &var.namesize); if (rv != 0) goto errout; var.vendor = guid; var.data = buf; var.datasize = sizeof(buf); rv = ioctl(efi_fd, EFIIOC_VAR_GET, &var); if (data_size != NULL) *data_size = var.datasize; if (data != NULL) *data = buf; if (attributes != NULL) *attributes = var.attrib; errout: free(var.name); return rv_to_linux_rv(rv); } int efi_get_variable_attributes(efi_guid_t guid, const char *name, uint32_t *attributes) { /* Make sure this construct works -- I think it will fail */ return efi_get_variable(guid, name, NULL, NULL, attributes); } int efi_get_variable_size(efi_guid_t guid, const char *name, size_t *size) { /* XXX check to make sure this matches the linux value */ *size = 0; return efi_get_variable(guid, name, NULL, size, NULL); } int efi_get_next_variable_name(efi_guid_t **guid, char **name) { struct efi_var_ioc var; int rv; static efi_char *buf; static size_t buflen = 256 * sizeof(efi_char); static efi_guid_t retguid; size_t size; if (efi_open_dev() == -1) return -1; /* * Always allocate enough for an extra NUL on the end, but don't tell * the IOCTL about it so we can NUL terminate the name before converting * it to UTF8. */ if (buf == NULL) buf = malloc(buflen + sizeof(efi_char)); again: efi_var_reset(&var); var.name = buf; var.namesize = buflen; if (*name == NULL) { *buf = 0; /* GUID zeroed in var_reset */ } else { rv = utf8_to_ucs2(*name, &var.name, &size); if (rv != 0) goto errout; var.vendor = **guid; } rv = ioctl(efi_fd, EFIIOC_VAR_NEXT, &var); if (rv == 0 && var.name == NULL) { /* * Variable name not long enough, so allocate more space for the * name and try again. As above, mind the NUL we add. */ void *new = realloc(buf, var.namesize + sizeof(efi_char)); if (new == NULL) { rv = -1; errno = ENOMEM; goto done; } buflen = var.namesize; buf = new; goto again; } if (rv == 0) { free(*name); /* Free last name, to avoid leaking */ *name = NULL; /* Force ucs2_to_utf8 to malloc new space */ var.name[var.namesize / sizeof(efi_char)] = 0; /* EFI doesn't NUL terminate */ rv = ucs2_to_utf8(var.name, name); if (rv != 0) goto errout; retguid = var.vendor; *guid = &retguid; } errout: /* XXX The linux interface expects name to be a static buffer -- fix or leak memory? */ /* XXX for the moment, we free just before we'd leak, but still leak last one */ done: if (rv != 0 && errno == ENOENT) { errno = 0; free(*name); /* Free last name, to avoid leaking */ return 0; } return (rv_to_linux_rv(rv)); } int efi_guid_cmp(const efi_guid_t *guid1, const efi_guid_t *guid2) { uint32_t status; return uuid_compare(guid1, guid2, &status); } int efi_guid_is_zero(const efi_guid_t *guid) { uint32_t status; return uuid_is_nil(guid, &status); } int efi_guid_to_name(efi_guid_t *guid, char **name) { size_t i; uint32_t status; efi_guid_tbl_compile(); for (i = 0; i < nitems(guid_tbl); i++) { if (uuid_equal(guid, &guid_tbl[i].guid, &status)) { *name = strdup(guid_tbl[i].name); return (0); } } return (efi_guid_to_str(guid, name)); } int efi_guid_to_symbol(efi_guid_t *guid __unused, char **symbol __unused) { /* * Unsure what this is used for, efibootmgr doesn't use it. * Leave unimplemented for now. */ return -1; } int efi_guid_to_str(const efi_guid_t *guid, char **sp) { uint32_t status; /* knows efi_guid_t is a typedef of uuid_t */ uuid_to_string(guid, sp, &status); return (status == uuid_s_ok ? 0 : -1); } int efi_name_to_guid(const char *name, efi_guid_t *guid) { size_t i; efi_guid_tbl_compile(); for (i = 0; i < nitems(guid_tbl); i++) { if (strcmp(name, guid_tbl[i].name) == 0) { *guid = guid_tbl[i].guid; return (0); } } return (efi_str_to_guid(name, guid)); } int efi_set_variable(efi_guid_t guid, const char *name, - uint8_t *data, size_t data_size, uint32_t attributes, mode_t mode __unused) + uint8_t *data, size_t data_size, uint32_t attributes) { struct efi_var_ioc var; int rv; if (efi_open_dev() == -1) return -1; efi_var_reset(&var); rv = utf8_to_ucs2(name, &var.name, &var.namesize); if (rv != 0) goto errout; var.vendor = guid; var.data = data; var.datasize = data_size; var.attrib = attributes; rv = ioctl(efi_fd, EFIIOC_VAR_SET, &var); errout: free(var.name); return rv; } int efi_str_to_guid(const char *s, efi_guid_t *guid) { uint32_t status; /* knows efi_guid_t is a typedef of uuid_t */ uuid_from_string(s, guid, &status); return (status == uuid_s_ok ? 0 : -1); } int efi_variables_supported(void) { return efi_open_dev() != -1; } Index: head/lib/libefivar/efivar.h =================================================================== --- head/lib/libefivar/efivar.h (revision 325683) +++ head/lib/libefivar/efivar.h (revision 325684) @@ -1,135 +1,102 @@ /*- * Copyright (c) 2016 Netflix, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer * in this position and unchanged. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * $FreeBSD$ */ #ifndef _EFIVAR_H_ #define _EFIVAR_H_ #include #include #include #include /* Shoud these be elsewhere ? */ #define EFI_VARIABLE_NON_VOLATILE 0x00000001 #define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x00000002 #define EFI_VARIABLE_RUNTIME_ACCESS 0x00000004 #define EFI_VARIABLE_HARDWARE_ERROR_RECORD 0x00000008 #define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS 0x00000010 #define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS \ 0x00000020 #define EFI_VARIABLE_APPEND_WRITE 0x00000040 #if 0 /* todo */ #define EFI_VARIABLE_HAS_AUTH_HEADER #define EFI_VARIABLE_HAS_SIGNATURE #endif #ifndef _EFIVAR_EFI_GUID_T_DEF #define _EFIVAR_EFI_GUID_T_DEF typedef uuid_t efi_guid_t; #endif #if BYTE_ORDER == LITTLE_ENDIAN #define EFI_GUID(a, b, c, d, e0, e1, e2, e3, e4, e5) \ ((efi_guid_t) {(a), (b), (c), (d) >> 8, (d) & 0xff, \ { (e0), (e1), (e2), (e3), (e4), (e5) }}) #else #define EFI_GUID(a, b, c, d, e0, e1, e2, e3, e4, e5) \ ((efi_guid_t) {(a), (b), (c), (d) & 0xff, (d) >> 8, \ { (e0), (e1), (e2), (e3), (e4), (e5) }}) #endif #define EFI_GLOBAL_GUID EFI_GUID(0x8be4df61, 0x93ca, 0x11d2, 0xaa0d, \ 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c) int efi_append_variable(efi_guid_t guid, const char *name, uint8_t *data, size_t data_size, uint32_t attributes); int efi_del_variable(efi_guid_t guid, const char *name); int efi_get_variable(efi_guid_t guid, const char *name, uint8_t **data, size_t *data_size, uint32_t *attributes); int efi_get_variable_attributes(efi_guid_t guid, const char *name, uint32_t *attributes); int efi_get_variable_size(efi_guid_t guid, const char *name, size_t *size); int efi_get_next_variable_name(efi_guid_t **guid, char **name); int efi_guid_cmp(const efi_guid_t *guid1, const efi_guid_t *guid2); int efi_guid_is_zero(const efi_guid_t *guid1); int efi_guid_to_name(efi_guid_t *guid, char **name); int efi_guid_to_symbol(efi_guid_t *guid, char **symbol); int efi_guid_to_str(const efi_guid_t *guid, char **sp); int efi_name_to_guid(const char *name, efi_guid_t *guid); int efi_set_variable(efi_guid_t guid, const char *name, - uint8_t *data, size_t data_size, uint32_t attributes, mode_t mode); + uint8_t *data, size_t data_size, uint32_t attributes); int efi_str_to_guid(const char *s, efi_guid_t *guid); int efi_variables_supported(void); /* FreeBSD extensions */ struct uuid_table { const char *uuid_str; const char *name; efi_guid_t guid; }; int efi_known_guid(struct uuid_table **); extern const efi_guid_t efi_guid_empty; - -/* Stubs that are expected, but aren't really used */ -static inline int -efi_error_get(unsigned int n __unused, char ** const fn __unused, - char ** const func __unused, int *line __unused, - char ** const msg __unused, int *err __unused) -{ - return 0; -} - -static inline int -efi_error_set(const char *fn __unused, const char *func __unused, - int line __unused, int err __unused, const char *fmt __unused, ...) -{ - return 0; -} - -static inline void -efi_error_clear(void) -{ -} - -static inline int -efi_error(const char *fmt __unused, ...) -{ - return 0; -} - -static inline int -efi_error_val(int val __unused, const char *fmt __unused, ...) -{ - return 0; -} #endif /* _EFIVAR_H_ */ Index: head/usr.sbin/efivar/efivar.c =================================================================== --- head/usr.sbin/efivar/efivar.c (revision 325683) +++ head/usr.sbin/efivar/efivar.c (revision 325684) @@ -1,362 +1,362 @@ /*- * Copyright (c) 2016 Netflix, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include "efiutil.h" #include "efichar.h" /* options descriptor */ static struct option longopts[] = { { "append", no_argument, NULL, 'a' }, { "ascii", no_argument, NULL, 'A' }, { "attributes", required_argument, NULL, 't' }, { "binary", no_argument, NULL, 'b' }, { "delete", no_argument, NULL, 'D' }, { "device", no_argument, NULL, 'd' }, { "device-path", no_argument, NULL, 'd' }, { "fromfile", required_argument, NULL, 'f' }, { "guid", no_argument, NULL, 'g' }, { "hex", no_argument, NULL, 'H' }, { "list-guids", no_argument, NULL, 'L' }, { "list", no_argument, NULL, 'l' }, { "load-option", no_argument, NULL, 'O' }, { "name", required_argument, NULL, 'n' }, { "no-name", no_argument, NULL, 'N' }, { "print", no_argument, NULL, 'p' }, { "print-decimal", no_argument, NULL, 'd' }, { "raw-guid", no_argument, NULL, 'R' }, { "utf8", no_argument, NULL, 'u' }, { "write", no_argument, NULL, 'w' }, { NULL, 0, NULL, 0 } }; static int aflag, Aflag, bflag, dflag, Dflag, gflag, Hflag, Nflag, lflag, Lflag, Rflag, wflag, pflag, uflag, load_opt_flag; static char *varname; static u_long attrib = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS; static void usage(void) { errx(1, "efivar [-abdDHlLNpRtuw] [-n name] [-f file] [--append] [--ascii]\n" "\t[--attributes] [--binary] [--delete] [--fromfile file] [--hex]\n" "\t[--list-guids] [--list] [--load-option] [--name name] [--no-name]\n" "\t[--print] [--print-decimal] [--raw-guid] [--utf8] [--write]\n" "\tname[=value]"); } static void breakdown_name(char *name, efi_guid_t *guid, char **vname) { char *cp; cp = strrchr(name, '-'); if (cp == NULL) errx(1, "Invalid name: %s", name); *vname = cp + 1; *cp = '\0'; if (efi_name_to_guid(name, guid) < 0) errx(1, "Invalid guid %s", name); } static uint8_t * get_value(char *val, size_t *datalen) { static char buffer[16*1024]; if (val != NULL) { *datalen = strlen(val); return ((uint8_t *)val); } /* Read from stdin */ *datalen = sizeof(buffer); *datalen = read(0, buffer, *datalen); return ((uint8_t *)buffer); } static void append_variable(char *name, char *val) { char *vname; efi_guid_t guid; size_t datalen; uint8_t *data; breakdown_name(name, &guid, &vname); data = get_value(val, &datalen); if (efi_append_variable(guid, vname, data, datalen, attrib) < 0) err(1, "efi_append_variable"); } static void delete_variable(char *name) { char *vname; efi_guid_t guid; breakdown_name(name, &guid, &vname); if (efi_del_variable(guid, vname) < 0) err(1, "efi_del_variable"); } static void write_variable(char *name, char *val) { char *vname; efi_guid_t guid; size_t datalen; uint8_t *data; breakdown_name(name, &guid, &vname); data = get_value(val, &datalen); - if (efi_set_variable(guid, vname, data, datalen, attrib, 0) < 0) + if (efi_set_variable(guid, vname, data, datalen, attrib) < 0) err(1, "efi_set_variable"); } static void devpath_dump(uint8_t *data, size_t datalen) { char buffer[1024]; efidp_format_device_path(buffer, sizeof(buffer), (const_efidp)data, datalen); if (!Nflag) printf(": "); printf("%s\n", buffer); } static void pretty_guid(efi_guid_t *guid, char **gname) { char *pretty = NULL; if (gflag) efi_guid_to_name(guid, &pretty); if (pretty == NULL) efi_guid_to_str(guid, gname); else *gname = pretty; } static void print_var(efi_guid_t *guid, char *name) { uint32_t att; uint8_t *data; size_t datalen; char *gname; int rv; pretty_guid(guid, &gname); if (pflag) { rv = efi_get_variable(*guid, name, &data, &datalen, &att); if (rv < 0) err(1, "%s-%s", gname, name); if (!Nflag) printf("%s-%s\n", gname, name); if (load_opt_flag) efi_print_load_option(data, datalen, Aflag, bflag, uflag); else if (Aflag) asciidump(data, datalen); else if (uflag) utf8dump(data, datalen); else if (bflag) bindump(data, datalen); else if (dflag) devpath_dump(data, datalen); else hexdump(data, datalen); } else { printf("%s-%s", gname, name); } free(gname); if (!Nflag) printf("\n"); } static void print_variable(char *name) { char *vname; efi_guid_t guid; breakdown_name(name, &guid, &vname); print_var(&guid, vname); } static void print_variables(void) { int rv; char *name = NULL; efi_guid_t *guid = NULL; while ((rv = efi_get_next_variable_name(&guid, &name)) > 0) print_var(guid, name); if (rv < 0) err(1, "Error listing names"); } static void print_known_guid(void) { struct uuid_table *tbl; int i, n; n = efi_known_guid(&tbl); for (i = 0; i < n; i++) printf("%s %s\n", tbl[i].uuid_str, tbl[i].name); } static void parse_args(int argc, char **argv) { int ch, i; while ((ch = getopt_long(argc, argv, "aAbdDf:gHlLNn:OpRt:w", longopts, NULL)) != -1) { switch (ch) { case 'a': aflag++; break; case 'A': Aflag++; break; case 'b': bflag++; break; case 'd': dflag++; break; case 'D': Dflag++; break; case 'g': gflag++; break; case 'H': Hflag++; break; case 'l': lflag++; break; case 'L': Lflag++; break; case 'n': varname = optarg; break; case 'N': Nflag++; break; case 'O': load_opt_flag++; break; case 'p': pflag++; break; case 'R': Rflag++; break; case 't': attrib = strtoul(optarg, NULL, 16); break; case 'u': uflag++; break; case 'w': wflag++; break; case 'f': case 0: errx(1, "unknown or unimplemented option\n"); break; default: usage(); } } argc -= optind; argv += optind; if (argc == 1) varname = argv[0]; if (aflag + Dflag + wflag > 1) { warnx("Can only use one of -a (--append), " "-D (--delete) and -w (--write)"); usage(); } if (aflag + Dflag + wflag > 0 && varname == NULL) { warnx("Must specify a variable for -a (--append), " "-D (--delete) or -w (--write)"); usage(); } if (aflag) append_variable(varname, NULL); else if (Dflag) delete_variable(varname); else if (wflag) write_variable(varname, NULL); else if (Lflag) print_known_guid(); else if (varname) { pflag++; print_variable(varname); } else if (argc > 0) { pflag++; for (i = 0; i < argc; i++) print_variable(argv[i]); } else print_variables(); } int main(int argc, char **argv) { parse_args(argc, argv); }