// SPDX-License-Identifier: GPL-2.0+
/*
 * File interface for UEFI variables
 *
 * Copyright (c) 2020, Heinrich Schuchardt
 */

#define LOG_CATEGORY LOGC_EFI

#include <common.h>
#include <charset.h>
#include <fs.h>
#include <log.h>
#include <malloc.h>
#include <mapmem.h>
#include <efi_loader.h>
#include <efi_variable.h>
#include <u-boot/crc.h>

#define PART_STR_LEN 10

/* GUID used by Shim to store the MOK database */
#define SHIM_LOCK_GUID \
        EFI_GUID(0x605dab50, 0xe046, 0x4300, \
                 0xab, 0xb6, 0x3d, 0xd8, 0x10, 0xdd, 0x8b, 0x23)

static const efi_guid_t shim_lock_guid = SHIM_LOCK_GUID;

/**
 * efi_set_blk_dev_to_system_partition() - select EFI system partition
 *
 * Set the EFI system partition as current block device.
 *
 * Return:      status code
 */
static efi_status_t __maybe_unused efi_set_blk_dev_to_system_partition(void)
{
        char part_str[PART_STR_LEN];
        int r;

        if (!efi_system_partition.if_type) {
                log_err("No EFI system partition\n");
                return EFI_DEVICE_ERROR;
        }
        snprintf(part_str, PART_STR_LEN, "%x:%x",
                 efi_system_partition.devnum, efi_system_partition.part);
        r = fs_set_blk_dev(blk_get_if_type_name(efi_system_partition.if_type),
                           part_str, FS_TYPE_ANY);
        if (r) {
                log_err("Cannot read EFI system partition\n");
                return EFI_DEVICE_ERROR;
        }
        return EFI_SUCCESS;
}

efi_status_t __maybe_unused efi_var_collect(struct efi_var_file **bufp, loff_t *lenp,
                                            u32 check_attr_mask)
{
        size_t len = EFI_VAR_BUF_SIZE;
        struct efi_var_file *buf;
        struct efi_var_entry *var, *old_var;
        size_t old_var_name_length = 2;

        *bufp = NULL; /* Avoid double free() */
        buf = calloc(1, len);
        if (!buf)
                return EFI_OUT_OF_RESOURCES;
        var = buf->var;
        old_var = var;
        for (;;) {
                efi_uintn_t data_length, var_name_length;
                u8 *data;
                efi_status_t ret;

                if ((uintptr_t)buf + len <=
                    (uintptr_t)var->name + old_var_name_length)
                        return EFI_BUFFER_TOO_SMALL;

                var_name_length = (uintptr_t)buf + len - (uintptr_t)var->name;
                memcpy(var->name, old_var->name, old_var_name_length);
                guidcpy(&var->guid, &old_var->guid);
                ret = efi_get_next_variable_name_int(
                                &var_name_length, var->name, &var->guid);
                if (ret == EFI_NOT_FOUND)
                        break;
                if (ret != EFI_SUCCESS) {
                        free(buf);
                        return ret;
                }
                old_var_name_length = var_name_length;
                old_var = var;

                data = (u8 *)var->name + old_var_name_length;
                data_length = (uintptr_t)buf + len - (uintptr_t)data;
                ret = efi_get_variable_int(var->name, &var->guid,
                                           &var->attr, &data_length, data,
                                           &var->time);
                if (ret != EFI_SUCCESS) {
                        free(buf);
                        return ret;
                }
                if ((var->attr & check_attr_mask) == check_attr_mask) {
                        var->length = data_length;
                        var = (struct efi_var_entry *)ALIGN((uintptr_t)data + data_length, 8);
                }
        }

        buf->reserved = 0;
        buf->magic = EFI_VAR_FILE_MAGIC;
        len = (uintptr_t)var - (uintptr_t)buf;
        buf->crc32 = crc32(0, (u8 *)buf->var,
                           len - sizeof(struct efi_var_file));
        buf->length = len;
        *bufp = buf;
        *lenp = len;

        return EFI_SUCCESS;
}

/**
 * efi_var_to_file() - save non-volatile variables as file
 *
 * File ubootefi.var is created on the EFI system partion.
 *
 * Return:      status code
 */
efi_status_t efi_var_to_file(void)
{
#ifdef CONFIG_EFI_VARIABLE_FILE_STORE
        efi_status_t ret;
        struct efi_var_file *buf;
        loff_t len;
        loff_t actlen;
        int r;

        ret = efi_var_collect(&buf, &len, EFI_VARIABLE_NON_VOLATILE);
        if (ret != EFI_SUCCESS)
                goto error;

        ret = efi_set_blk_dev_to_system_partition();
        if (ret != EFI_SUCCESS)
                goto error;

        r = fs_write(EFI_VAR_FILE_NAME, map_to_sysmem(buf), 0, len, &actlen);
        if (r || len != actlen)
                ret = EFI_DEVICE_ERROR;

error:
        if (ret != EFI_SUCCESS)
                log_err("Failed to persist EFI variables\n");
        free(buf);
        return ret;
#else
        return EFI_SUCCESS;
#endif
}

efi_status_t efi_var_restore(struct efi_var_file *buf, bool safe)
{
        struct efi_var_entry *var, *last_var;
        u16 *data;
        efi_status_t ret;

        if (buf->reserved || buf->magic != EFI_VAR_FILE_MAGIC ||
            buf->crc32 != crc32(0, (u8 *)buf->var,
                                buf->length - sizeof(struct efi_var_file))) {
                log_err("Invalid EFI variables file\n");
                return EFI_INVALID_PARAMETER;
        }

        last_var = (struct efi_var_entry *)((u8 *)buf + buf->length);
        for (var = buf->var; var < last_var;
             var = (struct efi_var_entry *)
                   ALIGN((uintptr_t)data + var->length, 8)) {

                data = var->name + u16_strlen(var->name) + 1;

                /*
                 * Secure boot related and non-volatile variables shall only be
                 * restored from U-Boot's preseed.
                 */
                if (!safe &&
                    (efi_auth_var_get_type(var->name, &var->guid) !=
                     EFI_AUTH_VAR_NONE ||
                     !guidcmp(&var->guid, &shim_lock_guid) ||
                     !(var->attr & EFI_VARIABLE_NON_VOLATILE)))
                        continue;
                if (!var->length)
                        continue;
                ret = efi_var_mem_ins(var->name, &var->guid, var->attr,
                                      var->length, data, 0, NULL,
                                      var->time);
                if (ret != EFI_SUCCESS)
                        log_err("Failed to set EFI variable %ls\n", var->name);
        }
        return EFI_SUCCESS;
}

/**
 * efi_var_from_file() - read variables from file
 *
 * File ubootefi.var is read from the EFI system partitions and the variables
 * stored in the file are created.
 *
 * In case the file does not exist yet or a variable cannot be set EFI_SUCCESS
 * is returned.
 *
 * Return:      status code
 */
efi_status_t efi_var_from_file(void)
{
#ifdef CONFIG_EFI_VARIABLE_FILE_STORE
        struct efi_var_file *buf;
        loff_t len;
        efi_status_t ret;
        int r;

        buf = calloc(1, EFI_VAR_BUF_SIZE);
        if (!buf) {
                log_err("Out of memory\n");
                return EFI_OUT_OF_RESOURCES;
        }

        ret = efi_set_blk_dev_to_system_partition();
        if (ret != EFI_SUCCESS)
                goto error;
        r = fs_read(EFI_VAR_FILE_NAME, map_to_sysmem(buf), 0, EFI_VAR_BUF_SIZE,
                    &len);
        if (r || len < sizeof(struct efi_var_file)) {
                log_err("Failed to load EFI variables\n");
                goto error;
        }
        if (buf->length != len || efi_var_restore(buf, false) != EFI_SUCCESS)
                log_err("Invalid EFI variables file\n");
error:
        free(buf);
#endif
        return EFI_SUCCESS;
}