/* $NetBSD: bootvar.c,v 1.3 2025/03/02 01:07:11 riastradh Exp $ */

/*
 * 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 ``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 <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: bootvar.c,v 1.3 2025/03/02 01:07:11 riastradh Exp $");
#endif /* not lint */

#include <sys/queue.h>

#include <assert.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <util.h>
#include <uuid.h>

#include "defs.h"
#include "efiio.h"
#include "bootvar.h"
#include "devpath.h"
#include "gptsubr.h"
#include "map.h"
#include "utils.h"

typedef SIMPLEQ_HEAD(boothead, boot_blk) boothead_t;

typedef struct boot_blk {
        size_t size;
        union {
                uint8_t    *bp;
                char       *cp;
                void       *vp;
                boot_var_t *body;       /* first element */
                devpath_t  *path;       /* remaining elements */
        } u;
        SIMPLEQ_ENTRY(boot_blk) entry;
} boot_blk_t;

static inline boot_blk_t *
new_blk(uint8_t type, uint8_t subtype, uint16_t length)
{
        boot_blk_t *bb;

        bb = ecalloc(sizeof(*bb), 1);

        if (length == 0)        /* alloc bb only */
                return bb;

        bb->u.vp = ecalloc(length, 1);
        bb->size = length;

        if (type == 0)          /* non-devpath */
                return bb;

        bb->u.path->Type = type;
        bb->u.path->SubType = subtype;
        bb->u.path->Length = length;

        return bb;
}

static void *
collapse_list(boothead_t *head, size_t datasize)
{
        boot_blk_t *bb;
        void *data;
        char *cp;

        data = ecalloc(datasize, 1);
        cp = data;
        SIMPLEQ_FOREACH(bb, head, entry) {
                memcpy(cp, bb->u.vp, bb->size);
                cp += bb->size;
        }
        return data;
}

static boot_blk_t *
create_bootbody(const char *label, uint32_t attrib)
{
        boot_blk_t *bb;
        size_t body_size, desc_size, size;

        desc_size = utf8_to_ucs2_size(label);
        body_size = sizeof(*bb->u.body) + desc_size;

        bb = new_blk(0, 0, (uint16_t)body_size);

        bb->u.body->Attributes = attrib;

        size = desc_size;
        utf8_to_ucs2(label, strlen(label) + 1, bb->u.body->Description, &size);
        assert(size == desc_size);

        return bb;
}

static boot_blk_t *
create_devpath_media_hd(const char *dev, uint partnum)
{
        struct {
                devpath_t       hdr;    /* Length 42 */
                uint32_t        PartitionNumber;
                uint64_t        PartitionStart;
                uint64_t        PartitionSize;
                struct uuid     PartitionSignature;
                uint8_t         PartitionFormat;
#define PARTITION_FORMAT_MBR    0x01
#define PARTITION_FORMAT_GPT    0x02

                uint8_t         SignatureType;
#define SIGNATURE_TYPE_NONE     0x00
#define SIGNATURE_TYPE_MBR      0x01
#define SIGNATURE_TYPE_GUID     0x02
        } __packed *pp;
        assert(sizeof(*pp) == 42);
        boot_blk_t *bb;
        struct gpt_ent *ent;
        map_t m;

        /* Get GPT info for device and partition */
        m = find_gpt_map(dev, partnum);
        if (m == NULL)
                errx(EXIT_FAILURE, "cannot find partition number %u on %s\n",
                    partnum, dev);

        ent = m->map_data;
        if (m->map_type != MAP_TYPE_GPT_PART)
                errx(EXIT_FAILURE, "not a MAP_TYPE_GPT_PART: %u\n",
                    m->map_type);

        /* Check that this is an EFI partition? */
        if (memcmp(ent->ent_type, (void *)&(uuid_t)GPT_ENT_TYPE_EFI,
                sizeof(ent->ent_type)) != 0)
                errx(EXIT_FAILURE, "not an EFI partition");

        bb = new_blk(DEVPATH_TYPE_MEDIA, 1, sizeof(*pp));

        pp = bb->u.vp;
        pp->PartitionNumber = m->map_index;
        pp->PartitionStart  = (uint64_t)m->map_start;
        pp->PartitionSize   = (uint64_t)m->map_size;
        memcpy(&pp->PartitionSignature, ent->ent_guid,
            sizeof(pp->PartitionSignature));
        pp->PartitionFormat = PARTITION_FORMAT_GPT;
        pp->SignatureType   = SIGNATURE_TYPE_GUID;

        return bb;
}

static boot_blk_t *
create_devpath_media_pathname(const char *loader)
{
        struct {
                devpath_t       hdr;
                uint16_t        PathName[];
        } __packed *pn;
        size_t len, path_len;
        boot_blk_t *bb;

        path_len = utf8_to_ucs2_size(loader);
        len = sizeof(pn->hdr) + path_len;

        bb = new_blk(DEVPATH_TYPE_MEDIA, 4, (uint16_t)len);

        pn = bb->u.vp;
        (void)utf8_to_ucs2(loader, strlen(loader) + 1, pn->PathName,
            &path_len);

        return bb;
}

static boot_blk_t *
create_devpath_end(void)
{
        boot_blk_t *bb;

        bb = new_blk(DEVPATH_TYPE_END, 0xff, sizeof(*bb->u.path));

        return bb;
}

static boot_blk_t *
create_optdata(const char *fname)
{
        boot_blk_t *bb;

        bb = new_blk(0, 0, 0);
        bb->u.vp = read_file(fname, &bb->size);
        return bb;
}

PUBLIC void *
make_bootvar_data(const char *dev, uint partnum, uint32_t attrib,
    const char *label, const char *loader, const char *fname,
    size_t *datasize)
{
        boothead_t head = SIMPLEQ_HEAD_INITIALIZER(head);
        boot_blk_t *bb;
        size_t FilePathListLength, OptDataLength;

        bb = create_bootbody(label, attrib);
        SIMPLEQ_INSERT_TAIL(&head, bb, entry);
        FilePathListLength = 0;

        bb = create_devpath_media_hd(dev, partnum);
        SIMPLEQ_INSERT_TAIL(&head, bb, entry);
        FilePathListLength += bb->size;

        bb = create_devpath_media_pathname(loader);
        SIMPLEQ_INSERT_TAIL(&head, bb, entry);
        FilePathListLength += bb->size;

        bb = create_devpath_end();
        SIMPLEQ_INSERT_TAIL(&head, bb, entry);
        FilePathListLength += bb->size;

        if (fname == NULL) {
                OptDataLength = 0;
        }
        else {
                bb = create_optdata(fname);
                SIMPLEQ_INSERT_TAIL(&head, bb, entry);
                OptDataLength = bb->size;
        }

        bb = SIMPLEQ_FIRST(&head);
        bb->u.body->FilePathListLength = (uint16_t)FilePathListLength;

        *datasize = bb->size + FilePathListLength + OptDataLength;
        return collapse_list(&head, *datasize);
}

PUBLIC int
find_new_bootvar(efi_var_t **var_array, size_t var_cnt, const char *target)
{
        int idx, lastidx;
        int rstatus;
        size_t n;

        assert(target != NULL);

        n = strlen(target);
        lastidx = -1;
        for (size_t i = 0; i < var_cnt; i++) {
                idx = (int)strtou(var_array[i]->name + n, NULL, 16, 0, 0xffff,
                    &rstatus);
                if (rstatus != 0)
                        err(EXIT_FAILURE, "strtou: %s", var_array[i]->name);

//              printf("idx: %x\n", idx);
                assert(idx > lastidx);
                if (idx != lastidx + 1) {
                        break;
                }
                lastidx = idx;
        }
        return lastidx + 1;
}