[thirdparty/systemd.git] / src / shared / efivars.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2013 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <unistd.h>
#include <string.h>
#include <fcntl.h>

#include "util.h"
#include "utf8.h"
#include "efivars.h"

#ifdef ENABLE_EFI

#define LOAD_OPTION_ACTIVE            0x00000001
#define MEDIA_DEVICE_PATH                   0x04
#define MEDIA_HARDDRIVE_DP                  0x01
#define MEDIA_FILEPATH_DP                   0x04
#define SIGNATURE_TYPE_GUID                 0x02
#define MBR_TYPE_EFI_PARTITION_TABLE_HEADER 0x02
#define END_DEVICE_PATH_TYPE                0x7f
#define END_ENTIRE_DEVICE_PATH_SUBTYPE      0xff

struct boot_option {
        uint32_t attr;
        uint16_t path_len;
        uint16_t title[];
} __attribute__((packed));

struct drive_path {
        uint32_t part_nr;
        uint64_t part_start;
        uint64_t part_size;
        char signature[16];
        uint8_t mbr_type;
        uint8_t signature_type;
} __attribute__((packed));

struct device_path {
        uint8_t type;
        uint8_t sub_type;
        uint16_t length;
        union {
                uint16_t path[0];
                struct drive_path drive;
        };
} __attribute__((packed));

bool is_efi_boot(void) {
        return access("/sys/firmware/efi", F_OK) >= 0;
}

static int read_flag(const char *varname) {
        int r;
        _cleanup_free_ void *v = NULL;
        size_t s;
        uint8_t b;

        r = efi_get_variable(EFI_VENDOR_GLOBAL, varname, NULL, &v, &s);
        if (r < 0)
                return r;

        if (s != 1)
                return -EINVAL;

        b = *(uint8_t *)v;
        r = b > 0;
        return r;
}

int is_efi_secure_boot(void) {
        return read_flag("SecureBoot");
}

int is_efi_secure_boot_setup_mode(void) {
        return read_flag("SetupMode");
}

int efi_get_variable(
                sd_id128_t vendor,
                const char *name,
                uint32_t *attribute,
                void **value,
                size_t *size) {

        _cleanup_close_ int fd = -1;
        _cleanup_free_ char *p = NULL;
        uint32_t a;
        ssize_t n;
        struct stat st;
        void *r;

        assert(name);
        assert(value);
        assert(size);

        if (asprintf(&p,
                     "/sys/firmware/efi/efivars/%s-%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
                     name, SD_ID128_FORMAT_VAL(vendor)) < 0)
                return -ENOMEM;

        fd = open(p, O_RDONLY|O_NOCTTY|O_CLOEXEC);
        if (fd < 0)
                return -errno;

        if (fstat(fd, &st) < 0)
                return -errno;
        if (st.st_size < 4)
                return -EIO;
        if (st.st_size > 4*1024*1024 + 4)
                return -E2BIG;

        n = read(fd, &a, sizeof(a));
        if (n < 0)
                return -errno;
        if (n != sizeof(a))
                return -EIO;

        r = malloc(st.st_size - 4 + 2);
        if (!r)
                return -ENOMEM;

        n = read(fd, r, (size_t) st.st_size - 4);
        if (n < 0) {
                free(r);
                return -errno;
        }
        if (n != (ssize_t) st.st_size - 4) {
                free(r);
                return -EIO;
        }

        /* Always NUL terminate (2 bytes, to protect UTF-16) */
        ((char*) r)[st.st_size - 4] = 0;
        ((char*) r)[st.st_size - 4 + 1] = 0;

        *value = r;
        *size = (size_t) st.st_size - 4;

        if (attribute)
                *attribute = a;

        return 0;
}

int efi_set_variable(
                sd_id128_t vendor,
                const char *name,
                const void *value,
                size_t size) {

        struct var {
                uint32_t attr;
                char buf[];
        } __attribute__((packed)) *buf = NULL;
        char *p = NULL;
        int fd = -1;
        int r;

        assert(name);

        if (asprintf(&p,
                     "/sys/firmware/efi/efivars/%s-%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
                     name, SD_ID128_FORMAT_VAL(vendor)) < 0)
                return -ENOMEM;

        if (size == 0) {
                r = unlink(p);
                goto finish;
        }

        fd = open(p, O_WRONLY|O_CREAT|O_NOCTTY|O_CLOEXEC, 0644);
        if (fd < 0) {
                r = -errno;
                goto finish;
        }

        buf = malloc(sizeof(uint32_t) + size);
        if (!buf) {
                r = -errno;
                goto finish;
        }

        buf->attr = EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS;
        memcpy(buf->buf, value, size);

        r = write(fd, buf, sizeof(uint32_t) + size);
        if (r < 0) {
                r = -errno;
                goto finish;
        }

        if ((size_t)r != sizeof(uint32_t) + size) {
                r = -EIO;
                goto finish;
        }

finish:
        if (fd >= 0)
                close(fd);
        free(buf);
        free(p);
        return r;
}

int efi_get_variable_string(sd_id128_t vendor, const char *name, char **p) {
        _cleanup_free_ void *s = NULL;
        size_t ss = 0;
        int r;
        char *x;

        r = efi_get_variable(vendor, name, NULL, &s, &ss);
        if (r < 0)
                return r;

        x = utf16_to_utf8(s, ss);
        if (!x)
                return -ENOMEM;

        *p = x;
        return 0;
}

static size_t utf16_size(const uint16_t *s) {
        size_t l = 0;

        while (s[l] > 0)
                l++;

        return (l+1) * sizeof(uint16_t);
}

static void efi_guid_to_id128(const void *guid, sd_id128_t *id128) {
        struct uuid {
                uint32_t u1;
                uint16_t u2;
                uint16_t u3;
                uint8_t u4[8];
        } _packed_;
        const struct uuid *uuid = guid;

        id128->bytes[0] = (uuid->u1 >> 24) & 0xff;
        id128->bytes[1] = (uuid->u1 >> 16) & 0xff;
        id128->bytes[2] = (uuid->u1 >> 8) & 0xff;
        id128->bytes[3] = (uuid->u1) & 0xff;
        id128->bytes[4] = (uuid->u2 >> 8) & 0xff;
        id128->bytes[5] = (uuid->u2) & 0xff;
        id128->bytes[6] = (uuid->u3 >> 8) & 0xff;
        id128->bytes[7] = (uuid->u3) & 0xff;
        memcpy(&id128->bytes[8], uuid->u4, sizeof(uuid->u4));
}

int efi_get_boot_option(
                uint16_t id,
                char **title,
                sd_id128_t *part_uuid,
                char **path,
                bool *active) {
        struct boot_option {
                uint32_t attr;
                uint16_t path_len;
                uint16_t title[];
        } _packed_;

        struct drive_path {
                uint32_t part_nr;
                uint64_t part_start;
                uint64_t part_size;
                char signature[16];
                uint8_t mbr_type;
                uint8_t signature_type;
        } _packed_;

        struct device_path {
                uint8_t type;
                uint8_t sub_type;
                uint16_t length;
                union {
                        uint16_t path[0];
                        struct drive_path drive;
                };
        } _packed_;

        char boot_id[9];
        _cleanup_free_ uint8_t *buf = NULL;
        size_t l;
        struct boot_option *header;
        size_t title_size;
        char *s = NULL;
        char *p = NULL;
        sd_id128_t p_uuid = SD_ID128_NULL;
        int err;

        snprintf(boot_id, sizeof(boot_id), "Boot%04X", id);
        err = efi_get_variable(EFI_VENDOR_GLOBAL, boot_id, NULL, (void **)&buf, &l);
        if (err < 0)
                return err;
        if (l < sizeof(struct boot_option))
                return -ENOENT;

        header = (struct boot_option *)buf;
        title_size = utf16_size(header->title);
        if (title_size > l - offsetof(struct boot_option, title))
                return -EINVAL;

        if (title) {
                s = utf16_to_utf8(header->title, title_size);
                if (!s) {
                        err = -ENOMEM;
                        goto err;
                }
        }

        if (header->path_len > 0) {
                uint8_t *dbuf;
                size_t dnext;

                dbuf = buf + offsetof(struct boot_option, title) + title_size;
                dnext = 0;
                while (dnext < header->path_len) {
                        struct device_path *dpath;

                        dpath = (struct device_path *)(dbuf + dnext);
                        if (dpath->length < 4)
                                break;

                        /* Type 0x7F – End of Hardware Device Path, Sub-Type 0xFF – End Entire Device Path */
                        if (dpath->type == END_DEVICE_PATH_TYPE && dpath->sub_type == END_ENTIRE_DEVICE_PATH_SUBTYPE)
                                break;

                        dnext += dpath->length;

                        /* Type 0x04 – Media Device Path */
                        if (dpath->type != MEDIA_DEVICE_PATH)
                                continue;

                        /* Sub-Type 1 – Hard Drive */
                        if (dpath->sub_type == MEDIA_HARDDRIVE_DP) {
                                /* 0x02 – GUID Partition Table */
                                if (dpath->drive.mbr_type != MBR_TYPE_EFI_PARTITION_TABLE_HEADER)
                                        continue;

                                /* 0x02 – GUID signature */
                                if (dpath->drive.signature_type != SIGNATURE_TYPE_GUID)
                                        continue;

                                if (part_uuid)
                                        efi_guid_to_id128(dpath->drive.signature, &p_uuid);
                                continue;
                        }

                        /* Sub-Type 4 – File Path */
                        if (dpath->sub_type == MEDIA_FILEPATH_DP && !p && path) {
                                p = utf16_to_utf8(dpath->path, dpath->length-4);
                                efi_tilt_backslashes(p);
                                continue;
                        }
                }
        }

        if (title)
                *title = s;
        if (part_uuid)
                *part_uuid = p_uuid;
        if (path)
                *path = p;
        if (active)
                *active = !!header->attr & LOAD_OPTION_ACTIVE;

        return 0;
err:
        free(s);
        free(p);
        return err;
}

static void to_utf16(uint16_t *dest, const char *src) {
        int i;

        for (i = 0; src[i] != '\0'; i++)
                dest[i] = src[i];
        dest[i] = '\0';
}

struct guid {
        uint32_t u1;
        uint16_t u2;
        uint16_t u3;
        uint8_t u4[8];
} __attribute__((packed));

static void id128_to_efi_guid(sd_id128_t id, void *guid) {
        struct guid *uuid = guid;

        uuid->u1 = id.bytes[0] << 24 | id.bytes[1] << 16 | id.bytes[2] << 8 | id.bytes[3];
        uuid->u2 = id.bytes[4] << 8 | id.bytes[5];
        uuid->u3 = id.bytes[6] << 8 | id.bytes[7];
        memcpy(uuid->u4, id.bytes+8, sizeof(uuid->u4));
}

static uint16_t *tilt_slashes(uint16_t *s) {
        uint16_t *p;

        for (p = s; *p; p++)
                if (*p == '/')
                        *p = '\\';

        return s;
}

char *efi_tilt_backslashes(char *s) {
        char *p;

        for (p = s; *p; p++)
                if (*p == '\\')
                        *p = '/';

        return s;
}

int efi_add_boot_option(uint16_t id, const char *title,
                        uint32_t part, uint64_t pstart, uint64_t psize,
                        sd_id128_t part_uuid, const char *path) {
        char boot_id[9];
        char *buf;
        size_t size;
        size_t title_len;
        size_t path_len;
        struct boot_option *option;
        struct device_path *devicep;
        int err;

        title_len = (strlen(title)+1) * 2;
        path_len = (strlen(path)+1) * 2;

        buf = calloc(sizeof(struct boot_option) + title_len +
                     sizeof(struct drive_path) +
                     sizeof(struct device_path) + path_len, 1);
        if (!buf) {
                err = -ENOMEM;
                goto finish;
        }

        /* header */
        option = (struct boot_option *)buf;
        option->attr = LOAD_OPTION_ACTIVE;
        option->path_len = offsetof(struct device_path, drive) + sizeof(struct drive_path) +
                           offsetof(struct device_path, path) + path_len +
                           offsetof(struct device_path, path);
        to_utf16(option->title, title);
        size = offsetof(struct boot_option, title) + title_len;

        /* partition info */
        devicep = (struct device_path *)(buf + size);
        devicep->type = MEDIA_DEVICE_PATH;
        devicep->sub_type = MEDIA_HARDDRIVE_DP;
        devicep->length = offsetof(struct device_path, drive) + sizeof(struct drive_path);
        devicep->drive.part_nr = part;
        devicep->drive.part_start = pstart;
        devicep->drive.part_size =  psize;
        devicep->drive.signature_type = SIGNATURE_TYPE_GUID;
        devicep->drive.mbr_type = MBR_TYPE_EFI_PARTITION_TABLE_HEADER;
        id128_to_efi_guid(part_uuid, devicep->drive.signature);
        size += devicep->length;

        /* path to loader */
        devicep = (struct device_path *)(buf + size);
        devicep->type = MEDIA_DEVICE_PATH;
        devicep->sub_type = MEDIA_FILEPATH_DP;
        devicep->length = offsetof(struct device_path, path) + path_len;
        to_utf16(devicep->path, path);
        tilt_slashes(devicep->path);
        size += devicep->length;

        /* end of path */
        devicep = (struct device_path *)(buf + size);
        devicep->type = END_DEVICE_PATH_TYPE;
        devicep->sub_type = END_ENTIRE_DEVICE_PATH_SUBTYPE;
        devicep->length = offsetof(struct device_path, path);
        size += devicep->length;

        snprintf(boot_id, sizeof(boot_id), "Boot%04X", id);
        err = efi_set_variable(EFI_VENDOR_GLOBAL, boot_id, buf, size);

finish:
        free(buf);
        return err;
}

int efi_remove_boot_option(uint16_t id) {
        char boot_id[9];

        snprintf(boot_id, sizeof(boot_id), "Boot%04X", id);
        return efi_set_variable(EFI_VENDOR_GLOBAL, boot_id, NULL, 0);
}

int efi_get_boot_order(uint16_t **order) {
        void *buf;
        size_t l;
        int r;

        r = efi_get_variable(EFI_VENDOR_GLOBAL, "BootOrder", NULL, &buf, &l);
        if (r < 0)
                return r;

        if (l <= 0) {
                free(buf);
                return -ENOENT;
        }

        if ((l % sizeof(uint16_t) > 0) ||
            (l / sizeof(uint16_t) > INT_MAX)) {
                free(buf);
                return -EINVAL;
        }

        *order = buf;
        return (int) (l / sizeof(uint16_t));
}

int efi_set_boot_order(uint16_t *order, size_t n) {
        return efi_set_variable(EFI_VENDOR_GLOBAL, "BootOrder", order, n * sizeof(uint16_t));
}

static int boot_id_hex(const char s[4]) {
        int i;
        int id = 0;

        for (i = 0; i < 4; i++)
                if (s[i] >= '0' && s[i] <= '9')
                        id |= (s[i] - '0') << (3 - i) * 4;
                else if (s[i] >= 'A' && s[i] <= 'F')
                        id |= (s[i] - 'A' + 10) << (3 - i) * 4;
                else
                        return -EINVAL;

        return id;
}

static int cmp_uint16(const void *_a, const void *_b) {
        const uint16_t *a = _a, *b = _b;

        return (int)*a - (int)*b;
}

int efi_get_boot_options(uint16_t **options) {
        _cleanup_closedir_ DIR *dir = NULL;
        struct dirent *de;
        uint16_t *list = NULL;
        int count = 0, r;

        assert(options);

        dir = opendir("/sys/firmware/efi/efivars/");
        if (!dir)
                return -errno;

        FOREACH_DIRENT(de, dir, r = -errno; goto fail) {
                int id;
                uint16_t *t;

                if (strncmp(de->d_name, "Boot", 4) != 0)
                        continue;

                if (strlen(de->d_name) != 45)
                        continue;

                if (strcmp(de->d_name + 8, "-8be4df61-93ca-11d2-aa0d-00e098032b8c") != 0)
                        continue;

                id = boot_id_hex(de->d_name + 4);
                if (id < 0)
                        continue;

                t = realloc(list, (count + 1) * sizeof(uint16_t));
                if (!t) {
                        r = -ENOMEM;
                        goto fail;
                }

                list = t;
                list[count ++] = id;
        }

        qsort_safe(list, count, sizeof(uint16_t), cmp_uint16);

        *options = list;
        return count;

fail:
        free(list);
        return r;
}

static int read_usec(sd_id128_t vendor, const char *name, usec_t *u) {
        _cleanup_free_ char *j = NULL;
        int r;
        uint64_t x = 0;

        assert(name);
        assert(u);

        r = efi_get_variable_string(EFI_VENDOR_LOADER, name, &j);
        if (r < 0)
                return r;

        r = safe_atou64(j, &x);
        if (r < 0)
                return r;

        *u = x;
        return 0;
}

int efi_loader_get_boot_usec(usec_t *firmware, usec_t *loader) {
        uint64_t x, y;
        int r;

        assert(firmware);
        assert(loader);

        r = read_usec(EFI_VENDOR_LOADER, "LoaderTimeInitUSec", &x);
        if (r < 0)
                return r;

        r = read_usec(EFI_VENDOR_LOADER, "LoaderTimeExecUSec", &y);
        if (r < 0)
                return r;

        if (y == 0 || y < x)
                return -EIO;

        if (y > USEC_PER_HOUR)
                return -EIO;

        *firmware = x;
        *loader = y;

        return 0;
}

int efi_loader_get_device_part_uuid(sd_id128_t *u) {
        _cleanup_free_ char *p = NULL;
        int r, parsed[16];

        r = efi_get_variable_string(EFI_VENDOR_LOADER, "LoaderDevicePartUUID", &p);
        if (r < 0)
                return r;

        if (sscanf(p, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
                   &parsed[0], &parsed[1], &parsed[2], &parsed[3],
                   &parsed[4], &parsed[5], &parsed[6], &parsed[7],
                   &parsed[8], &parsed[9], &parsed[10], &parsed[11],
                   &parsed[12], &parsed[13], &parsed[14], &parsed[15]) != 16)
                return -EIO;

        if (u) {
                unsigned i;

                for (i = 0; i < ELEMENTSOF(parsed); i++)
                        u->bytes[i] = parsed[i];
        }

        return 0;
}

#endif
Commit	Line	Data
2e3d0692 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2013 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <unistd.h>
7b4d7cc0	23	#include <string.h>
2e3d0692 LP	24	#include <fcntl.h>
	25
	26	#include "util.h"
	27	#include "utf8.h"
	28	#include "efivars.h"
	29
b872e9a0 LP	30	#ifdef ENABLE_EFI
b872e9a0 LP	31
0974a682 KS	32	#define LOAD_OPTION_ACTIVE 0x00000001
	33	#define MEDIA_DEVICE_PATH 0x04
	34	#define MEDIA_HARDDRIVE_DP 0x01
	35	#define MEDIA_FILEPATH_DP 0x04
	36	#define SIGNATURE_TYPE_GUID 0x02
	37	#define MBR_TYPE_EFI_PARTITION_TABLE_HEADER 0x02
	38	#define END_DEVICE_PATH_TYPE 0x7f
	39	#define END_ENTIRE_DEVICE_PATH_SUBTYPE 0xff
	40
	41	struct boot_option {
	42	uint32_t attr;
	43	uint16_t path_len;
	44	uint16_t title[];
	45	} __attribute__((packed));
	46
	47	struct drive_path {
	48	uint32_t part_nr;
	49	uint64_t part_start;
	50	uint64_t part_size;
	51	char signature[16];
	52	uint8_t mbr_type;
	53	uint8_t signature_type;
	54	} __attribute__((packed));
	55
	56	struct device_path {
	57	uint8_t type;
	58	uint8_t sub_type;
	59	uint16_t length;
	60	union {
	61	uint16_t path[0];
	62	struct drive_path drive;
	63	};
	64	} __attribute__((packed));
	65
9cde64ff	66	bool is_efi_boot(void) {
34e5a31e LP	67	return access("/sys/firmware/efi", F_OK) >= 0;
	68	}
	69
bc6f2e7c KS	70	static int read_flag(const char *varname) {
bc6f2e7c KS	71	int r;
b47d419c	72	_cleanup_free_ void *v = NULL;
bc6f2e7c KS	73	size_t s;
	74	uint8_t b;
	75
	76	r = efi_get_variable(EFI_VENDOR_GLOBAL, varname, NULL, &v, &s);
	77	if (r < 0)
	78	return r;
	79
b47d419c ZJS	80	if (s != 1)
b47d419c ZJS	81	return -EINVAL;
bc6f2e7c KS	82
	83	b = (uint8_t )v;
	84	r = b > 0;
bc6f2e7c KS	85	return r;
	86	}
	87
	88	int is_efi_secure_boot(void) {
	89	return read_flag("SecureBoot");
	90	}
	91
	92	int is_efi_secure_boot_setup_mode(void) {
	93	return read_flag("SetupMode");
	94	}
	95
9cde64ff LP	96	int efi_get_variable(
	97	sd_id128_t vendor,
	98	const char *name,
	99	uint32_t *attribute,
	100	void **value,
	101	size_t *size) {
	102
2e3d0692 LP	103	_cleanup_close_ int fd = -1;
	104	_cleanup_free_ char *p = NULL;
	105	uint32_t a;
	106	ssize_t n;
	107	struct stat st;
	108	void *r;
	109
	110	assert(name);
	111	assert(value);
	112	assert(size);
	113
	114	if (asprintf(&p,
	115	"/sys/firmware/efi/efivars/%s-%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
	116	name, SD_ID128_FORMAT_VAL(vendor)) < 0)
	117	return -ENOMEM;
	118
	119	fd = open(p, O_RDONLY\|O_NOCTTY\|O_CLOEXEC);
	120	if (fd < 0)
	121	return -errno;
	122
	123	if (fstat(fd, &st) < 0)
	124	return -errno;
	125	if (st.st_size < 4)
	126	return -EIO;
	127	if (st.st_size > 410241024 + 4)
	128	return -E2BIG;
	129
	130	n = read(fd, &a, sizeof(a));
	131	if (n < 0)
9cde64ff	132	return -errno;
2e3d0692 LP	133	if (n != sizeof(a))
	134	return -EIO;
	135
	136	r = malloc(st.st_size - 4 + 2);
	137	if (!r)
	138	return -ENOMEM;
	139
	140	n = read(fd, r, (size_t) st.st_size - 4);
	141	if (n < 0) {
	142	free(r);
742af54a	143	return -errno;
2e3d0692 LP	144	}
	145	if (n != (ssize_t) st.st_size - 4) {
	146	free(r);
	147	return -EIO;
	148	}
	149
	150	/* Always NUL terminate (2 bytes, to protect UTF-16) */
	151	((char*) r)[st.st_size - 4] = 0;
	152	((char*) r)[st.st_size - 4 + 1] = 0;
	153
	154	*value = r;
ff47c895	155	*size = (size_t) st.st_size - 4;
2e3d0692 LP	156
	157	if (attribute)
	158	*attribute = a;
	159
	160	return 0;
	161	}
	162
0974a682 KS	163	int efi_set_variable(
	164	sd_id128_t vendor,
	165	const char *name,
	166	const void *value,
	167	size_t size) {
	168
	169	struct var {
	170	uint32_t attr;
	171	char buf[];
	172	} __attribute__((packed)) *buf = NULL;
	173	char *p = NULL;
	174	int fd = -1;
	175	int r;
	176
	177	assert(name);
	178
	179	if (asprintf(&p,
	180	"/sys/firmware/efi/efivars/%s-%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
	181	name, SD_ID128_FORMAT_VAL(vendor)) < 0)
	182	return -ENOMEM;
	183
	184	if (size == 0) {
	185	r = unlink(p);
	186	goto finish;
	187	}
	188
	189	fd = open(p, O_WRONLY\|O_CREAT\|O_NOCTTY\|O_CLOEXEC, 0644);
	190	if (fd < 0) {
	191	r = -errno;
	192	goto finish;
	193	}
	194
	195	buf = malloc(sizeof(uint32_t) + size);
	196	if (!buf) {
	197	r = -errno;
	198	goto finish;
	199	}
	200
	201	buf->attr = EFI_VARIABLE_NON_VOLATILE\|EFI_VARIABLE_BOOTSERVICE_ACCESS\|EFI_VARIABLE_RUNTIME_ACCESS;
	202	memcpy(buf->buf, value, size);
	203
	204	r = write(fd, buf, sizeof(uint32_t) + size);
	205	if (r < 0) {
	206	r = -errno;
	207	goto finish;
	208	}
	209
	210	if ((size_t)r != sizeof(uint32_t) + size) {
	211	r = -EIO;
	212	goto finish;
	213	}
	214
	215	finish:
	216	if (fd >= 0)
	217	close(fd);
	218	free(buf);
	219	free(p);
	220	return r;
	221	}
	222
9cde64ff	223	int efi_get_variable_string(sd_id128_t vendor, const char name, char *p) {
7b4d7cc0	224	_cleanup_free_ void *s = NULL;
39883f62	225	size_t ss = 0;
9cde64ff LP	226	int r;
9cde64ff LP	227	char *x;
7b4d7cc0	228
9cde64ff LP	229	r = efi_get_variable(vendor, name, NULL, &s, &ss);
	230	if (r < 0)
	231	return r;
	232
	233	x = utf16_to_utf8(s, ss);
	234	if (!x)
	235	return -ENOMEM;
	236
	237	*p = x;
	238	return 0;
7b4d7cc0 KS	239	}
	240
	241	static size_t utf16_size(const uint16_t *s) {
	242	size_t l = 0;
	243
	244	while (s[l] > 0)
	245	l++;
9cde64ff	246
7b4d7cc0 KS	247	return (l+1) * sizeof(uint16_t);
	248	}
	249
	250	static void efi_guid_to_id128(const void guid, sd_id128_t id128) {
	251	struct uuid {
	252	uint32_t u1;
	253	uint16_t u2;
	254	uint16_t u3;
	255	uint8_t u4[8];
	256	} _packed_;
	257	const struct uuid *uuid = guid;
	258
	259	id128->bytes[0] = (uuid->u1 >> 24) & 0xff;
	260	id128->bytes[1] = (uuid->u1 >> 16) & 0xff;
	261	id128->bytes[2] = (uuid->u1 >> 8) & 0xff;
	262	id128->bytes[3] = (uuid->u1) & 0xff;
	263	id128->bytes[4] = (uuid->u2 >> 8) & 0xff;
	264	id128->bytes[5] = (uuid->u2) & 0xff;
	265	id128->bytes[6] = (uuid->u3 >> 8) & 0xff;
	266	id128->bytes[7] = (uuid->u3) & 0xff;
	267	memcpy(&id128->bytes[8], uuid->u4, sizeof(uuid->u4));
	268	}
	269
9cde64ff LP	270	int efi_get_boot_option(
	271	uint16_t id,
	272	char **title,
	273	sd_id128_t *part_uuid,
0974a682 KS	274	char **path,
0974a682 KS	275	bool *active) {
7b4d7cc0 KS	276	struct boot_option {
	277	uint32_t attr;
	278	uint16_t path_len;
	279	uint16_t title[];
	280	} _packed_;
	281
	282	struct drive_path {
	283	uint32_t part_nr;
	284	uint64_t part_start;
	285	uint64_t part_size;
	286	char signature[16];
	287	uint8_t mbr_type;
	288	uint8_t signature_type;
	289	} _packed_;
	290
	291	struct device_path {
	292	uint8_t type;
	293	uint8_t sub_type;
	294	uint16_t length;
	295	union {
	296	uint16_t path[0];
	297	struct drive_path drive;
	298	};
	299	} _packed_;
	300
9cde64ff LP	301	char boot_id[9];
9cde64ff LP	302	_cleanup_free_ uint8_t *buf = NULL;
7b4d7cc0 KS	303	size_t l;
	304	struct boot_option *header;
	305	size_t title_size;
	306	char *s = NULL;
	307	char *p = NULL;
	308	sd_id128_t p_uuid = SD_ID128_NULL;
7b4d7cc0 KS	309	int err;
	310
	311	snprintf(boot_id, sizeof(boot_id), "Boot%04X", id);
	312	err = efi_get_variable(EFI_VENDOR_GLOBAL, boot_id, NULL, (void **)&buf, &l);
	313	if (err < 0)
	314	return err;
7b4d7cc0 KS	315	if (l < sizeof(struct boot_option))
	316	return -ENOENT;
	317
	318	header = (struct boot_option *)buf;
	319	title_size = utf16_size(header->title);
	320	if (title_size > l - offsetof(struct boot_option, title))
	321	return -EINVAL;
	322
5483a186 ZJS	323	if (title) {
	324	s = utf16_to_utf8(header->title, title_size);
	325	if (!s) {
	326	err = -ENOMEM;
	327	goto err;
	328	}
7b4d7cc0 KS	329	}
	330
	331	if (header->path_len > 0) {
9cde64ff	332	uint8_t *dbuf;
7b4d7cc0 KS	333	size_t dnext;
	334
	335	dbuf = buf + offsetof(struct boot_option, title) + title_size;
	336	dnext = 0;
	337	while (dnext < header->path_len) {
	338	struct device_path *dpath;
	339
	340	dpath = (struct device_path *)(dbuf + dnext);
	341	if (dpath->length < 4)
	342	break;
	343
	344	/* Type 0x7F – End of Hardware Device Path, Sub-Type 0xFF – End Entire Device Path */
0974a682	345	if (dpath->type == END_DEVICE_PATH_TYPE && dpath->sub_type == END_ENTIRE_DEVICE_PATH_SUBTYPE)
7b4d7cc0 KS	346	break;
	347
	348	dnext += dpath->length;
	349
	350	/* Type 0x04 – Media Device Path */
0974a682	351	if (dpath->type != MEDIA_DEVICE_PATH)
7b4d7cc0 KS	352	continue;
	353
	354	/* Sub-Type 1 – Hard Drive */
0974a682	355	if (dpath->sub_type == MEDIA_HARDDRIVE_DP) {
7b4d7cc0	356	/* 0x02 – GUID Partition Table */
0974a682	357	if (dpath->drive.mbr_type != MBR_TYPE_EFI_PARTITION_TABLE_HEADER)
7b4d7cc0 KS	358	continue;
	359
	360	/* 0x02 – GUID signature */
0974a682	361	if (dpath->drive.signature_type != SIGNATURE_TYPE_GUID)
7b4d7cc0 KS	362	continue;
7b4d7cc0 KS	363
5483a186 ZJS	364	if (part_uuid)
5483a186 ZJS	365	efi_guid_to_id128(dpath->drive.signature, &p_uuid);
7b4d7cc0 KS	366	continue;
	367	}
	368
	369	/* Sub-Type 4 – File Path */
0974a682	370	if (dpath->sub_type == MEDIA_FILEPATH_DP && !p && path) {
7b4d7cc0	371	p = utf16_to_utf8(dpath->path, dpath->length-4);
0974a682	372	efi_tilt_backslashes(p);
7b4d7cc0 KS	373	continue;
	374	}
	375	}
	376	}
	377
9cde64ff LP	378	if (title)
9cde64ff LP	379	*title = s;
7b4d7cc0 KS	380	if (part_uuid)
	381	*part_uuid = p_uuid;
	382	if (path)
	383	*path = p;
0974a682 KS	384	if (active)
0974a682 KS	385	*active = !!header->attr & LOAD_OPTION_ACTIVE;
9cde64ff	386
7b4d7cc0 KS	387	return 0;
	388	err:
	389	free(s);
	390	free(p);
7b4d7cc0 KS	391	return err;
	392	}
	393
0974a682 KS	394	static void to_utf16(uint16_t dest, const char src) {
	395	int i;
	396
	397	for (i = 0; src[i] != '\0'; i++)
	398	dest[i] = src[i];
	399	dest[i] = '\0';
	400	}
	401
	402	struct guid {
	403	uint32_t u1;
	404	uint16_t u2;
	405	uint16_t u3;
	406	uint8_t u4[8];
	407	} __attribute__((packed));
	408
	409	static void id128_to_efi_guid(sd_id128_t id, void *guid) {
	410	struct guid *uuid = guid;
	411
	412	uuid->u1 = id.bytes[0] << 24 \| id.bytes[1] << 16 \| id.bytes[2] << 8 \| id.bytes[3];
	413	uuid->u2 = id.bytes[4] << 8 \| id.bytes[5];
	414	uuid->u3 = id.bytes[6] << 8 \| id.bytes[7];
	415	memcpy(uuid->u4, id.bytes+8, sizeof(uuid->u4));
	416	}
	417
	418	static uint16_t tilt_slashes(uint16_t s) {
	419	uint16_t *p;
	420
	421	for (p = s; *p; p++)
	422	if (*p == '/')
	423	*p = '\\';
	424
	425	return s;
	426	}
	427
	428	char efi_tilt_backslashes(char s) {
	429	char *p;
	430
	431	for (p = s; *p; p++)
	432	if (*p == '\\')
	433	*p = '/';
	434
	435	return s;
	436	}
	437
	438	int efi_add_boot_option(uint16_t id, const char *title,
	439	uint32_t part, uint64_t pstart, uint64_t psize,
	440	sd_id128_t part_uuid, const char *path) {
	441	char boot_id[9];
	442	char *buf;
	443	size_t size;
	444	size_t title_len;
	445	size_t path_len;
	446	struct boot_option *option;
	447	struct device_path *devicep;
	448	int err;
	449
	450	title_len = (strlen(title)+1) * 2;
	451	path_len = (strlen(path)+1) * 2;
	452
	453	buf = calloc(sizeof(struct boot_option) + title_len +
	454	sizeof(struct drive_path) +
	455	sizeof(struct device_path) + path_len, 1);
	456	if (!buf) {
	457	err = -ENOMEM;
458	goto finish;
459	}
460
461	/* header */
462	option = (struct boot_option *)buf;
463	option->attr = LOAD_OPTION_ACTIVE;
464	option->path_len = offsetof(struct device_path, drive) + sizeof(struct drive_path) +
465	offsetof(struct device_path, path) + path_len +
466	offsetof(struct device_path, path);
467	to_utf16(option->title, title);
468	size = offsetof(struct boot_option, title) + title_len;
469
470	/* partition info */
471	devicep = (struct device_path *)(buf + size);
472	devicep->type = MEDIA_DEVICE_PATH;
473	devicep->sub_type = MEDIA_HARDDRIVE_DP;
474	devicep->length = offsetof(struct device_path, drive) + sizeof(struct drive_path);
475	devicep->drive.part_nr = part;
476	devicep->drive.part_start = pstart;
477	devicep->drive.part_size = psize;
478	devicep->drive.signature_type = SIGNATURE_TYPE_GUID;
479	devicep->drive.mbr_type = MBR_TYPE_EFI_PARTITION_TABLE_HEADER;
480	id128_to_efi_guid(part_uuid, devicep->drive.signature);
481	size += devicep->length;
482
483	/* path to loader */
484	devicep = (struct device_path *)(buf + size);
485	devicep->type = MEDIA_DEVICE_PATH;
486	devicep->sub_type = MEDIA_FILEPATH_DP;
487	devicep->length = offsetof(struct device_path, path) + path_len;
488	to_utf16(devicep->path, path);
489	tilt_slashes(devicep->path);
490	size += devicep->length;
491
492	/* end of path */
493	devicep = (struct device_path *)(buf + size);
494	devicep->type = END_DEVICE_PATH_TYPE;
495	devicep->sub_type = END_ENTIRE_DEVICE_PATH_SUBTYPE;
496	devicep->length = offsetof(struct device_path, path);
497	size += devicep->length;
498
499	snprintf(boot_id, sizeof(boot_id), "Boot%04X", id);
500	err = efi_set_variable(EFI_VENDOR_GLOBAL, boot_id, buf, size);
501
502	finish:
503	free(buf);
504	return err;
505	}
506
507	int efi_remove_boot_option(uint16_t id) {
508	char boot_id[9];
509
510	snprintf(boot_id, sizeof(boot_id), "Boot%04X", id);
511	return efi_set_variable(EFI_VENDOR_GLOBAL, boot_id, NULL, 0);
512	}
513
9cde64ff	514	int efi_get_boot_order(uint16_t **order) {
7b4d7cc0 KS	515	void *buf;
7b4d7cc0 KS	516	size_t l;
9cde64ff	517	int r;
7b4d7cc0	518
9cde64ff LP	519	r = efi_get_variable(EFI_VENDOR_GLOBAL, "BootOrder", NULL, &buf, &l);
	520	if (r < 0)
	521	return r;
7b4d7cc0	522
9cde64ff	523	if (l <= 0) {
7b4d7cc0 KS	524	free(buf);
	525	return -ENOENT;
	526	}
	527
9cde64ff LP	528	if ((l % sizeof(uint16_t) > 0) \|\|
9cde64ff LP	529	(l / sizeof(uint16_t) > INT_MAX)) {
7b4d7cc0 KS	530	free(buf);
	531	return -EINVAL;
	532	}
	533
	534	*order = buf;
9cde64ff LP	535	return (int) (l / sizeof(uint16_t));
	536	}
	537
0974a682 KS	538	int efi_set_boot_order(uint16_t *order, size_t n) {
	539	return efi_set_variable(EFI_VENDOR_GLOBAL, "BootOrder", order, n * sizeof(uint16_t));
	540	}
	541
4d34c495 KS	542	static int boot_id_hex(const char s[4]) {
	543	int i;
	544	int id = 0;
	545
	546	for (i = 0; i < 4; i++)
	547	if (s[i] >= '0' && s[i] <= '9')
	548	id \|= (s[i] - '0') << (3 - i) * 4;
	549	else if (s[i] >= 'A' && s[i] <= 'F')
	550	id \|= (s[i] - 'A' + 10) << (3 - i) * 4;
	551	else
7e8185ef	552	return -EINVAL;
4d34c495 KS	553
	554	return id;
	555	}
	556
9db11a99 LP	557	static int cmp_uint16(const void _a, const void _b) {
	558	const uint16_t a = _a, b = _b;
	559
02a6fc3e	560	return (int)a - (int)b;
9db11a99 LP	561	}
9db11a99 LP	562
9cde64ff LP	563	int efi_get_boot_options(uint16_t **options) {
	564	_cleanup_closedir_ DIR *dir = NULL;
	565	struct dirent *de;
	566	uint16_t *list = NULL;
9db11a99	567	int count = 0, r;
9cde64ff LP	568
	569	assert(options);
	570
	571	dir = opendir("/sys/firmware/efi/efivars/");
	572	if (!dir)
	573	return -errno;
	574
9db11a99	575	FOREACH_DIRENT(de, dir, r = -errno; goto fail) {
4d34c495	576	int id;
9cde64ff LP	577	uint16_t *t;
	578
	579	if (strncmp(de->d_name, "Boot", 4) != 0)
	580	continue;
	581
4d34c495	582	if (strlen(de->d_name) != 45)
9cde64ff LP	583	continue;
	584
	585	if (strcmp(de->d_name + 8, "-8be4df61-93ca-11d2-aa0d-00e098032b8c") != 0)
	586	continue;
	587
4d34c495 KS	588	id = boot_id_hex(de->d_name + 4);
4d34c495 KS	589	if (id < 0)
9cde64ff LP	590	continue;
	591
	592	t = realloc(list, (count + 1) * sizeof(uint16_t));
	593	if (!t) {
9db11a99 LP	594	r = -ENOMEM;
9db11a99 LP	595	goto fail;
9cde64ff LP	596	}
	597
	598	list = t;
4d34c495	599	list[count ++] = id;
9cde64ff LP	600	}
9cde64ff LP	601
7ff7394d	602	qsort_safe(list, count, sizeof(uint16_t), cmp_uint16);
9db11a99	603
9cde64ff LP	604	*options = list;
9cde64ff LP	605	return count;
9db11a99 LP	606
	607	fail:
	608	free(list);
	609	return r;
7b4d7cc0 KS	610	}
7b4d7cc0 KS	611
5dbe9f53	612	static int read_usec(sd_id128_t vendor, const char name, usec_t u) {
2e3d0692	613	_cleanup_free_ char *j = NULL;
2e3d0692	614	int r;
39883f62	615	uint64_t x = 0;
2e3d0692 LP	616
	617	assert(name);
	618	assert(u);
	619
61cc634b	620	r = efi_get_variable_string(EFI_VENDOR_LOADER, name, &j);
2e3d0692 LP	621	if (r < 0)
	622	return r;
	623
2e3d0692 LP	624	r = safe_atou64(j, &x);
	625	if (r < 0)
	626	return r;
	627
5dbe9f53	628	*u = x;
2e3d0692 LP	629	return 0;
	630	}
	631
c51d84dc	632	int efi_loader_get_boot_usec(usec_t firmware, usec_t loader) {
2e3d0692 LP	633	uint64_t x, y;
2e3d0692 LP	634	int r;
2e3d0692 LP	635
	636	assert(firmware);
	637	assert(loader);
	638
e9cea16d	639	r = read_usec(EFI_VENDOR_LOADER, "LoaderTimeInitUSec", &x);
2e3d0692 LP	640	if (r < 0)
	641	return r;
	642
e9cea16d	643	r = read_usec(EFI_VENDOR_LOADER, "LoaderTimeExecUSec", &y);
2e3d0692 LP	644	if (r < 0)
	645	return r;
	646
	647	if (y == 0 \|\| y < x)
	648	return -EIO;
	649
	650	if (y > USEC_PER_HOUR)
	651	return -EIO;
	652
	653	*firmware = x;
	654	*loader = y;
	655
	656	return 0;
	657	}
	658
c51d84dc	659	int efi_loader_get_device_part_uuid(sd_id128_t *u) {
f4ce2b3e	660	_cleanup_free_ char *p = NULL;
f4ce2b3e	661	int r, parsed[16];
f4ce2b3e	662
61cc634b	663	r = efi_get_variable_string(EFI_VENDOR_LOADER, "LoaderDevicePartUUID", &p);
f4ce2b3e LP	664	if (r < 0)
	665	return r;
	666
f4ce2b3e LP	667	if (sscanf(p, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
	668	&parsed[0], &parsed[1], &parsed[2], &parsed[3],
	669	&parsed[4], &parsed[5], &parsed[6], &parsed[7],
	670	&parsed[8], &parsed[9], &parsed[10], &parsed[11],
	671	&parsed[12], &parsed[13], &parsed[14], &parsed[15]) != 16)
	672	return -EIO;
	673
73b80ec2 LP	674	if (u) {
	675	unsigned i;
	676
	677	for (i = 0; i < ELEMENTSOF(parsed); i++)
	678	u->bytes[i] = parsed[i];
	679	}
f4ce2b3e LP	680
	681	return 0;
	682	}
b872e9a0 LP	683
b872e9a0 LP	684	#endif