/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * This file contains functions for manipulating the GRUB menu.
 */
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/mount.h>
#include <stdarg.h>
#include <assert.h>
#include <ctype.h>

#include "libgrub_impl.h"

static const grub_cmd_desc_t grub_cmd_descs[GRBM_CMD_NUM] = {
#define	menu_cmd(cmd, num, flag, parsef)	{cmd, num, flag},
#include "libgrub_cmd.def"
};

static void
append_line(grub_menu_t *mp, grub_line_t *lp)
{
	if (mp->gm_start == NULL) {
		mp->gm_start = lp;
	} else {
		mp->gm_end->gl_next = lp;
		lp->gl_prev = mp->gm_end;
	}
	mp->gm_end = lp;
	lp->gl_line_num = ++mp->gm_line_num;
	lp->gl_entry_num = GRUB_ENTRY_DEFAULT;
}

static void
process_line(grub_menu_t *mp)
{
	int	n;
	grub_line_t	*lp;

	lp = mp->gm_end;
	n = sizeof (grub_cmd_descs) / sizeof (grub_cmd_descs[0]);

	/* search through the table of known commands */
	while (n-- != 0 && strcmp(lp->gl_cmd, grub_cmd_descs[n].gcd_cmd) != 0)
		;

	/* unknown command */
	if (n < 0)
		return;

	/* we found command, fill lp fields */
	lp->gl_flags = grub_cmd_descs[n].gcd_flags;
	lp->gl_cmdtp = grub_cmd_descs[n].gcd_num;
}


static void
check_entry(grub_entry_t *ent)
{
	int i;
	uint_t emask;
	grub_line_t *lp;
	const grub_line_t * const lend = ent->ge_end->gl_next;

	emask = 0;
	for (i = 0, lp = ent->ge_start; lend != lp; lp = lp->gl_next, ++i) {
		lp->gl_entry_num = ent->ge_entry_num;
		if (lp->gl_flags == GRUB_LINE_INVALID ||
		    lp->gl_flags == GRUB_LINE_GLOBAL) {
			emask |= 1 << i;
			lp->gl_flags = GRUB_LINE_INVALID;
		}
	}

	if ((ent->ge_emask = emask) == 0)
		ent->ge_flags |= GRBM_VALID_FLAG;
}

static int
add_entry(grub_menu_t *mp, grub_line_t *start, grub_line_t *end)
{
	grub_entry_t *ent;

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

	ent->ge_start = start;
	ent->ge_end = end;

	if (mp->gm_ent_end == NULL) {
		mp->gm_ent_start = ent;
	} else {
		mp->gm_ent_end->ge_next = ent;
		ent->ge_prev = mp->gm_ent_end;
	}
	mp->gm_ent_end = ent;
	ent->ge_entry_num = mp->gm_entry_num++;
	ent->ge_menu = mp;
	return (0);
}

static void
default_entry(grub_menu_t *mp)
{
	uint_t defent;
	grub_line_t *lp;
	grub_entry_t *ent;

	defent = 0;
	lp = mp->gm_curdefault;

	if (lp != NULL && lp->gl_flags == GRUB_LINE_GLOBAL &&
	    lp->gl_cmdtp == GRBM_DEFAULT_CMD) {
		defent  = strtoul(lp->gl_arg, NULL, 0);
		if (defent >= mp->gm_entry_num)
			defent = 0;
	}

	for (ent = mp->gm_ent_start; ent != NULL && defent != ent->ge_entry_num;
	    ent = ent->ge_next)
		;

	mp->gm_ent_default = ent;
}

static void
free_line(grub_line_t *lp)
{
	if (lp == NULL)
		return;

	free(lp->gl_cmd);
	free(lp->gl_sep);
	free(lp->gl_arg);
	free(lp->gl_line);
	free(lp);
}

static void
free_linelist(grub_line_t *line)
{
	grub_line_t *lp;

	if (line == NULL)
		return;

	while (line) {
		lp = line;
		line = lp->gl_next;
		free_line(lp);
	}
}

static void
free_entries(grub_menu_t *mp)
{
	grub_entry_t *ent, *tmp;

	if (mp == NULL)
		return;

	for (ent = mp->gm_ent_start; (tmp = ent) != NULL;
	    ent = tmp->ge_next, free(tmp))
		;

	mp->gm_ent_start = NULL;
	mp->gm_ent_end = NULL;
}

static int
grub_menu_append_line(grub_menu_t *mp, const char *line)
{
	int rc;
	size_t n;
	grub_line_t *lp;

	if (line == NULL)
		return (EINVAL);

	rc = 0;
	lp = NULL;
	if ((lp = calloc(1, sizeof (*lp))) == NULL ||
	    (lp->gl_line = strdup(line)) == NULL) {
		free(lp);
		return (errno);
	}

	/* skip initial white space */
	line += strspn(line, " \t");

	/* process comment line */
	if (line[0] == '#') {
		if ((lp->gl_cmd =
		    strdup(grub_cmd_descs[GRBM_COMMENT_CMD].gcd_cmd)) == NULL ||
		    (lp->gl_sep =
		    strdup(grub_cmd_descs[GRBM_EMPTY_CMD].gcd_cmd)) == NULL ||
		    (lp->gl_arg = strdup(line + 1)) == NULL)
			rc = errno;
	} else {
		/* get command */
		n = strcspn(line, " \t=");
		if ((lp->gl_cmd = malloc(n + 1)) == NULL)
			rc = errno;
		else
			(void) strlcpy(lp->gl_cmd, line, n + 1);

		line += n;

		/* get separator */
		n = strspn(line, " \t=");
		if ((lp->gl_sep = malloc(n + 1)) == NULL)
			rc = errno;
		else
			(void) strlcpy(lp->gl_sep, line, n + 1);

		line += n;

		/* get arguments */
		if ((lp->gl_arg = strdup(line)) == NULL)
			rc = errno;
	}

	if (rc != 0) {
		free_line(lp);
		return (rc);
	}

	append_line(mp, lp);
	process_line(mp);
	return (0);
}

static int
grub_menu_process(grub_menu_t *mp)
{
	int ret;
	grub_entry_t *ent;
	grub_line_t *line, *start;

	/* Free remaininig entries, if any */
	free_entries(mp);

	/*
	 * Walk through lines, till first 'title' command is encountered.
	 * Initialize globals.
	 */
	for (line = mp->gm_start; line != NULL; line = line->gl_next) {
		if (line->gl_flags == GRUB_LINE_GLOBAL &&
		    line->gl_cmdtp == GRBM_DEFAULT_CMD)
			mp->gm_curdefault = line;
		else if (line->gl_cmdtp == GRBM_TITLE_CMD)
			break;
	}

	/*
	 * Walk through remaining lines and recreate menu entries.
	 */
	for (start = NULL; line != NULL; line = line->gl_next) {
		if (line->gl_cmdtp == GRBM_TITLE_CMD) {
			/* is first entry */
			if (start != NULL &&
			    (ret = add_entry(mp, start, line->gl_prev)) != 0)
				return (ret);
			start = line;
		}
	}

	/* Add last entry */
	if (start != NULL && (ret = add_entry(mp, start, mp->gm_end)) != 0)
		return (ret);

	for (ent = mp->gm_ent_start; NULL != ent; ent = ent->ge_next)
		check_entry(ent);

	default_entry(mp);

	return (0);
}

static int
grub_fs_init(grub_fs_t *fs)
{
	assert(fs);
	if ((fs->gf_lzfh = libzfs_init()) == NULL ||
	    (fs->gf_diroot = di_init("/", DINFOCPYALL | DINFOPATH))
	    == DI_NODE_NIL ||
	    (fs->gf_dvlh = di_devlink_init(NULL, 0)) == DI_LINK_NIL) {
		return (EG_INITFS);
	}
	return (0);
}

static void
grub_fs_fini(grub_fs_t *fs)
{
	if (fs == NULL)
		return;

	if (fs->gf_dvlh != DI_LINK_NIL)
		(void) di_devlink_fini(&fs->gf_dvlh);
	if (fs->gf_diroot != DI_NODE_NIL)
		di_fini(fs->gf_diroot);
	if (fs->gf_lzfh != NULL)
		libzfs_fini(fs->gf_lzfh);
	(void) memset(fs, 0, sizeof (*fs));
}

/*
 * Reads and parses GRUB menu file into a grub_menu_t data structure.
 * If grub_menu_path file path is NULL, will use 'currently active'
 * GRUB menu file.
 *
 * Memory for the menu data structure is allocated within the routine.
 * Caller must call grub_menu_fini() to release memory after calling
 * grub_menu_init().
 */
int
grub_menu_init(const char *path, grub_menu_t **menup)
{
	FILE *fp;
	char *cp;
	grub_menu_t *mp;
	int len, n, ret;
	char buf[GRBM_MAXLINE];

	if (menup == NULL)
		return (EINVAL);

	/*
	 * Allocate space, perform initialization
	 */
	if ((mp = calloc(1, sizeof (*mp))) == NULL) {
		*menup = mp;
		return (errno);
	}

	if ((ret = grub_fs_init(&mp->gm_fs)) != 0 ||
	    (ret = grub_current_root(&mp->gm_fs, &mp->gm_root)) != 0)
		goto err_out1;

	if (path == NULL) {
		/*
		 * Use default grub-menu.
		 * If top dataset is not mounted, mount it now.
		 */
		if (mp->gm_root.gr_fs[GRBM_FS_TOP].gfs_mountp[0] == 0) {
			if ((ret = grub_fsd_mount_tmp(mp->gm_root.gr_fs +
			    GRBM_FS_TOP, mp->gm_root.gr_fstyp)) != 0)
				goto err_out1;
		}
		(void) snprintf(mp->gm_path, sizeof (mp->gm_path),
		    "%s/%s", mp->gm_root.gr_fs[GRBM_FS_TOP].gfs_mountp,
		    GRUB_MENU);
	} else {
		(void) strlcpy(mp->gm_path, path, sizeof (mp->gm_path));
	}

	if ((fp = fopen(mp->gm_path, "r")) == NULL) {
		ret = errno;
		goto err_out1;
	}

	cp = buf;
	len = sizeof (buf);

	while (fgets(cp, len, fp) != NULL) {

		if (IS_LINE2BIG(cp, len, n)) {
			ret = E2BIG;
			break;
		}

		/* remove white space at the end of line */
		for (; n != 0 && isspace(cp[n - 1]); --n)
			;
		cp[n] = '\0';

		if (n > 0 && cp[n - 1] == '\\') {
			len -= n - 1;
			assert(len >= 2);
			cp += n - 1;
			continue;
		}
		if ((ret = grub_menu_append_line(mp, buf)) != 0)
			break;

		cp = buf;
		len = sizeof (buf);
	}

	if (fclose(fp) == EOF)
		ret = errno;
	else if (ret == 0)
		ret = grub_menu_process(mp);

err_out1:
	grub_fsd_umount_tmp(mp->gm_root.gr_fs + GRBM_FS_TOP);
	if (0 != ret) {
		grub_menu_fini(mp);
		mp = NULL;
	}
	*menup = mp;
	return (ret);
}

void
grub_menu_fini(grub_menu_t *mp)
{
	if (mp == NULL)
		return;

	grub_fs_fini(&mp->gm_fs);
	free_entries(mp);
	free_linelist(mp->gm_start);
	free(mp);
}

grub_line_t *
grub_menu_next_line(const grub_menu_t *mp, const grub_line_t *lp)
{
	assert(mp);
	if (lp == NULL)
		return (mp->gm_start);
	else
		return (lp->gl_next);
}

grub_line_t *
grub_menu_prev_line(const grub_menu_t *mp, const grub_line_t *lp)
{
	assert(mp);
	if (lp == NULL)
		return (mp->gm_end);
	else
		return (lp->gl_prev);
}

grub_line_t *
grub_menu_get_line(const grub_menu_t *mp, int num)
{
	grub_line_t *lp;

	assert(mp);
	if (num > mp->gm_line_num)
		return (NULL);
	for (lp = mp->gm_start; lp != NULL && num != lp->gl_line_num;
	    lp = lp->gl_next)
		;
	return (lp);
}

size_t
grub_menu_get_cmdline(const grub_menu_t *mp, int num, char *cmdl, size_t size)
{
	grub_entry_t *ent;

	assert(mp);
	if ((ent = grub_menu_get_entry(mp, num)) == NULL)
		return (size_t)(-1);

	return (grub_entry_get_cmdline(ent, cmdl, size));
}

grub_entry_t *
grub_menu_next_entry(const grub_menu_t *mp, const grub_entry_t *ent)
{
	assert(mp);
	if (ent == NULL) {
		return (mp->gm_ent_start);
	} else {
		assert(mp == ent->ge_menu);
		return (ent->ge_next);
	}
}

grub_entry_t *
grub_menu_prev_entry(const grub_menu_t *mp, const grub_entry_t *ent)
{
	assert(mp);
	if (ent == NULL) {
		return (mp->gm_ent_end);
	} else {
		assert(mp == ent->ge_menu);
		return (ent->ge_prev);
	}
}

grub_entry_t *
grub_menu_get_entry(const grub_menu_t *mp, int num)
{
	grub_entry_t *ent;

	assert(mp);
	if (num == GRUB_ENTRY_DEFAULT) {
		ent = mp->gm_ent_default;
	} else if (num >= mp->gm_entry_num) {
		ent = NULL;
	} else {
		for (ent = mp->gm_ent_start;
		    ent != NULL && num != ent->ge_entry_num;
		    ent = ent->ge_next)
			;
	}
	return (ent);
}