// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
 */

#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include <xalloc.h>
#include "internal.h"
#include "lkc.h"

struct gstr autoconf_cmd;

/* return true if 'path' exists, false otherwise */
static bool is_present(const char *path)
{
        struct stat st;

        return !stat(path, &st);
}

/* return true if 'path' exists and it is a directory, false otherwise */
static bool is_dir(const char *path)
{
        struct stat st;

        if (stat(path, &st))
                return false;

        return S_ISDIR(st.st_mode);
}

/* return true if the given two files are the same, false otherwise */
static bool is_same(const char *file1, const char *file2)
{
        int fd1, fd2;
        struct stat st1, st2;
        void *map1, *map2;
        bool ret = false;

        fd1 = open(file1, O_RDONLY);
        if (fd1 < 0)
                return ret;

        fd2 = open(file2, O_RDONLY);
        if (fd2 < 0)
                goto close1;

        ret = fstat(fd1, &st1);
        if (ret)
                goto close2;
        ret = fstat(fd2, &st2);
        if (ret)
                goto close2;

        if (st1.st_size != st2.st_size)
                goto close2;

        map1 = mmap(NULL, st1.st_size, PROT_READ, MAP_PRIVATE, fd1, 0);
        if (map1 == MAP_FAILED)
                goto close2;

        map2 = mmap(NULL, st2.st_size, PROT_READ, MAP_PRIVATE, fd2, 0);
        if (map2 == MAP_FAILED)
                goto close2;

        if (memcmp(map1, map2, st1.st_size))
                goto close2;

        ret = true;
close2:
        close(fd2);
close1:
        close(fd1);

        return ret;
}

/*
 * Create the parent directory of the given path.
 *
 * For example, if 'include/config/auto.conf' is given, create 'include/config'.
 */
static int make_parent_dir(const char *path)
{
        char tmp[PATH_MAX + 1];
        char *p;

        strncpy(tmp, path, sizeof(tmp));
        tmp[sizeof(tmp) - 1] = 0;

        /* Remove the base name. Just return if nothing is left */
        p = strrchr(tmp, '/');
        if (!p)
                return 0;
        *(p + 1) = 0;

        /* Just in case it is an absolute path */
        p = tmp;
        while (*p == '/')
                p++;

        while ((p = strchr(p, '/'))) {
                *p = 0;

                /* skip if the directory exists */
                if (!is_dir(tmp) && mkdir(tmp, 0755))
                        return -1;

                *p = '/';
                while (*p == '/')
                        p++;
        }

        return 0;
}

static char depfile_path[PATH_MAX];
static size_t depfile_prefix_len;

/* touch depfile for symbol 'name' */
static int conf_touch_dep(const char *name)
{
        int fd;

        /* check overflow: prefix + name + '\0' must fit in buffer. */
        if (depfile_prefix_len + strlen(name) + 1 > sizeof(depfile_path))
                return -1;

        strcpy(depfile_path + depfile_prefix_len, name);

        fd = open(depfile_path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
        if (fd == -1)
                return -1;
        close(fd);

        return 0;
}

static void conf_warning(const char *fmt, ...)
        __attribute__ ((format (printf, 1, 2)));

static void conf_message(const char *fmt, ...)
        __attribute__ ((format (printf, 1, 2)));

static const char *conf_filename;
static int conf_lineno, conf_warnings;

bool conf_errors(void)
{
        if (conf_warnings)
                return getenv("KCONFIG_WERROR");
        return false;
}

static void conf_warning(const char *fmt, ...)
{
        va_list ap;
        va_start(ap, fmt);
        fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
        vfprintf(stderr, fmt, ap);
        fprintf(stderr, "\n");
        va_end(ap);
        conf_warnings++;
}

static void conf_default_message_callback(const char *s)
{
        printf("#\n# ");
        printf("%s", s);
        printf("\n#\n");
}

static void (*conf_message_callback)(const char *s) =
        conf_default_message_callback;
void conf_set_message_callback(void (*fn)(const char *s))
{
        conf_message_callback = fn;
}

static void conf_message(const char *fmt, ...)
{
        va_list ap;
        char buf[4096];

        if (!conf_message_callback)
                return;

        va_start(ap, fmt);

        vsnprintf(buf, sizeof(buf), fmt, ap);
        conf_message_callback(buf);
        va_end(ap);
}

const char *conf_get_configname(void)
{
        char *name = getenv("KCONFIG_CONFIG");

        return name ? name : ".config";
}

static const char *conf_get_autoconfig_name(void)
{
        char *name = getenv("KCONFIG_AUTOCONFIG");

        return name ? name : "include/config/auto.conf";
}

static const char *conf_get_autoheader_name(void)
{
        char *name = getenv("KCONFIG_AUTOHEADER");

        return name ? name : "include/generated/autoconf.h";
}

static const char *conf_get_rustccfg_name(void)
{
        char *name = getenv("KCONFIG_RUSTCCFG");

        return name ? name : "include/generated/rustc_cfg";
}

static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)
{
        char *p2;

        switch (sym->type) {
        case S_TRISTATE:
                if (p[0] == 'm') {
                        sym->def[def].tri = mod;
                        sym->flags |= def_flags;
                        break;
                }
                /* fall through */
        case S_BOOLEAN:
                if (p[0] == 'y') {
                        sym->def[def].tri = yes;
                        sym->flags |= def_flags;
                        break;
                }
                if (p[0] == 'n') {
                        sym->def[def].tri = no;
                        sym->flags |= def_flags;
                        break;
                }
                if (def != S_DEF_AUTO)
                        conf_warning("symbol value '%s' invalid for %s",
                                     p, sym->name);
                return 1;
        case S_STRING:
                /* No escaping for S_DEF_AUTO (include/config/auto.conf) */
                if (def != S_DEF_AUTO) {
                        if (*p++ != '"')
                                break;
                        for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
                                if (*p2 == '"') {
                                        *p2 = 0;
                                        break;
                                }
                                memmove(p2, p2 + 1, strlen(p2));
                        }
                        if (!p2) {
                                conf_warning("invalid string found");
                                return 1;
                        }
                }
                /* fall through */
        case S_INT:
        case S_HEX:
                if (sym_string_valid(sym, p)) {
                        sym->def[def].val = xstrdup(p);
                        sym->flags |= def_flags;
                } else {
                        if (def != S_DEF_AUTO)
                                conf_warning("symbol value '%s' invalid for %s",
                                             p, sym->name);
                        return 1;
                }
                break;
        default:
                ;
        }
        return 0;
}

/* like getline(), but the newline character is stripped away */
static ssize_t getline_stripped(char **lineptr, size_t *n, FILE *stream)
{
        ssize_t len;

        len = getline(lineptr, n, stream);

        if (len > 0 && (*lineptr)[len - 1] == '\n') {
                len--;
                (*lineptr)[len] = '\0';

                if (len > 0 && (*lineptr)[len - 1] == '\r') {
                        len--;
                        (*lineptr)[len] = '\0';
                }
        }

        return len;
}

int conf_read_simple(const char *name, int def)
{
        FILE *in = NULL;
        char   *line = NULL;
        size_t  line_asize = 0;
        char *p, *val;
        struct symbol *sym;
        int def_flags;
        const char *warn_unknown, *sym_name;

        warn_unknown = getenv("KCONFIG_WARN_UNKNOWN_SYMBOLS");
        if (name) {
                in = zconf_fopen(name);
        } else {
                char *env;

                name = conf_get_configname();
                in = zconf_fopen(name);
                if (in)
                        goto load;
                conf_set_changed(true);

                env = getenv("KCONFIG_DEFCONFIG_LIST");
                if (!env)
                        return 1;

                while (1) {
                        bool is_last;

                        while (isspace(*env))
                                env++;

                        if (!*env)
                                break;

                        p = env;
                        while (*p && !isspace(*p))
                                p++;

                        is_last = (*p == '\0');

                        *p = '\0';

                        name = env;

                        in = zconf_fopen(name);
                        if (in) {
                                conf_message("using defaults found in %s",
                                             name);
                                goto load;
                        }

                        if (is_last)
                                break;

                        env = p + 1;
                }
        }
        if (!in)
                return 1;

load:
        conf_filename = name;
        conf_lineno = 0;
        conf_warnings = 0;

        def_flags = SYMBOL_DEF << def;
        for_all_symbols(sym) {
                sym->flags &= ~def_flags;
                switch (sym->type) {
                case S_INT:
                case S_HEX:
                case S_STRING:
                        free(sym->def[def].val);
                        /* fall through */
                default:
                        sym->def[def].val = NULL;
                        sym->def[def].tri = no;
                }
        }

        if (def == S_DEF_USER) {
                for_all_symbols(sym)
                        sym->flags &= ~SYMBOL_VALID;
                expr_invalidate_all();
        }

        while (getline_stripped(&line, &line_asize, in) != -1) {
                struct menu *choice;

                conf_lineno++;

                if (!line[0]) /* blank line */
                        continue;

                if (line[0] == '#') {
                        if (line[1] != ' ')
                                continue;
                        p = line + 2;
                        if (memcmp(p, CONFIG_, strlen(CONFIG_)))
                                continue;
                        sym_name = p + strlen(CONFIG_);
                        p = strchr(sym_name, ' ');
                        if (!p)
                                continue;
                        *p++ = 0;
                        if (strcmp(p, "is not set"))
                                continue;

                        val = "n";
                } else {
                        if (memcmp(line, CONFIG_, strlen(CONFIG_))) {
                                conf_warning("unexpected data: %s", line);
                                continue;
                        }

                        sym_name = line + strlen(CONFIG_);
                        p = strchr(sym_name, '=');
                        if (!p) {
                                conf_warning("unexpected data: %s", line);
                                continue;
                        }
                        *p = 0;
                        val = p + 1;
                }

                sym = sym_find(sym_name);
                if (!sym) {
                        if (def == S_DEF_AUTO) {
                                /*
                                 * Reading from include/config/auto.conf.
                                 * If CONFIG_FOO previously existed in auto.conf
                                 * but it is missing now, include/config/FOO
                                 * must be touched.
                                 */
                                conf_touch_dep(sym_name);
                        } else {
                                if (warn_unknown)
                                        conf_warning("unknown symbol: %s", sym_name);

                                conf_set_changed(true);
                        }
                        continue;
                }

                if (sym->flags & def_flags)
                        conf_warning("override: reassigning to symbol %s", sym->name);

                if (conf_set_sym_val(sym, def, def_flags, val))
                        continue;

                if (def != S_DEF_USER)
                        continue;

                /*
                 * If this is a choice member, give it the highest priority.
                 * If conflicting CONFIG options are given from an input file,
                 * the last one wins.
                 */
                choice = sym_get_choice_menu(sym);
                if (choice)
                        list_move(&sym->choice_link, &choice->choice_members);
        }
        free(line);
        fclose(in);

        return 0;
}

int conf_read(const char *name)
{
        struct symbol *sym;

        conf_set_changed(false);

        if (conf_read_simple(name, S_DEF_USER)) {
                sym_calc_value(modules_sym);
                return 1;
        }

        sym_calc_value(modules_sym);

        for_all_symbols(sym) {
                sym_calc_value(sym);
                if (sym_is_choice(sym))
                        continue;
                if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
                        /* check that calculated value agrees with saved value */
                        switch (sym->type) {
                        case S_BOOLEAN:
                        case S_TRISTATE:
                                if (sym->def[S_DEF_USER].tri == sym_get_tristate_value(sym))
                                        continue;
                                break;
                        default:
                                if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
                                        continue;
                                break;
                        }
                } else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
                        /* no previous value and not saved */
                        continue;
                conf_set_changed(true);
                /* maybe print value in verbose mode... */
        }

        if (conf_warnings)
                conf_set_changed(true);

        return 0;
}

struct comment_style {
        const char *decoration;
        const char *prefix;
        const char *postfix;
};

static const struct comment_style comment_style_pound = {
        .decoration = "#",
        .prefix = "#",
        .postfix = "#",
};

static const struct comment_style comment_style_c = {
        .decoration = " *",
        .prefix = "/*",
        .postfix = " */",
};

static void conf_write_heading(FILE *fp, const struct comment_style *cs)
{
        if (!cs)
                return;

        fprintf(fp, "%s\n", cs->prefix);

        fprintf(fp, "%s Automatically generated file; DO NOT EDIT.\n",
                cs->decoration);

        fprintf(fp, "%s %s\n", cs->decoration, rootmenu.prompt->text);

        fprintf(fp, "%s\n", cs->postfix);
}

/* The returned pointer must be freed on the caller side */
static char *escape_string_value(const char *in)
{
        const char *p;
        char *out;
        size_t len;

        len = strlen(in) + strlen("\"\"") + 1;

        p = in;
        while (1) {
                p += strcspn(p, "\"\\");

                if (p[0] == '\0')
                        break;

                len++;
                p++;
        }

        out = xmalloc(len);
        out[0] = '\0';

        strcat(out, "\"");

        p = in;
        while (1) {
                len = strcspn(p, "\"\\");
                strncat(out, p, len);
                p += len;

                if (p[0] == '\0')
                        break;

                strcat(out, "\\");
                strncat(out, p++, 1);
        }

        strcat(out, "\"");

        return out;
}

enum output_n { OUTPUT_N, OUTPUT_N_AS_UNSET, OUTPUT_N_NONE };

static void __print_symbol(FILE *fp, struct symbol *sym, enum output_n output_n,
                           bool escape_string)
{
        const char *val;
        char *escaped = NULL;

        if (sym->type == S_UNKNOWN)
                return;

        val = sym_get_string_value(sym);

        if ((sym->type == S_BOOLEAN || sym->type == S_TRISTATE) &&
            output_n != OUTPUT_N && *val == 'n') {
                if (output_n == OUTPUT_N_AS_UNSET)
                        fprintf(fp, "# %s%s is not set\n", CONFIG_, sym->name);
                return;
        }

        if (sym->type == S_STRING && escape_string) {
                escaped = escape_string_value(val);
                val = escaped;
        }

        fprintf(fp, "%s%s=%s\n", CONFIG_, sym->name, val);

        free(escaped);
}

static void print_symbol_for_dotconfig(FILE *fp, struct symbol *sym)
{
        __print_symbol(fp, sym, OUTPUT_N_AS_UNSET, true);
}

static void print_symbol_for_autoconf(FILE *fp, struct symbol *sym)
{
        __print_symbol(fp, sym, OUTPUT_N_NONE, false);
}

void print_symbol_for_listconfig(struct symbol *sym)
{
        __print_symbol(stdout, sym, OUTPUT_N, true);
}

static void print_symbol_for_c(FILE *fp, struct symbol *sym)
{
        const char *val;
        const char *sym_suffix = "";
        const char *val_prefix = "";
        char *escaped = NULL;

        if (sym->type == S_UNKNOWN)
                return;

        val = sym_get_string_value(sym);

        switch (sym->type) {
        case S_BOOLEAN:
        case S_TRISTATE:
                switch (*val) {
                case 'n':
                        return;
                case 'm':
                        sym_suffix = "_MODULE";
                        /* fall through */
                default:
                        val = "1";
                }
                break;
        case S_HEX:
                if (val[0] != '0' || (val[1] != 'x' && val[1] != 'X'))
                        val_prefix = "0x";
                break;
        case S_STRING:
                escaped = escape_string_value(val);
                val = escaped;
        default:
                break;
        }

        fprintf(fp, "#define %s%s%s %s%s\n", CONFIG_, sym->name, sym_suffix,
                val_prefix, val);

        free(escaped);
}

static void print_symbol_for_rustccfg(FILE *fp, struct symbol *sym)
{
        const char *val;
        const char *val_prefix = "";
        char *val_prefixed = NULL;
        size_t val_prefixed_len;
        char *escaped = NULL;

        if (sym->type == S_UNKNOWN)
                return;

        val = sym_get_string_value(sym);

        switch (sym->type) {
        case S_BOOLEAN:
        case S_TRISTATE:
                /*
                 * We do not care about disabled ones, i.e. no need for
                 * what otherwise are "comments" in other printers.
                 */
                if (*val == 'n')
                        return;

                /*
                 * To have similar functionality to the C macro `IS_ENABLED()`
                 * we provide an empty `--cfg CONFIG_X` here in both `y`
                 * and `m` cases.
                 *
                 * Then, the common `fprintf()` below will also give us
                 * a `--cfg CONFIG_X="y"` or `--cfg CONFIG_X="m"`, which can
                 * be used as the equivalent of `IS_BUILTIN()`/`IS_MODULE()`.
                 */
                fprintf(fp, "--cfg=%s%s\n", CONFIG_, sym->name);
                break;
        case S_HEX:
                if (val[0] != '0' || (val[1] != 'x' && val[1] != 'X'))
                        val_prefix = "0x";
                break;
        default:
                break;
        }

        if (strlen(val_prefix) > 0) {
                val_prefixed_len = strlen(val) + strlen(val_prefix) + 1;
                val_prefixed = xmalloc(val_prefixed_len);
                snprintf(val_prefixed, val_prefixed_len, "%s%s", val_prefix, val);
                val = val_prefixed;
        }

        /* All values get escaped: the `--cfg` option only takes strings */
        escaped = escape_string_value(val);
        val = escaped;

        fprintf(fp, "--cfg=%s%s=%s\n", CONFIG_, sym->name, val);

        free(escaped);
        free(val_prefixed);
}

/*
 * Write out a minimal config.
 * All values that has default values are skipped as this is redundant.
 */
int conf_write_defconfig(const char *filename)
{
        struct symbol *sym;
        struct menu *menu;
        FILE *out;

        out = fopen(filename, "w");
        if (!out)
                return 1;

        sym_clear_all_valid();

        menu_for_each_entry(menu) {
                struct menu *choice;

                sym = menu->sym;

                if (!sym || sym_is_choice(sym))
                        continue;

                sym_calc_value(sym);
                if (!(sym->flags & SYMBOL_WRITE))
                        continue;
                sym->flags &= ~SYMBOL_WRITE;
                /* Skip unchangeable symbols */
                if (!sym_is_changeable(sym))
                        continue;
                /* Skip symbols that are equal to the default */
                if (!strcmp(sym_get_string_value(sym), sym_get_string_default(sym)))
                        continue;

                /* Skip choice values that are equal to the default */
                choice = sym_get_choice_menu(sym);
                if (choice) {
                        struct symbol *ds;

                        ds = sym_choice_default(choice);
                        if (sym == ds && sym_get_tristate_value(sym) == yes)
                                continue;
                }
                print_symbol_for_dotconfig(out, sym);
        }
        fclose(out);
        return 0;
}

int conf_write(const char *name)
{
        FILE *out;
        struct symbol *sym;
        struct menu *menu;
        const char *str;
        char tmpname[PATH_MAX + 1], oldname[PATH_MAX + 1];
        char *env;
        bool need_newline = false;

        if (!name)
                name = conf_get_configname();

        if (!*name) {
                fprintf(stderr, "config name is empty\n");
                return -1;
        }

        if (is_dir(name)) {
                fprintf(stderr, "%s: Is a directory\n", name);
                return -1;
        }

        if (make_parent_dir(name))
                return -1;

        env = getenv("KCONFIG_OVERWRITECONFIG");
        if (env && *env) {
                *tmpname = 0;
                out = fopen(name, "w");
        } else {
                snprintf(tmpname, sizeof(tmpname), "%s.%d.tmp",
                         name, (int)getpid());
                out = fopen(tmpname, "w");
        }
        if (!out)
                return 1;

        conf_write_heading(out, &comment_style_pound);

        if (!conf_get_changed())
                sym_clear_all_valid();

        menu = rootmenu.list;
        while (menu) {
                sym = menu->sym;
                if (!sym) {
                        if (!menu_is_visible(menu))
                                goto next;
                        str = menu_get_prompt(menu);
                        fprintf(out, "\n"
                                     "#\n"
                                     "# %s\n"
                                     "#\n", str);
                        need_newline = false;
                } else if (!sym_is_choice(sym) &&
                           !(sym->flags & SYMBOL_WRITTEN)) {
                        sym_calc_value(sym);
                        if (!(sym->flags & SYMBOL_WRITE))
                                goto next;
                        if (need_newline) {
                                fprintf(out, "\n");
                                need_newline = false;
                        }
                        sym->flags |= SYMBOL_WRITTEN;
                        print_symbol_for_dotconfig(out, sym);
                }

next:
                if (menu->list) {
                        menu = menu->list;
                        continue;
                }

end_check:
                if (!menu->sym && menu_is_visible(menu) && menu != &rootmenu &&
                    menu->prompt->type == P_MENU) {
                        fprintf(out, "# end of %s\n", menu_get_prompt(menu));
                        need_newline = true;
                }

                if (menu->next) {
                        menu = menu->next;
                } else {
                        menu = menu->parent;
                        if (menu)
                                goto end_check;
                }
        }
        fclose(out);

        for_all_symbols(sym)
                sym->flags &= ~SYMBOL_WRITTEN;

        if (*tmpname) {
                if (is_same(name, tmpname)) {
                        conf_message("No change to %s", name);
                        unlink(tmpname);
                        conf_set_changed(false);
                        return 0;
                }

                snprintf(oldname, sizeof(oldname), "%s.old", name);
                rename(name, oldname);
                if (rename(tmpname, name))
                        return 1;
        }

        conf_message("configuration written to %s", name);

        conf_set_changed(false);

        return 0;
}

/* write a dependency file as used by kbuild to track dependencies */
static int conf_write_autoconf_cmd(const char *autoconf_name)
{
        char name[PATH_MAX], tmp[PATH_MAX];
        FILE *out;
        int ret;

        ret = snprintf(name, sizeof(name), "%s.cmd", autoconf_name);
        if (ret >= sizeof(name)) /* check truncation */
                return -1;

        if (make_parent_dir(name))
                return -1;

        ret = snprintf(tmp, sizeof(tmp), "%s.cmd.tmp", autoconf_name);
        if (ret >= sizeof(tmp)) /* check truncation */
                return -1;

        out = fopen(tmp, "w");
        if (!out) {
                perror("fopen");
                return -1;
        }

        fprintf(out, "autoconfig := %s\n", autoconf_name);

        fputs(str_get(&autoconf_cmd), out);

        fflush(out);
        ret = ferror(out); /* error check for all fprintf() calls */
        fclose(out);
        if (ret)
                return -1;

        if (rename(tmp, name)) {
                perror("rename");
                return -1;
        }

        return 0;
}

static int conf_touch_deps(void)
{
        const char *name, *tmp;
        struct symbol *sym;
        int res;

        name = conf_get_autoconfig_name();
        tmp = strrchr(name, '/');
        depfile_prefix_len = tmp ? tmp - name + 1 : 0;
        if (depfile_prefix_len + 1 > sizeof(depfile_path))
                return -1;

        strncpy(depfile_path, name, depfile_prefix_len);
        depfile_path[depfile_prefix_len] = 0;

        conf_read_simple(name, S_DEF_AUTO);

        for_all_symbols(sym) {
                if (sym_is_choice(sym))
                        continue;
                if (sym->flags & SYMBOL_WRITE) {
                        if (sym->flags & SYMBOL_DEF_AUTO) {
                                /*
                                 * symbol has old and new value,
                                 * so compare them...
                                 */
                                switch (sym->type) {
                                case S_BOOLEAN:
                                case S_TRISTATE:
                                        if (sym_get_tristate_value(sym) ==
                                            sym->def[S_DEF_AUTO].tri)
                                                continue;
                                        break;
                                case S_STRING:
                                case S_HEX:
                                case S_INT:
                                        if (!strcmp(sym_get_string_value(sym),
                                                    sym->def[S_DEF_AUTO].val))
                                                continue;
                                        break;
                                default:
                                        break;
                                }
                        } else {
                                /*
                                 * If there is no old value, only 'no' (unset)
                                 * is allowed as new value.
                                 */
                                switch (sym->type) {
                                case S_BOOLEAN:
                                case S_TRISTATE:
                                        if (sym_get_tristate_value(sym) == no)
                                                continue;
                                        break;
                                default:
                                        break;
                                }
                        }
                } else if (!(sym->flags & SYMBOL_DEF_AUTO))
                        /* There is neither an old nor a new value. */
                        continue;
                /* else
                 *      There is an old value, but no new value ('no' (unset)
                 *      isn't saved in auto.conf, so the old value is always
                 *      different from 'no').
                 */

                res = conf_touch_dep(sym->name);
                if (res)
                        return res;
        }

        return 0;
}

static int __conf_write_autoconf(const char *filename,
                                 void (*print_symbol)(FILE *, struct symbol *),
                                 const struct comment_style *comment_style)
{
        char tmp[PATH_MAX];
        FILE *file;
        struct symbol *sym;
        int ret;

        if (make_parent_dir(filename))
                return -1;

        ret = snprintf(tmp, sizeof(tmp), "%s.tmp", filename);
        if (ret >= sizeof(tmp)) /* check truncation */
                return -1;

        file = fopen(tmp, "w");
        if (!file) {
                perror("fopen");
                return -1;
        }

        conf_write_heading(file, comment_style);

        for_all_symbols(sym)
                if ((sym->flags & SYMBOL_WRITE) && sym->name)
                        print_symbol(file, sym);

        fflush(file);
        /* check possible errors in conf_write_heading() and print_symbol() */
        ret = ferror(file);
        fclose(file);
        if (ret)
                return -1;

        if (rename(tmp, filename)) {
                perror("rename");
                return -1;
        }

        return 0;
}

int conf_write_autoconf(int overwrite)
{
        struct symbol *sym;
        const char *autoconf_name = conf_get_autoconfig_name();
        int ret;

        if (!overwrite && is_present(autoconf_name))
                return 0;

        ret = conf_write_autoconf_cmd(autoconf_name);
        if (ret)
                return -1;

        for_all_symbols(sym)
                sym_calc_value(sym);

        if (conf_touch_deps())
                return 1;

        ret = __conf_write_autoconf(conf_get_autoheader_name(),
                                    print_symbol_for_c,
                                    &comment_style_c);
        if (ret)
                return ret;

        ret = __conf_write_autoconf(conf_get_rustccfg_name(),
                                    print_symbol_for_rustccfg,
                                    NULL);
        if (ret)
                return ret;

        /*
         * Create include/config/auto.conf. This must be the last step because
         * Kbuild has a dependency on auto.conf and this marks the successful
         * completion of the previous steps.
         */
        ret = __conf_write_autoconf(conf_get_autoconfig_name(),
                                    print_symbol_for_autoconf,
                                    &comment_style_pound);
        if (ret)
                return ret;

        return 0;
}

static bool conf_changed;
static void (*conf_changed_callback)(bool);

void conf_set_changed(bool val)
{
        if (conf_changed_callback && conf_changed != val)
                conf_changed_callback(val);

        conf_changed = val;
}

bool conf_get_changed(void)
{
        return conf_changed;
}

void conf_set_changed_callback(void (*fn)(bool))
{
        conf_changed_callback = fn;
}