/*
 * Copyright (c) 2011-2015 Juan Romero Pardines.
 * Copyright (c) 2014 Enno Boland.
 * Copyright (c) 2019 Duncan Overbruck <mail@duncano.de>.
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 <sys/types.h>
#ifdef __FreeBSD__
#define _WITH_GETLINE   /* getline() */
#endif
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <glob.h>
#include <libgen.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>

#include "xbps_api_impl.h"

/**
 * @file lib/conf.c
 * @brief Configuration parsing
 * @defgroup conf Configuration parsing
 *
 * Functions for parsing xbps configuration files.
 */

static int
store_virtualpkg(struct xbps_handle *xhp, const char *path, size_t line, char *val)
{
	char *p;
	/*
	 * Parse strings delimited by ':' i.e
	 * 	<left>:<right>
	 */
	p = strchr(val, ':');
	if (p == NULL || p[1] == '\0') {
		xbps_dbg_printf("%s: ignoring invalid "
		    "virtualpkg option at line %zu\n", path, line);
		return 0;
	}
	*p++ = '\0';

	if (!xbps_dictionary_set_cstring(xhp->vpkgd, val, p))
		return -errno;
	if (!xbps_dictionary_set_cstring(xhp->vpkgd_conf, val, p))
		return -errno;
	xbps_dbg_printf("%s: added virtualpkg %s for %s\n", path, val, p);
	return 1;
}

static void
store_preserved_file(struct xbps_handle *xhp, const char *file)
{
	glob_t globbuf;
	char *p = NULL, *rfile = NULL;
	size_t len;
	int rv = 0;

	if (xhp->preserved_files == NULL) {
		xhp->preserved_files = xbps_array_create();
		assert(xhp->preserved_files);
	}

	rfile = xbps_xasprintf("%s%s", xhp->rootdir, file);

	rv = glob(rfile, 0, NULL, &globbuf);
	if (rv == GLOB_NOMATCH) {
		if (xbps_match_string_in_array(xhp->preserved_files, file))
			goto out;
		xbps_array_add_cstring(xhp->preserved_files, file);
		xbps_dbg_printf("Added preserved file: %s\n", file);
		goto out;
	} else if (rv != 0) {
		goto out;
	}
	for (size_t i = 0; i < globbuf.gl_pathc; i++) {
		if (xbps_match_string_in_array(xhp->preserved_files, globbuf.gl_pathv[i]))
			continue;

		len = strlen(globbuf.gl_pathv[i]) - strlen(xhp->rootdir) + 1;
		p = malloc(len);
		assert(p);
		xbps_strlcpy(p, globbuf.gl_pathv[i] + strlen(xhp->rootdir), len);
		xbps_array_add_cstring(xhp->preserved_files, p);
		xbps_dbg_printf("Added preserved file: %s (expanded from %s)\n", p, file);
		free(p);
	}
out:
	globfree(&globbuf);
	free(rfile);
}

static bool
store_repo(struct xbps_handle *xhp, const char *repo)
{
	if (xhp->flags & XBPS_FLAG_IGNORE_CONF_REPOS)
		return false;

	return xbps_repo_store(xhp, repo);
}

static void
store_ignored_pkg(struct xbps_handle *xhp, const char *pkgname)
{
	if (xhp->ignored_pkgs == NULL) {
		xhp->ignored_pkgs = xbps_array_create();
		assert(xhp->ignored_pkgs);
	}
	xbps_array_add_cstring(xhp->ignored_pkgs, pkgname);
	xbps_dbg_printf("Added ignored package: %s\n", pkgname);
}

static void
store_noextract(struct xbps_handle *xhp, const char *value)
{
	if (*value == '\0')
		return;
	if (xhp->noextract == NULL) {
		xhp->noextract = xbps_array_create();
		assert(xhp->noextract);
	}
	xbps_array_add_cstring(xhp->noextract, value);
	xbps_dbg_printf("Added noextract pattern: %s\n", value);
}

enum {
	KEY_ERROR = 0,
	KEY_ARCHITECTURE,
	KEY_BESTMATCHING,
	KEY_CACHEDIR,
	KEY_IGNOREPKG,
	KEY_INCLUDE,
	KEY_NOEXTRACT,
	KEY_PRESERVE,
	KEY_REPOSITORY,
	KEY_ROOTDIR,
	KEY_SYSLOG,
	KEY_VIRTUALPKG,
	KEY_KEEPCONF,
};

static const struct key {
	const char *str;
	size_t len;
	int key;
} keys[] = {
	{ "architecture", 12, KEY_ARCHITECTURE },
	{ "bestmatching", 12, KEY_BESTMATCHING },
	{ "cachedir",      8, KEY_CACHEDIR },
	{ "ignorepkg",     9, KEY_IGNOREPKG },
	{ "include",       7, KEY_INCLUDE },
	{ "keepconf",      8, KEY_KEEPCONF },
	{ "noextract",     9, KEY_NOEXTRACT },
	{ "preserve",      8, KEY_PRESERVE },
	{ "repository",   10, KEY_REPOSITORY },
	{ "rootdir",       7, KEY_ROOTDIR },
	{ "syslog",        6, KEY_SYSLOG },
	{ "virtualpkg",   10, KEY_VIRTUALPKG },
};

static int
cmpkey(const void *a, const void *b)
{
	const struct key *ka = a;
	const struct key *kb = b;
	return strncmp(ka->str, kb->str, ka->len);
}

static int
parse_option(char *line, size_t linelen, char **valp, size_t *vallen)
{
	size_t len;
	char *p;
	struct key needle, *result;

	p = strpbrk(line, " \t=");
	if (p == NULL)
		return KEY_ERROR;
	needle.str = line;
	needle.len = p-line;

	while (*p && isblank((unsigned char)*p))
		p++;
	if (*p != '=')
		return KEY_ERROR;

	result = bsearch(&needle, keys, __arraycount(keys), sizeof(struct key), cmpkey);
	if (result == NULL)
		return KEY_ERROR;

	p++;
	while (isblank((unsigned char)*p))
		p++;

	len = linelen-(p-line);
	/* eat trailing spaces, len - 1 here because \0 should be set -after- the first non-space
	 * if len points at the actual current character, we can never make it an empty string
	 * because than end needs to be set to -1, but len is a unsigned type thus would result in underflow */
	while (len > 0 && isblank((unsigned char)p[len-1]))
		len--;

	p[len] = '\0';
	*valp = p;
	*vallen = len;

	return result->key;
}

static int parse_file(struct xbps_handle *, const char *, bool);

static int
parse_files_glob(struct xbps_handle *xhp, xbps_dictionary_t seen,
    const char *cwd, const char *pat, bool nested)
{
	char tmppath[PATH_MAX];
	glob_t globbuf;
	int rs, rv = 0, rv2;

	rs = snprintf(tmppath, PATH_MAX, "%s/%s",
	    pat[0] == '/' ? xhp->rootdir : cwd, pat);
	if (rs < 0 || rs >= PATH_MAX)
		return ENOMEM;

	switch (glob(tmppath, 0, NULL, &globbuf)) {
	case 0: break;
	case GLOB_NOSPACE: return ENOMEM;
	case GLOB_NOMATCH: return 0;
	default: return 0;
	}
	for (size_t i = 0; i < globbuf.gl_pathc; i++) {
		if (seen != NULL) {
			const char *fname;
			bool mask = false;
			fname = basename(globbuf.gl_pathv[i]);
			if (xbps_dictionary_get_bool(seen, fname, &mask) && mask)
				continue;
			xbps_dictionary_set_bool(seen, fname, true);
		}
		if ((rv2 = parse_file(xhp, globbuf.gl_pathv[i], nested)) != 0)
			rv = rv2;
	}
	globfree(&globbuf);

	return rv;
}

static int
parse_file(struct xbps_handle *xhp, const char *path, bool nested)
{
	FILE *fp;
	size_t len, nlines = 0;
	ssize_t rd;
	char *line = NULL;
	int rv = 0;
	int size, rs;
	char *dir;

	if ((fp = fopen(path, "r")) == NULL) {
		rv = errno;
		xbps_error_printf("cannot read configuration file %s: %s\n", path, strerror(rv));
		return rv;
	}

	xbps_dbg_printf("Parsing configuration file: %s\n", path);

	while ((rd = getline(&line, &len, fp)) != -1) {
		char *val = NULL;
		size_t vallen;

		if (line[rd-1] == '\n') {
			line[rd-1] = '\0';
			rd--;
		}

		nlines++;

		/* eat blanks */
		while (isblank((unsigned char)*line))
			line++;
		/* ignore comments or empty lines */
		if (line[0] == '#' || line[0] == '\0')
			continue;

		switch (parse_option(line, rd, &val, &vallen)) {
		case KEY_ERROR:
			xbps_dbg_printf("%s: ignoring invalid option at "
			    "line %zu\n", path, nlines);
			continue;
		case KEY_ROOTDIR:
			size = sizeof xhp->rootdir;
			rs = snprintf(xhp->rootdir, size, "%s", val);
			if (rs < 0 || rs >= size) {
				rv = ENOMEM;
				break;
			}
			xbps_dbg_printf("%s: rootdir set to %s\n", path, val);
			break;
		case KEY_CACHEDIR:
			size = sizeof xhp->cachedir;
			rs = snprintf(xhp->cachedir, size, "%s", val);
			if (rs < 0 || rs >= size) {
				rv = ENOMEM;
				break;
			}
			xbps_dbg_printf("%s: cachedir set to %s\n", path, val);
			break;
		case KEY_ARCHITECTURE:
			size = sizeof xhp->native_arch;
			rs = snprintf(xhp->native_arch, size, "%s", val);
			if (rs < 0 || rs >= size) {
				rv = ENOMEM;
				break;
			}
			xbps_dbg_printf("%s: native architecture set to %s\n", path,
			    val);
			break;
		case KEY_SYSLOG:
			if (strcasecmp(val, "true") == 0) {
				xhp->flags &= ~XBPS_FLAG_DISABLE_SYSLOG;
				xbps_dbg_printf("%s: syslog enabled\n", path);
			} else {
				xhp->flags |= XBPS_FLAG_DISABLE_SYSLOG;
				xbps_dbg_printf("%s: syslog disabled\n", path);
			}
			break;
		case KEY_REPOSITORY:
			if (store_repo(xhp, val))
				xbps_dbg_printf("%s: added repository %s\n", path, val);
			break;
		case KEY_VIRTUALPKG:
			rv = store_virtualpkg(xhp, path, nlines, val);
			if (rv < 0) {
				rv = -rv;
				break;
			}
			rv = 0;
			break;
		case KEY_PRESERVE:
			store_preserved_file(xhp, val);
			break;
		case KEY_KEEPCONF:
			if (strcasecmp(val, "true") == 0) {
				xhp->flags |= XBPS_FLAG_KEEP_CONFIG;
				xbps_dbg_printf("%s: config preservation enabled\n", path);
			} else {
				xhp->flags &= ~XBPS_FLAG_KEEP_CONFIG;
				xbps_dbg_printf("%s: config preservation disabled\n", path);
			}
			break;
		case KEY_BESTMATCHING:
			if (strcasecmp(val, "true") == 0) {
				xhp->flags |= XBPS_FLAG_BESTMATCH;
				xbps_dbg_printf("%s: pkg best matching enabled\n", path);
			} else {
				xhp->flags &= ~XBPS_FLAG_BESTMATCH;
				xbps_dbg_printf("%s: pkg best matching disabled\n", path);
			}
			break;
		case KEY_IGNOREPKG:
			store_ignored_pkg(xhp, val);
			break;
		case KEY_NOEXTRACT:
			store_noextract(xhp, val);
			break;
		case KEY_INCLUDE:
			/* Avoid double-nested parsing, only allow it once */
			if (nested) {
				xbps_dbg_printf("%s: ignoring nested include\n", path);
				continue;
			}
			dir = strdup(path);
			rv = parse_files_glob(xhp, NULL, dirname(dir), val, true);
			free(dir);
			break;
		}
	}
	free(line);
	fclose(fp);

	return rv;
}

int HIDDEN
xbps_conf_init(struct xbps_handle *xhp)
{
	xbps_dictionary_t seen;
	int rv = 0;

	assert(xhp);
	seen = xbps_dictionary_create();
	assert(seen);

	if (*xhp->confdir) {
		xbps_dbg_printf("Processing configuration directory: %s\n", xhp->confdir);
		if ((rv = parse_files_glob(xhp, seen, xhp->confdir, "*.conf", false)))
			goto out;
	}
	if (*xhp->sysconfdir) {
		xbps_dbg_printf("Processing system configuration directory: %s\n", xhp->sysconfdir);
		if ((rv = parse_files_glob(xhp, seen, xhp->sysconfdir, "*.conf", false)))
			goto out;
	}

out:
	xbps_object_release(seen);
	return rv;
}