/*      $NetBSD: installboot.c,v 1.41 2022/07/10 19:28:00 brook Exp $   */

/*-
 * Copyright (c) 2002 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Luke Mewburn of Wasabi Systems.
 *
 * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 */

#if HAVE_NBTOOL_CONFIG_H
#include "nbtool_config.h"
#endif

#include <sys/cdefs.h>
#if !defined(__lint)
__RCSID("$NetBSD: installboot.c,v 1.41 2022/07/10 19:28:00 brook Exp $");
#endif  /* !__lint */

#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/utsname.h>

#include <assert.h>
#include <err.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>
#if !HAVE_NBTOOL_CONFIG_H
#include <util.h>
#endif

#include "installboot.h"
#include "evboards.h"

static  void    getmachine(ib_params *, const char *, const char *);
static  void    getfstype(ib_params *, const char *, const char *);
static  void    getubootpaths(ib_params *, const char *);
static  void    parseoptions(ib_params *, const char *);
__dead static   void    usage(void);
static  void    options_usage(void);
static  void    machine_usage(void);
static  void    fstype_usage(void);

static  ib_params       installboot_params;

#define OFFSET(field)    offsetof(ib_params, field)
const struct option {
        const char      *name;          /* Name of option */
        ib_flags        flag;           /* Corresponding IB_xxx flag */
        enum {                          /* Type of option value... */
                OPT_BOOL,               /* no value */
                OPT_INT,                /* numeric value */
                OPT_WORD,               /* space/tab/, terminated */
                OPT_STRING              /* null terminated */
        }               type;
        int             offset;         /* of field in ib_params */
} options[] = {
        { "alphasum",   IB_ALPHASUM,    OPT_BOOL,       0 },
        { "append",     IB_APPEND,      OPT_BOOL,       0 },
        { "command",    IB_COMMAND,     OPT_STRING,     OFFSET(command) },
        { "console",    IB_CONSOLE,     OPT_WORD,       OFFSET(console) },
        { "ioaddr",     IB_CONSADDR,    OPT_INT,        OFFSET(consaddr) },
        { "keymap",     IB_KEYMAP,      OPT_WORD,       OFFSET(keymap) },
        { "password",   IB_PASSWORD,    OPT_WORD,       OFFSET(password) },
        { "resetvideo", IB_RESETVIDEO,  OPT_BOOL,       0 },
        { "speed",      IB_CONSPEED,    OPT_INT,        OFFSET(conspeed) },
        { "sunsum",     IB_SUNSUM,      OPT_BOOL,       0 },
        { "timeout",    IB_TIMEOUT,     OPT_INT,        OFFSET(timeout) },
        { "modules",    IB_MODULES,     OPT_BOOL,       0 },
        { "bootconf",   IB_BOOTCONF,    OPT_BOOL,       0 },
        { "board",      IB_BOARD,       OPT_STRING,     OFFSET(board) },
        { "dtb",        IB_DTB,         OPT_STRING,     OFFSET(dtb) },
        { "media",      IB_MEDIA,       OPT_WORD,       OFFSET(media) },
        { .name = NULL },
};
#undef OFFSET
#define OPTION(params, type, opt) (*(type *)((char *)(params) + (opt)->offset))

#define DFL_SECSIZE     512     /* Don't use DEV_BSIZE. It's host's value. */

#ifndef DEFAULT_UBOOT_PKG_PATH
#define DEFAULT_UBOOT_PKG_PATH  "/usr/pkg/share/u-boot"
#endif

#ifndef UBOOT_PATHS_ENV_VAR
#define UBOOT_PATHS_ENV_VAR     "INSTALLBOOT_UBOOT_PATHS"
#endif

int
main(int argc, char *argv[])
{
        struct utsname  utsname;
        ib_params       *params;
        unsigned long   lval;
        int             ch, rv, mode;
        char            *p;
        const char      *op;
        ib_flags        unsupported_flags;
#if !HAVE_NBTOOL_CONFIG_H
        char            specname[MAXPATHLEN];
        char            rawname[MAXPATHLEN];
        const char      *special, *raw;
#endif

        setprogname(argv[0]);
        params = &installboot_params;
        memset(params, 0, sizeof(*params));
        params->fsfd = -1;
        params->s1fd = -1;
        if ((p = getenv("MACHINE")) != NULL)
                getmachine(params, p, "$MACHINE");
        getubootpaths(params, DEFAULT_UBOOT_PKG_PATH);
        if ((p = getenv(UBOOT_PATHS_ENV_VAR)) != NULL) {
                getubootpaths(params, p);
        }

        while ((ch = getopt(argc, argv, "b:B:cefm:no:t:u:v")) != -1) {
                switch (ch) {

                case 'b':
                case 'B':
                        if (*optarg == '\0')
                                goto badblock;
                        lval = strtoul(optarg, &p, 0);
                        if (lval > UINT32_MAX || *p != '\0') {
 badblock:
                                errx(1, "Invalid block number `%s'", optarg);
                        }
                        if (ch == 'b') {
                                params->s1start = (uint32_t)lval;
                                params->flags |= IB_STAGE1START;
                        } else {
                                params->s2start = (uint32_t)lval;
                                params->flags |= IB_STAGE2START;
                        }
                        break;

                case 'c':
                        params->flags |= IB_CLEAR;
                        break;

                case 'e':
                        params->flags |= IB_EDIT;
                        break;

                case 'f':
                        params->flags |= IB_FORCE;
                        break;

                case 'm':
                        getmachine(params, optarg, "-m");
                        break;

                case 'n':
                        params->flags |= IB_NOWRITE;
                        break;

                case 'o':
                        parseoptions(params, optarg);
                        break;

                case 't':
                        getfstype(params, optarg, "-t");
                        break;

                case 'u':
                        getubootpaths(params, optarg);
                        break;

                case 'v':
                        params->flags |= IB_VERBOSE;
                        break;

                case '?':
                default:
                        usage();
                        /* NOTREACHED */

                }
        }
        argc -= optind;
        argv += optind;

        if (params->flags & IB_CLEAR && params->flags & IB_EDIT)
                usage();
        if (argc < 1 || argc + 2 * !!(params->flags & (IB_CLEAR | IB_EDIT)) > 3)
                usage();

        /* set missing defaults */
        if (params->machine == NULL) {
                if (uname(&utsname) == -1)
                        err(1, "Determine uname");
                getmachine(params, utsname.machine, "uname()");
        }

        /* Check that options are supported by this system */
        unsupported_flags = params->flags & ~params->machine->valid_flags;
        unsupported_flags &= ~(IB_VERBOSE | IB_NOWRITE | IB_CLEAR | IB_EDIT
                                | IB_FORCE);
        if (unsupported_flags != 0) {
                int ndx;
                for (ndx = 0; options[ndx].name != NULL; ndx++) {
                        if (unsupported_flags & options[ndx].flag) {
                                unsupported_flags &= ~options[ndx].flag;
                                warnx("`-o %s' is not supported for %s",
                                    options[ndx].name, params->machine->name);
                        }
                }
                if (unsupported_flags & IB_STAGE1START)
                        warnx("`-b bno' is not supported for %s",
                            params->machine->name);
                if (unsupported_flags & IB_STAGE2START)
                        warnx("`-B bno' is not supported for %s",
                            params->machine->name);
                unsupported_flags &= ~(IB_STAGE1START | IB_STAGE2START);
                if (unsupported_flags != 0)
                        warnx("Unknown unsupported flag %#x (coding error!)",
                            unsupported_flags);
                exit(1);
        }
        /* and some illegal combinations */
        if (params->flags & IB_STAGE1START && params->flags & IB_APPEND) {
                warnx("Can't use `-b bno' with `-o append'");
                exit(1);
        }
        if (params->flags & IB_CLEAR &&
            params->flags & (IB_STAGE1START | IB_STAGE2START | IB_APPEND)) {
                warnx("Can't use `-b bno', `-B bno' or `-o append' with `-c'");
                exit(1);
        }

        if (argc >= 3) {
                params->stage2 = argv[2];
        }

#if !HAVE_NBTOOL_CONFIG_H
        special = getfsspecname(specname, sizeof(specname), argv[0]);
        if (special == NULL)
                err(1, "%s: %s", argv[0], specname);
        raw = getdiskrawname(rawname, sizeof(rawname), special);
        if (raw != NULL)
                special = raw;
        params->filesystem = special;
#else
        params->filesystem = argv[0];
#endif

        if (params->flags & IB_NOWRITE) {
                op = "only";
                mode = O_RDONLY;
        } else {
                op = "write";
                mode = O_RDWR;
        }
        /* XXX should be specified via option */
        params->sectorsize = DFL_SECSIZE;
        if ((params->fsfd = open(params->filesystem, mode, 0600)) == -1)
                err(1, "Opening file system `%s' read-%s",
                    params->filesystem, op);
        if (fstat(params->fsfd, &params->fsstat) == -1)
                err(1, "Examining file system `%s'", params->filesystem);
        if (params->fstype != NULL) {
                if (! params->fstype->match(params))
                        errx(1, "File system `%s' is not of type %s",
                            params->filesystem, params->fstype->name);
        } else {
                if (params->stage2 != NULL) {
                        params->fstype = &fstypes[0];
                        while (params->fstype->name != NULL &&
                                    !params->fstype->match(params))
                                params->fstype++;
                        if (params->fstype->name == NULL)
                                errx(1, "File system `%s' is of an unknown type",
                                    params->filesystem);
                }
        }

        assert(params->machine != NULL);

        if (argc >= 2) {
                if ((params->s1fd = open(argv[1], O_RDONLY, 0600)) == -1)
                        err(1, "Opening primary bootstrap `%s'", argv[1]);
                if (fstat(params->s1fd, &params->s1stat) == -1)
                        err(1, "Examining primary bootstrap `%s'", argv[1]);
                if (!S_ISREG(params->s1stat.st_mode)) {
                        /*
                         * If the platform uses u-boot, then the stage1
                         * spec might be the directory where the u-boot
                         * binaries for the system are located.
                         */
                        if (params->machine->mach_flags & MF_UBOOT) {
                                if (!S_ISDIR(params->s1stat.st_mode)) {
                                        errx(1, "`%s' must be a regular file "
                                             "or a directory", argv[1]);
                                }
                                (void) close(params->s1fd);
                                params->s1fd = -1;
                        } else {
                                errx(1, "`%s' must be a regular file", argv[1]);
                        }
                }
                params->stage1 = argv[1];
        }

        if (params->flags & IB_VERBOSE) {
                printf("File system:         %s\n", params->filesystem);
                if (params->fstype) 
                        printf("File system type:    %s (blocksize %u, "
                                "needswap %d)\n",
                            params->fstype->name, params->fstype->blocksize,
                            params->fstype->needswap);
                if (!(params->flags & IB_EDIT))
                        printf("Primary bootstrap:   %s%s\n",
                            (params->flags & IB_CLEAR) ? "(to be cleared)"
                            : params->stage1 ? params->stage1 : "(none)",
                            S_ISDIR(params->s1stat.st_mode) ? " (directory)"
                                                            : "");
                if (params->stage2 != NULL)
                        printf("Secondary bootstrap: %s\n", params->stage2);
        }

        if (params->flags & IB_EDIT) {
                op = "Edit";
                rv = params->machine->editboot(params);
        } else if (params->flags & IB_CLEAR) {
                op = "Clear";
                rv = params->machine->clearboot(params);
        } else {
                if (argc < 2) {
                        /*
                         * If the platform uses u-boot, then the stage1 spec is
                         * optional iff they specified a board (because we can
                         * infer a default location for u-boot binaries if the
                         * board type is given).
                         */
                        if (!(params->machine->mach_flags & MF_UBOOT)) {
                                errx(EXIT_FAILURE,
                                   "Please specify the primary bootstrap file");
                        }
                }
                op = "Set";
                rv = params->machine->setboot(params);
        }
        if (rv == 0)
                errx(1, "%s bootstrap operation failed", op);

        if (S_ISREG(params->fsstat.st_mode)) {
                if (fsync(params->fsfd) == -1)
                        err(1, "Synchronising file system `%s'",
                            params->filesystem);
        } else {
                /* Sync filesystems (to clean in-memory superblock?) */
                sync();
        }
        if (close(params->fsfd) == -1)
                err(1, "Closing file system `%s'", params->filesystem);
        if (params->s1fd != -1)
                if (close(params->s1fd) == -1)
                        err(1, "Closing primary bootstrap `%s'",
                            params->stage1);

        exit(0);
        /* NOTREACHED */
}

static void
parseoptions(ib_params *params, const char *option)
{
        char *cp;
        const struct option *opt;
        int len;
        unsigned long val;

        assert(params != NULL);
        assert(option != NULL);

        for (;; option += len) {
                option += strspn(option, ", \t");
                if (*option == 0)
                        return;
                len = strcspn(option, "=,");
                for (opt = options; opt->name != NULL; opt++) {
                        if (memcmp(option, opt->name, len) == 0
                            && opt->name[len] == 0)
                                break;
                }
                if (opt->name == NULL) {
                        len = strcspn(option, ",");
                        warnx("Unknown option `-o %.*s'", len, option);
                        break;
                }
                params->flags |= opt->flag;
                if (opt->type == OPT_BOOL) {
                        if (option[len] != '=')
                                continue;
                        warnx("Option `%s' must not have a value", opt->name);
                        break;
                }
                if (option[len] != '=') {
                        warnx("Option `%s' must have a value", opt->name);
                        break;
                }
                option += len + 1;
                len = strcspn(option, ",");
                switch (opt->type) {
                case OPT_STRING:
                        len = strlen(option);
                        /* FALLTHROUGH */
                case OPT_WORD:
                        cp = strdup(option);
                        if (cp == NULL)
                                err(1, "strdup");
                        cp[len] = 0;
                        OPTION(params, char *, opt) = cp;
                        continue;
                case OPT_INT:
                        val = strtoul(option, &cp, 0);
                        if (cp > option + len || (*cp != 0 && *cp != ','))
                                break;
                        if (val > INT_MAX)
                                break;
                        OPTION(params, int, opt) = (int)val;
                        continue;
                default:
                        errx(1, "Internal error: option `%s' has invalid type %d",
                                opt->name, opt->type);
                }
                warnx("Invalid option value `%s=%.*s'", opt->name, len, option);
                break;
        }
        options_usage();
        exit(1);
}

static void
options_usage(void)
{
        int ndx;
        const char *pfx;

        warnx("Valid options are:");
        pfx = "\t";
        for (ndx = 0; options[ndx].name != 0; ndx++) {
                fprintf(stderr, "%s%s", pfx, options[ndx].name);
                switch (options[ndx].type) {
                case OPT_INT:
                        fprintf(stderr, "=number");
                        break;
                case OPT_WORD:
                        fprintf(stderr, "=word");
                        break;
                case OPT_STRING:
                        fprintf(stderr, "=string");
                        break;
                default:
                        break;
                }
                if ((ndx % 5) == 4)
                        pfx = ",\n\t";
                else
                        pfx = ", ";
        }
        fprintf(stderr, "\n");
}

int
no_setboot(ib_params *params)
{

        assert(params != NULL);

        warnx("%s: bootstrap installation is not supported",
            params->machine->name);
        return (0);
}

int
no_clearboot(ib_params *params)
{

        assert(params != NULL);

        warnx("%s: bootstrap removal is not supported",
            params->machine->name);
        return (0);
}

int
no_editboot(ib_params *params)
{

        assert(params != NULL);

        warnx("%s: bootstrap editing is not supported",
            params->machine->name);
        return (0);
}


static void
getmachine(ib_params *param, const char *mach, const char *provider)
{
        int     i;

        assert(param != NULL);
        assert(mach != NULL);
        assert(provider != NULL);

        for (i = 0; machines[i] != NULL; i++) {
                if (machines[i]->name == NULL)
                        continue;
                if (strcmp(machines[i]->name, mach) == 0) {
                        param->machine = machines[i];
                        return;
                }
        }
        warnx("Invalid machine `%s' from %s", mach, provider);
        machine_usage();
        exit(1);
}

static void
machine_usage(void)
{
        const char *prefix;
        int     i;
        int col, len;
        const char *name;
        int     wincol=80;
#ifdef TIOCGWINSZ
        struct winsize win;

        if (ioctl(fileno(stderr), TIOCGWINSZ, &win) == 0 && win.ws_col > 0)
                wincol = win.ws_col;
#endif

        warnx("Supported machines are:");
        prefix="\t";
        col = 8 + 3;
        for (i = 0; machines[i] != NULL; i++) {
                name = machines[i]->name;
                if (name == NULL)
                        continue;
                len = strlen(name);
                if (col + len > wincol) {
                        prefix=",\n\t";
                        col = -2 + 8 + 3;
                }
                col += fprintf(stderr, "%s%s", prefix, name);
                prefix=", ";
        }
        fputs("\n", stderr);
}

static void
getfstype(ib_params *param, const char *fstype, const char *provider)
{
        int i;

        assert(param != NULL);
        assert(fstype != NULL);
        assert(provider != NULL);

        for (i = 0; fstypes[i].name != NULL; i++) {
                if (strcmp(fstypes[i].name, fstype) == 0) {
                        param->fstype = &fstypes[i];
                        return;
                }
        }
        warnx("Invalid file system type `%s' from %s", fstype, provider);
        fstype_usage();
        exit(1);
}

static void
fstype_usage(void)
{
#ifndef NO_STAGE2
        const char *prefix;
        int     i;

        warnx("Supported file system types are:");
#define FSTYPES_PER_LINE        9
        prefix="\t";
        for (i = 0; fstypes[i].name != NULL; i++) {
                if (i && (i % FSTYPES_PER_LINE) == 0)
                        prefix=",\n\t";
                fprintf(stderr, "%s%s", prefix, fstypes[i].name);
                prefix=", ";
        }
        fputs("\n", stderr);
#endif
}

static void
getubootpaths(ib_params *param, const char *paths)
{
        assert(param != NULL);
        assert(paths != NULL);

        param->uboot_paths = paths;
}

static void
usage(void)
{
        const char      *prog;

        prog = getprogname();
        fprintf(stderr,
"usage: %s [-fnv] [-B s2bno] [-b s1bno] [-m machine] [-o options]\n"
"\t\t   [-t fstype] [-u uboot-paths] filesystem primary [secondary]\n"
"usage: %s -c [-fnv] [-m machine] [-o options] [-t fstype] filesystem\n"
"usage: %s -e [-fnv] [-m machine] [-o options] bootstrap\n",
            prog, prog, prog);
        machine_usage();
        fstype_usage();
        options_usage();
        if (installboot_params.machine != NULL &&
            installboot_params.machine->usage != NULL)
                installboot_params.machine->usage(&installboot_params);
        exit(1);
}