// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <ctype.h>
#include <fbl/string.h>
#include <fbl/vector.h>
#include <fuchsia/boot/c/fidl.h>
#include <launchpad/launchpad.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/fdio/fdio.h>
#include <lib/zx/debuglog.h>
#include <lib/zx/job.h>
#include <sstream>
#include <stdio.h>
#include <thread>
#include <utility>
#include <zircon/boot/image.h>
#include <zircon/dlfcn.h>
#include <zircon/process.h>
#include <zircon/processargs.h>
#include <zircon/status.h>

#include "bootfs-loader-service.h"
#include "bootfs-service.h"
#include "svcfs-service.h"
#include "util.h"

namespace {

// Wire up stdout so that printf() and friends work.
void SetupStdout() {
    zx::debuglog h;
    if (zx::debuglog::create(zx::resource(), 0, &h) < 0) {
        return;
    }
    fdio_t* logger = nullptr;
    zx_status_t status = fdio_create(h.release(), &logger);
    if (status != ZX_OK) {
        return;
    }
    close(1);
    fdio_bind_to_fd(logger, 1, 0);
}

// Load the boot arguments from bootfs and environment variables.
zx_status_t LoadBootArgs(const fbl::RefPtr<bootsvc::BootfsService>& bootfs, zx::vmo* out,
                         uint64_t* size) {
    // TODO(teisenbe): Rename this file
    const char* config_path = "/config/devmgr";
    fbl::Vector<char> buf;

    zx::vmo config_vmo;
    uint64_t file_size;
    zx_status_t status = bootfs->Open(config_path, &config_vmo, &file_size);
    if (status == ZX_OK) {
        auto config = std::make_unique<char[]>(file_size);
        status = config_vmo.read(config.get(), 0, file_size);
        if (status != ZX_OK) {
            return status;
        }

        // Parse boot arguments file from bootfs.
        std::string_view str(config.get(), file_size);
        status = bootsvc::ParseBootArgs(std::move(str), &buf);
        if (status != ZX_OK) {
            return status;
        }
    }

    // Add boot arguments from environment variables.
    for (char** e = environ; *e != nullptr; e++) {
        for (const char* x = *e; *x != 0; x++) {
            buf.push_back(*x);
        }
        buf.push_back(0);
    }

    // Copy boot arguments into VMO.
    zx::vmo args_vmo;
    status = zx::vmo::create(buf.size(), ZX_VMO_NON_RESIZABLE, &args_vmo);
    if (status != ZX_OK) {
        return status;
    }
    status = args_vmo.write(buf.get(), 0, buf.size());
    if (status != ZX_OK) {
        return status;
    }
    status = args_vmo.replace(ZX_DEFAULT_VMO_RIGHTS & ~ZX_RIGHT_WRITE, &args_vmo);
    if (status != ZX_OK) {
        return status;
    }
    *out = std::move(args_vmo);
    *size = buf.size();
    return ZX_OK;
}

// Launch the next process in the boot chain.
// It will receive:
// - stdout wired up via a debuglog handle
// - The boot cmdline arguments, via envp
// - A namespace containing a /boot, serviced by bootsvc
// - A loader that can load libraries from /boot, serviced by bootsvc
// - A handle to the root job
// - A handle to each of the bootdata VMOs the kernel provided
// - A handle to a channel containing the root resource, with type
//   BOOTSVC_ROOT_RESOURCE_CHANNEL_HND
void LaunchNextProcess(fbl::RefPtr<bootsvc::BootfsService> bootfs,
                       fbl::RefPtr<bootsvc::SvcfsService> svcfs,
                       fbl::RefPtr<bootsvc::BootfsLoaderService> loader_svc) {
    const char* bootsvc_next = getenv("bootsvc.next");
    if (bootsvc_next == nullptr) {
        bootsvc_next = "bin/devcoordinator";
    }

    // Split the bootsvc.next value into 1 or more arguments using ',' as a
    // delimiter.
    printf("bootsvc: bootsvc.next = %s\n", bootsvc_next);
    fbl::Vector<fbl::String> next_args = bootsvc::SplitString(bootsvc_next, ',');

    // Open the executable we will start next
    zx::vmo program;
    uint64_t file_size;
    const char* next_program = next_args[0].c_str();
    zx_status_t status = bootfs->Open(next_program, &program, &file_size);
    ZX_ASSERT_MSG(status == ZX_OK, "bootsvc: failed to open '%s': %s\n", next_program,
                  zx_status_get_string(status));

    // Get the bootfs fuchsia.io.Node service channel that we will hand to the
    // next process in the boot chain.
    zx::channel bootfs_conn;
    status = bootfs->CreateRootConnection(&bootfs_conn);
    ZX_ASSERT_MSG(status == ZX_OK, "bootfs conn creation failed: %s\n",
                  zx_status_get_string(status));

    zx::channel svcfs_conn;
    status = svcfs->CreateRootConnection(&svcfs_conn);
    ZX_ASSERT_MSG(status == ZX_OK, "svcfs conn creation failed: %s\n",
                  zx_status_get_string(status));

    const char* nametable[2] = {};
    uint32_t count = 0;

    launchpad_t* lp;
    launchpad_create(0, next_program, &lp);
    {
        // Use the local loader service backed directly by the primary BOOTFS.
        zx::channel local_loader_conn;
        status = loader_svc->Connect(&local_loader_conn);
        ZX_ASSERT_MSG(status == ZX_OK,
                      "failed to connect to BootfsLoaderService : %s\n",
                      zx_status_get_string(status));
        zx_handle_t old =
            launchpad_use_loader_service(lp, local_loader_conn.release());
        ZX_ASSERT(old == ZX_HANDLE_INVALID);
    }
    launchpad_load_from_vmo(lp, program.release());
    launchpad_clone(lp, LP_CLONE_DEFAULT_JOB);

    launchpad_add_handle(lp, bootfs_conn.release(), PA_HND(PA_NS_DIR, count));
    nametable[count++] = "/boot";
    launchpad_add_handle(lp, svcfs_conn.release(), PA_HND(PA_NS_DIR, count));
    nametable[count++] = "/bootsvc";

    int argc = static_cast<int>(next_args.size());
    const char* argv[argc];
    for (int i = 0; i < argc; ++i) {
        argv[i] = next_args[i].c_str();
    }
    launchpad_set_args(lp, argc, argv);

    ZX_ASSERT(count <= fbl::count_of(nametable));
    launchpad_set_nametable(lp, count, nametable);

    zx::debuglog debuglog;
    status = zx::debuglog::create(zx::resource(), 0, &debuglog);
    if (status != ZX_OK) {
        launchpad_abort(lp, status, "bootsvc: cannot create debuglog handle");
    } else {
        launchpad_add_handle(lp, debuglog.release(), PA_HND(PA_FD, FDIO_FLAG_USE_FOR_STDIO | 0));
    }

    const char* errmsg;
    status = launchpad_go(lp, nullptr, &errmsg);
    if (status != ZX_OK) {
        printf("bootsvc: launchpad %s failed: %s: %s\n", next_program, errmsg,
               zx_status_get_string(status));
    } else {
        printf("bootsvc: Launched %s\n", next_program);
    }
}

} // namespace

int main(int argc, char** argv) {
    SetupStdout();
    printf("bootsvc: Starting...\n");

    // Close the loader-service channel so the service can go away.
    // We won't use it any more (no dlopen calls in this process).
    zx_handle_close(dl_set_loader_service(ZX_HANDLE_INVALID));

    async::Loop loop(&kAsyncLoopConfigNoAttachToThread);

    zx::vmo bootfs_vmo(zx_take_startup_handle(PA_HND(PA_VMO_BOOTFS, 0)));
    ZX_ASSERT(bootfs_vmo.is_valid());

    // Set up the bootfs service
    printf("bootsvc: Creating bootfs service...\n");
    fbl::RefPtr<bootsvc::BootfsService> bootfs_svc;
    zx_status_t status = bootsvc::BootfsService::Create(loop.dispatcher(), &bootfs_svc);
    ZX_ASSERT_MSG(status == ZX_OK, "BootfsService creation failed: %s\n",
                  zx_status_get_string(status));
    status = bootfs_svc->AddBootfs(std::move(bootfs_vmo));
    ZX_ASSERT_MSG(status == ZX_OK, "bootfs add failed: %s\n", zx_status_get_string(status));

    // Process the ZBI boot image
    printf("bootsvc: Retrieving boot image...\n");
    zx::vmo image_vmo;
    bootsvc::ItemMap item_map;
    status = bootsvc::RetrieveBootImage(&image_vmo, &item_map);
    ZX_ASSERT_MSG(status == ZX_OK, "Retrieving boot image failed: %s\n",
                  zx_status_get_string(status));

    // Load boot arguments into VMO
    printf("bootsvc: Loading boot arguments...\n");
    zx::vmo args_vmo;
    uint64_t args_size = 0;
    status = LoadBootArgs(bootfs_svc, &args_vmo, &args_size);
    ZX_ASSERT_MSG(status == ZX_OK, "Loading boot arguments failed: %s\n",
                  zx_status_get_string(status));

    // Set up the svcfs service
    printf("bootsvc: Creating svcfs service...\n");
    fbl::RefPtr<bootsvc::SvcfsService> svcfs_svc = bootsvc::SvcfsService::Create(loop.dispatcher());
    svcfs_svc->AddService(fuchsia_boot_Arguments_Name,
                          bootsvc::CreateArgumentsService(loop.dispatcher(), std::move(args_vmo),
                                                          args_size));
    svcfs_svc->AddService(fuchsia_boot_Items_Name,
                          bootsvc::CreateItemsService(loop.dispatcher(), std::move(image_vmo),
                                                      std::move(item_map)));
    zx::job::default_job()->set_property(ZX_PROP_NAME, "root", 4);
    svcfs_svc->AddService(fuchsia_boot_RootJob_Name,
                          bootsvc::CreateRootJobService(loop.dispatcher()));
    svcfs_svc->AddService(fuchsia_boot_RootResource_Name,
                          bootsvc::CreateRootResourceService(loop.dispatcher()));

    // Consume certain VMO types from the startup handle table
    printf("bootsvc: Loading kernel VMOs...\n");
    bootfs_svc->PublishStartupVmos(PA_VMO_VDSO, "PA_VMO_VDSO");
    bootfs_svc->PublishStartupVmos(PA_VMO_KERNEL_FILE, "PA_VMO_KERNEL_FILE");

    // Creating the loader service
    printf("bootsvc: Creating loader service...\n");
    fbl::RefPtr<bootsvc::BootfsLoaderService> loader_svc;
    status = bootsvc::BootfsLoaderService::Create(bootfs_svc, loop.dispatcher(), &loader_svc);
    ZX_ASSERT_MSG(status == ZX_OK, "BootfsLoaderService creation failed: %s\n",
                  zx_status_get_string(status));

    // Launch the next process in the chain.  This must be in a thread, since
    // it may issue requests to the loader, which runs in the async loop that
    // starts running after this.
    printf("bootsvc: Launching next process...\n");
    std::thread(LaunchNextProcess, bootfs_svc, svcfs_svc, loader_svc).detach();

    // Begin serving the bootfs fileystem and loader
    loop.Run();
    return 0;
}