// SPDX-License-Identifier: GPL-2.0-only

#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/utsname.h>
#include <unistd.h>
#include <fcntl.h>
#include <zlib.h>

#include "unpriv_helpers.h"

static gzFile open_config(void)
{
        struct utsname uts;
        char buf[PATH_MAX];
        gzFile config;

        if (uname(&uts)) {
                perror("uname");
                goto config_gz;
        }

        snprintf(buf, sizeof(buf), "/boot/config-%s", uts.release);
        config = gzopen(buf, "rb");
        if (config)
                return config;
        fprintf(stderr, "gzopen %s: %s\n", buf, strerror(errno));

config_gz:
        config = gzopen("/proc/config.gz", "rb");
        if (!config)
                perror("gzopen /proc/config.gz");
        return config;
}

static int config_contains(const char *pat)
{
        const char *msg;
        char buf[1024];
        gzFile config;
        int n, err;

        config = open_config();
        if (!config)
                return -1;

        for (;;) {
                if (!gzgets(config, buf, sizeof(buf))) {
                        msg = gzerror(config, &err);
                        if (err == Z_ERRNO)
                                perror("gzgets /proc/config.gz");
                        else if (err != Z_OK)
                                fprintf(stderr, "gzgets /proc/config.gz: %s", msg);
                        gzclose(config);
                        return -1;
                }
                n = strlen(buf);
                if (buf[n - 1] == '\n')
                        buf[n - 1] = 0;
                if (strcmp(buf, pat) == 0) {
                        gzclose(config);
                        return 1;
                }
        }
        gzclose(config);
        return 0;
}

static bool cmdline_contains(const char *pat)
{
        char cmdline[4096], *c;
        int fd, ret = false;

        fd = open("/proc/cmdline", O_RDONLY);
        if (fd < 0) {
                perror("open /proc/cmdline");
                return false;
        }

        if (read(fd, cmdline, sizeof(cmdline) - 1) < 0) {
                perror("read /proc/cmdline");
                goto out;
        }

        cmdline[sizeof(cmdline) - 1] = '\0';
        for (c = strtok(cmdline, " \n"); c; c = strtok(NULL, " \n")) {
                if (strncmp(c, pat, strlen(c)))
                        continue;
                ret = true;
                break;
        }
out:
        close(fd);
        return ret;
}

static int get_mitigations_off(void)
{
        int enabled_in_config;

        if (cmdline_contains("mitigations=off"))
                return 1;
        enabled_in_config = config_contains("CONFIG_CPU_MITIGATIONS=y");
        if (enabled_in_config < 0)
                return -1;
        return !enabled_in_config;
}

bool get_unpriv_disabled(void)
{
        int mitigations_off;
        bool disabled;
        char buf[2];
        FILE *fd;

        fd = fopen("/proc/sys/" UNPRIV_SYSCTL, "r");
        if (fd) {
                disabled = (fgets(buf, 2, fd) == buf && atoi(buf));
                fclose(fd);
        } else {
                perror("fopen /proc/sys/" UNPRIV_SYSCTL);
                disabled = true;
        }

        if (disabled)
                return true;

        /*
         * Some unpriv tests rely on spectre mitigations being on.
         * If mitigations are off or status can't be determined
         * assume that unpriv tests are disabled.
         */
        mitigations_off = get_mitigations_off();
        if (mitigations_off < 0) {
                fprintf(stderr,
                        "Can't determine if mitigations are enabled, disabling unpriv tests.");
                return true;
        }
        return mitigations_off;
}