/*
 * Copyright (c) 2020 Kungliga Tekniska Högskolan
 * (Royal Institute of Technology, Stockholm, Sweden).
 * All rights reserved.
 *
 * 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.
 *
 * 3. Neither the name of the Institute nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE 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 INSTITUTE 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 "baselocl.h"

#undef __attribute__
#define __attribute__(X)

heim_context
heim_context_init(void)
{
    heim_context context;

    if ((context = calloc(1, sizeof(*context))) == NULL)
        return NULL;

    context->homedir_access = !issuid();
    context->log_utc = 1;
    context->error_string = NULL;
    context->debug_dest = NULL;
    context->warn_dest = NULL;
    context->log_dest = NULL;
    context->time_fmt = NULL;
    context->et_list = NULL;
    return context;
}

void
heim_context_free(heim_context *contextp)
{
    heim_context context = *contextp;

    *contextp = NULL;
    if (!context)
        return;
    heim_closelog(context, context->debug_dest);
    heim_closelog(context, context->warn_dest);
    heim_closelog(context, context->log_dest);
    free_error_table(context->et_list);
    free(context->time_fmt);
    free(context->error_string);
    free(context);
}

heim_error_code
heim_add_et_list(heim_context context, void (*func)(struct et_list **))
{
    (*func)(&context->et_list);
    return 0;
}

heim_error_code
heim_context_set_time_fmt(heim_context context, const char *fmt)
{
    char *s;

    if (fmt == NULL) {
        free(context->time_fmt);
        return 0;
    }
    if ((s = strdup(fmt)) == NULL)
        return heim_enomem(context);
    free(context->time_fmt);
    context->time_fmt = s;
    return 0;
}

const char *
heim_context_get_time_fmt(heim_context context)
{
    return context->time_fmt ? context->time_fmt : "%Y-%m-%dT%H:%M:%S";
}

unsigned int
heim_context_set_log_utc(heim_context context, unsigned int log_utc)
{
    unsigned int old = context->log_utc;

    context->log_utc = log_utc ? 1 : 0;
    return old;
}

int
heim_context_get_log_utc(heim_context context)
{
    return context->log_utc;
}

unsigned int
heim_context_set_homedir_access(heim_context context, unsigned int homedir_access)
{
    unsigned int old = context->homedir_access;

    context->homedir_access = homedir_access ? 1 : 0;
    return old;
}

unsigned int
heim_context_get_homedir_access(heim_context context)
{
    return context->homedir_access;
}

heim_error_code
heim_enomem(heim_context context)
{
    heim_set_error_message(context, ENOMEM, "malloc: out of memory");
    return ENOMEM;
}

heim_log_facility *
heim_get_log_dest(heim_context context)
{
    return context->log_dest;
}

heim_log_facility *
heim_get_warn_dest(heim_context context)
{
    return context->warn_dest;
}

heim_log_facility *
heim_get_debug_dest(heim_context context)
{
    return context->debug_dest;
}

heim_error_code
heim_set_log_dest(heim_context context, heim_log_facility *fac)
{
    context->log_dest = heim_log_ref(fac);
    return 0;
}

heim_error_code
heim_set_warn_dest(heim_context context, heim_log_facility *fac)
{
    context->warn_dest = fac;
    return 0;
}

heim_error_code
heim_set_debug_dest(heim_context context, heim_log_facility *fac)
{
    context->debug_dest = fac;
    return 0;
}

#ifndef PATH_SEP
# define PATH_SEP ":"
#endif

static heim_error_code
add_file(char ***pfilenames, int *len, char *file)
{
    char **pp = *pfilenames;
    int i;

    for(i = 0; i < *len; i++) {
        if(strcmp(pp[i], file) == 0) {
            free(file);
            return 0;
        }
    }

    pp = realloc(*pfilenames, (*len + 2) * sizeof(*pp));
    if (pp == NULL) {
        free(file);
        return ENOMEM;
    }

    pp[*len] = file;
    pp[*len + 1] = NULL;
    *pfilenames = pp;
    *len += 1;
    return 0;
}

#ifdef WIN32
static char *
get_default_config_config_files_from_registry(const char *envvar)
{
    static const char *KeyName = "Software\\Heimdal"; /* XXX #define this */
    const char *ValueName;
    char *config_file = NULL;
    LONG rcode;
    HKEY key;

    if (stricmp(envvar, "KRB5_CONFIG") == 0)
	ValueName = "config";
    else
	ValueName = envvar;

    rcode = RegOpenKeyEx(HKEY_CURRENT_USER, KeyName, 0, KEY_READ, &key);
    if (rcode == ERROR_SUCCESS) {
	config_file = heim_parse_reg_value_as_multi_string(NULL, key, ValueName,
                                                           REG_NONE, 0, PATH_SEP);
        RegCloseKey(key);
    }

    if (config_file)
        return config_file;

    rcode = RegOpenKeyEx(HKEY_LOCAL_MACHINE, KeyName, 0, KEY_READ, &key);
    if (rcode == ERROR_SUCCESS) {
	config_file = heim_parse_reg_value_as_multi_string(NULL, key, ValueName,
                                                           REG_NONE, 0, PATH_SEP);
        RegCloseKey(key);
    }

    return config_file;
}
#endif

heim_error_code
heim_prepend_config_files(const char *filelist,
                          char **pq,
                          char ***ret_pp)
{
    heim_error_code ret;
    const char *p, *q;
    char **pp;
    int len;
    char *fn;

    pp = NULL;

    len = 0;
    p = filelist;
    while(1) {
        ssize_t l;
        q = p;
        l = strsep_copy(&q, PATH_SEP, NULL, 0);
        if(l == -1)
            break;
        fn = malloc(l + 1);
        if(fn == NULL) {
            heim_free_config_files(pp);
            return ENOMEM;
        }
        (void) strsep_copy(&p, PATH_SEP, fn, l + 1);
        ret = add_file(&pp, &len, fn);
        if (ret) {
            heim_free_config_files(pp);
            return ret;
        }
    }

    if (pq != NULL) {
        int i;

        for (i = 0; pq[i] != NULL; i++) {
            fn = strdup(pq[i]);
            if (fn == NULL) {
                heim_free_config_files(pp);
                return ENOMEM;
            }
            ret = add_file(&pp, &len, fn);
            if (ret) {
                heim_free_config_files(pp);
                return ret;
            }
        }
    }

    *ret_pp = pp;
    return 0;
}

heim_error_code
heim_prepend_config_files_default(const char *prepend,
                                  const char *def,
                                  const char *envvar,
                                  char ***pfilenames)
{
    heim_error_code ret;
    char **defpp, **pp = NULL;

    ret = heim_get_default_config_files(def, envvar, &defpp);
    if (ret)
        return ret;

    ret = heim_prepend_config_files(prepend, defpp, &pp);
    heim_free_config_files(defpp);
    if (ret) {
        return ret;
    }
    *pfilenames = pp;
    return 0;
}

heim_error_code
heim_get_default_config_files(const char *def,
                              const char *envvar,
                              char ***pfilenames)
{
    const char *files = NULL;

    files = secure_getenv(envvar);

#ifdef _WIN32
    if (files == NULL) {
        char * reg_files;
	reg_files = get_default_config_config_files_from_registry(envvar);
        if (reg_files != NULL) {
            heim_error_code code;

            code = heim_prepend_config_files(reg_files, NULL, pfilenames);
            free(reg_files);

            return code;
        }
    }
#endif

    if (files == NULL)
        files = def;
    return heim_prepend_config_files(files, NULL, pfilenames);
}

#ifdef _WIN32
#define REGPATH_KERBEROS "SOFTWARE\\Kerberos"
#define REGPATH_HEIMDAL  "SOFTWARE\\Heimdal"
#endif

heim_error_code
heim_set_config_files(heim_context context, char **filenames,
                      heim_config_binding **res)
{
    heim_error_code ret = 0;

    *res = NULL;
    while (filenames != NULL && *filenames != NULL && **filenames != '\0') {
        ret = heim_config_parse_file_multi(context, *filenames, res);
        if (ret != 0 && ret != ENOENT && ret != EACCES && ret != EPERM
            && ret != HEIM_ERR_CONFIG_BADFORMAT) {
            heim_config_file_free(context, *res);
            *res = NULL;
            return ret;
        }
        filenames++;
    }

#ifdef _WIN32
    /*
     * We always ignored errors from loading from the registry, so we still do.
     */
    heim_load_config_from_registry(context, REGPATH_KERBEROS,
                                   REGPATH_HEIMDAL, res);

#endif
    return 0;
}

void
heim_free_config_files(char **filenames)
{
    char **p;

    for (p = filenames; p && *p != NULL; p++)
        free(*p);
    free(filenames);
}