/*
 * 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.
 *
 * Copyright 2021 OmniOS Community Edition (OmniOSce) Association.
 */

/*
 * alias.c is a C version of the alias.sh wrapper (which links ksh
 * builtins to commands in /usr/bin/, e.g. calling this wrapper as
 * /usr/bin/alias will call the ksh "alias" builtin, running it as
 * /usr/bin/cut will call the ksh "cut" builtin etc.
 */

#include <defs.h>
#include <shell.h>
#include <nval.h>
#include <cmdext.h>
#include <stdio.h>
#include <setjmp.h>

#undef calloc
#undef free

typedef struct {
	const char *name;
	int (* func)(int, char **, Shbltin_t *);
} bfastpathrec;

/*
 * We've disabled the "fastpath" codepath for some commands below
 * because it causes a paradoxon for large input files (as used by
 * ON PerfPIT for testing). For /usr/bin/rev (where the issue was
 * first discovered) it looks like this:
 * - for small files like /etc/profile the fastpath is faster in a loop
 *   with 1000 iterations (8 seconds with fastpath, 14 seconds without
 *   fastpath)
 * - for large files (/usr/pub/UTF-8 replicated until the test file
 *   reaches 24884706 bytes) the benchmark reverses: The fastpath now
 *   needs 40 seconds and without fastpath it needs 30 seconds (for 100
 *   iterations).
 */
#if 0
#define	ENABLE_PERFORMANCE_PARADOXON 1
#endif

/*
 * List of libcmd builtins which do not require a |Shell_t| context.
 * This list was automatically generated from <ast/cmdext.h>
 */
static const
bfastpathrec fastpath_builtins[] =
{
	/* This list must be alphabetically sorted for |strcmp()| usage */
	{ "basename",	b_basename	},
	{ "cat",	b_cat		},
	{ "chgrp",	b_chgrp		},
	{ "chmod",	b_chmod		},
	{ "chown",	b_chown		},
#ifdef ENABLE_PERFORMANCE_PARADOXON
	{ "cksum",	b_cksum		},
#endif /* ENABLE_PERFORMANCE_PARADOXON */
	{ "cmp",	b_cmp		},
	{ "comm",	b_comm		},
	{ "cp",		b_cp		},
	{ "cut",	b_cut		},
	{ "date",	b_date		},
	{ "dirname",	b_dirname	},
	{ "expr",	b_expr		},
	{ "fds",	b_fds		},
	{ "fmt",	b_fmt		},
	{ "fold",	b_fold		},
	{ "getconf",	b_getconf	},
	{ "head",	b_head		},
	{ "id",		b_id		},
	{ "join",	b_join		},
	{ "ln",		b_ln		},
	{ "md5sum",	b_md5sum	},
	{ "mkdir",	b_mkdir		},
	{ "mkfifo",	b_mkfifo	},
	{ "mktemp",	b_mktemp	},
	{ "mv",		b_mv		},
	{ "paste",	b_paste		},
	{ "pathchk",	b_pathchk	},
	{ "pids",	b_pids		},
#ifdef ENABLE_PERFORMANCE_PARADOXON
	{ "rev",	b_rev		},
#endif /* ENABLE_PERFORMANCE_PARADOXON */
	{ "rm",		b_rm		},
	{ "rmdir",	b_rmdir		},
	{ "stty",	b_stty		},
#ifdef ENABLE_PERFORMANCE_PARADOXON
	{ "sum",	b_sum		},
#endif /* ENABLE_PERFORMANCE_PARADOXON */
	{ "sync",	b_sync		},
	{ "tail",	b_tail		},
	{ "tee",	b_tee		},
	{ "tty",	b_tty		},
	{ "uname",	b_uname		},
	{ "uniq",	b_uniq		},
	{ "vmstate",	b_vmstate	},
	{ "wc",		b_wc		},
	{ NULL,		NULL		}
};

static inline const bfastpathrec *
find_bfastpathrec(const char *name)
{
	unsigned int i;
	signed int cmpres;
	for (i = 0; fastpath_builtins[i].name != NULL; i++) {
		cmpres = strcmp(fastpath_builtins[i].name, name);
		if (cmpres == 0)
			return (&fastpath_builtins[i]);
		else if (cmpres > 0)
			return (NULL);
	}
	return (NULL);
}

static inline int
fastpath_builtin_main(const bfastpathrec *brec, int argc, char *argv[])
{
	setlocale(LC_ALL, ""); /* calls |_ast_setlocale()| */

	return ((*brec->func)(argc, argv, NULL));
}


/* Builtin script, originally derived from alias.sh */
static const char *script = "\n"
/* Get name of builtin */
"typeset cmd=\"${0##*/}\"\n"
/*
 * If the requested command is not an alias, load it explicitly
 * to make sure it is not bound to a path (those built-ins which
 * are mapped via shell aliases point to commands which are
 * "special shell built-ins" which cannot be bound to a specific
 * PATH element) - otherwise we may execute the wrong command
 * if an executable with the same name sits in a PATH element
 * before /usr/bin (e.g. /usr/xpg4/bin/ls would be executed
 * before /usr/bin/ls if the path was something like
 * PATH=/usr/xpg4/bin:/usr/bin).
 */
"if [[ \"${cmd}\" != ~(Elr)(alias|unalias|command) ]] && "
	"! alias \"${cmd}\" >/dev/null 2>&1 ; then\n"
	"PATH='' builtin \"${cmd}\"\n"
"fi\n"
/* command is a keyword and needs to be handled separately */
"if [[ \"${cmd}\" == \"command\" ]] ; then\n"
	"command \"$@\"\n"
"else\n"
	"\"${cmd}\" \"$@\"\n"
"fi\n"
"exitval=$?";

static int
script_builtin_main(int argc, char **argv)
{
	int i;
	Shell_t *shp;
	Namval_t *np;
	int exitval;
	char **xargv;

	/*
	 * Create copy of |argv| array shifted by one position to
	 * emulate $ /usr/bin/sh <scriptname> <args1> <arg2> ... #.
	 * First position is set to "/usr/bin/sh" since other
	 * values may trigger special shell modes (e.g. *rsh* will
	 * trigger "restricted" shell mode etc.).
	 */
	xargv = calloc(argc + 2, sizeof (char *));
	if (xargv == NULL)
		return (1);
	xargv[0] = "/usr/bin/sh";
	for (i = 0; i < argc; i++)
		xargv[i + 1] = argv[i];
	xargv[i + 1] = NULL;

	shp = sh_init(argc + 1, xargv, 0);
	if (!shp)
		error(ERROR_exit(1), "shell initialisation failed.");
	if (setjmp(*shp->jmplist) == 0)
		(void) sh_trap(script, 0);

	np = nv_open("exitval", shp->var_tree, 0);
	if (!np)
		error(ERROR_exit(1), "variable %s not found.", "exitval");
	exitval = (int)nv_getnum(np);
	nv_close(np);

	free(xargv);

	return (exitval);
}

int
main(int argc, char **argv)
{
	const char *progname;
	const bfastpathrec *brec;
	char execnamebuff[PATH_MAX + 1];

	/* Get program name */
	if (pathprog(argv[0], execnamebuff, sizeof (execnamebuff)) <= 0)
		error(ERROR_exit(1), "could not determinate exec name.");

	progname = (const char *)strrchr(execnamebuff, '/');

	if (progname != NULL)
		progname++;
	else
		progname = execnamebuff;

	/* Execute command... */
	if (brec = find_bfastpathrec(progname)) {
		/* ... either via a fast path (calling the code directly) ... */
		return (fastpath_builtin_main(brec, argc, argv));
	} else {
		/* ... or from within a full shell. */
		return (script_builtin_main(argc, argv));
	}
}