/*******************************************************************/

/*  slibtool: a skinny libtool implementation, written in C        */

/*  Copyright (C) 2016--2024  SysDeer Technologies, LLC            */

/*  Released under the Standard MIT License; see COPYING.SLIBTOOL. */

/*******************************************************************/

#include <stdint.h>

#include <string.h>

#include <unistd.h>

#include <stdlib.h>

#include <stdbool.h>

#include <fcntl.h>

#include <spawn.h>

#include <sys/mman.h>

#include <sys/wait.h>

#define ARGV_DRIVER

#include <slibtool/slibtool.h>

#include "slibtool_version.h"

#include "slibtool_driver_impl.h"

#include "slibtool_objlist_impl.h"

#include "slibtool_errinfo_impl.h"

#include "slibtool_lconf_impl.h"

#include "slibtool_ar_impl.h"

#include "argv/argv.h"

extern char ** environ;

/* annotation strings */

static const char cfgexplicit[] = "command-line argument";

static const char cfglconf[]    = "derived from <libtool>";

/* package info */

static const struct slbt_source_version slbt_src_version = {

	SLBT_TAG_VER_MAJOR,

	SLBT_TAG_VER_MINOR,

	SLBT_TAG_VER_PATCH,

	SLIBTOOL_GIT_VERSION

};

/* default fd context */

static const struct slbt_fd_ctx slbt_default_fdctx = {

	.fdin  = STDIN_FILENO,

	.fdout = STDOUT_FILENO,

	.fderr = STDERR_FILENO,

	.fdcwd = AT_FDCWD,

	.fddst = AT_FDCWD,

	.fdlog = (-1),

};

static const char aclr_reset [] = "\x1b[0m";

static const char aclr_bold  [] = "\x1b[1m";

static const char aclr_red   [] = "\x1b[31m";

static const char aclr_green [] = "\x1b[32m";

static const char aclr_yellow[] = "\x1b[33m";

static const char aclr_blue  [] = "\x1b[34m";

static const char aclr_cyan  [] = "\x1b[36m";

static const char aclr_white [] = "\x1b[37m";

static void slbt_output_raw_vector(int fderr, char ** argv, char ** envp, bool fcolor)

{

	char **		parg;

	char *		dot;

	const char *	color;

	(void)envp;

	if (fcolor)

		slbt_dprintf(fderr,"%s%s",aclr_bold,aclr_red);

	slbt_dprintf(fderr,"\n\n\n%s",argv[0]);

	for (parg=&argv[1]; *parg; parg++) {

		if (!fcolor)

			color = "";

		else if (*parg[0] == '-')

			color = aclr_blue;

		else if (!(dot = strrchr(*parg,'.')))

			color = aclr_green;

		else if (!(strcmp(dot,".lo")))

			color = aclr_cyan;

		else if (!(strcmp(dot,".la")))

			color = aclr_yellow;

		else

			color = aclr_white;

		slbt_dprintf(fderr," %s%s",color,*parg);

	}

	slbt_dprintf(fderr,"%s\n\n",fcolor ? aclr_reset : "");

}

slbt_hidden const char * slbt_program_name(const char * path)

{

	return argv_program_name(path);

}

slbt_hidden int slbt_optv_init(

	const struct argv_option    options[],

	const struct argv_option ** optv)

{

	return argv_optv_init(options,optv);

}

slbt_hidden void slbt_argv_scan(

	char **				argv,

	const struct argv_option **	optv,

	struct argv_ctx *		ctx,

	struct argv_meta *		meta)

{

	argv_scan(argv,optv,ctx,meta);

}

slbt_hidden struct argv_meta * slbt_argv_get(

	char **                         argv,

	const struct argv_option **     optv,

	int                             flags,

	int                             fd)

{

	return argv_get(argv,optv,flags,fd);

}

slbt_hidden void slbt_argv_free(struct argv_meta * meta)

{

	argv_free(meta);

}

slbt_hidden void slbt_argv_usage(

	int		                fd,

	const char *	                header,

	const struct	argv_option **  optv,

	const char *	                mode)

{

	argv_usage(fd,header,optv,mode);

}

slbt_hidden void slbt_argv_usage_plain(

	int		                fd,

	const char *	                header,

	const struct	argv_option **  optv,

	const char *	                mode)

{

	argv_usage_plain(fd,header,optv,mode);

}

slbt_hidden uint64_t slbt_argv_flags(uint64_t flags)

{

	uint32_t ret = 0;

	if (flags & SLBT_DRIVER_VERBOSITY_NONE)

		ret |= ARGV_VERBOSITY_NONE;

	if (flags & SLBT_DRIVER_VERBOSITY_ERRORS)

		ret |= ARGV_VERBOSITY_ERRORS;

	if (flags & SLBT_DRIVER_VERBOSITY_STATUS)

		ret |= ARGV_VERBOSITY_STATUS;

	return ret;

}

static int slbt_free_argv_buffer(

	struct slbt_split_vector * sargv,

	struct slbt_obj_list *     objlistv)

{

	struct slbt_obj_list * objlistp;

	if (sargv->dargs)

		free(sargv->dargs);

	if (sargv->dargv)

		free(sargv->dargv);

	if (sargv->targv)

		free(sargv->targv);

	if (objlistv) {

		for (objlistp=objlistv; objlistp->name; objlistp++) {

			free(objlistp->objv);

			free(objlistp->addr);

		}

		free(objlistv);

	}

	return -1;

}

slbt_hidden int slbt_driver_usage(

	int				fdout,

	const char *			program,

	const char *			arg,

	const struct argv_option **	optv,

	struct argv_meta *		meta,

	struct slbt_split_vector *	sargv,

	struct slbt_obj_list *		objlistv,

	int				noclr)

{

	char header[512];

	snprintf(header,sizeof(header),

		"Usage: %s [options] <file>...\n" "Options:\n",

		program);

	switch (noclr) {

		case 0:

			argv_usage(fdout,header,optv,arg);

			break;

		default:

			argv_usage_plain(fdout,header,optv,arg);

			break;

	}

	argv_free(meta);

	slbt_free_argv_buffer(sargv,objlistv);

	return SLBT_USAGE;

}

static struct slbt_driver_ctx_impl * slbt_driver_ctx_alloc(

	const struct slbt_fd_ctx *	fdctx,

	const struct slbt_common_ctx *	cctx,

	struct slbt_split_vector *	sargv,

	struct slbt_obj_list *		objlistv,

	char **				envp,

	size_t				ndlopen)

{

	struct slbt_driver_ctx_alloc *	ictx;

	size_t				size;

	int				elements;

	size =  sizeof(struct slbt_driver_ctx_alloc);

	if (!(ictx = calloc(1,size))) {

		slbt_free_argv_buffer(sargv,objlistv);

		return 0;

	}

	if (ndlopen) {

		if (!(ictx->ctx.dlopenv = calloc(ndlopen+1,sizeof(char *)))) {

			free(ictx);

			slbt_free_argv_buffer(sargv,objlistv);

			return 0;

		}

		ictx->ctx.ndlopen = ndlopen;

	}

	ictx->ctx.dargs = sargv->dargs;

	ictx->ctx.dargv = sargv->dargv;

	ictx->ctx.targv = sargv->targv;

	ictx->ctx.cargv = sargv->cargv;

	ictx->ctx.envp  = envp;

	memcpy(&ictx->ctx.fdctx,fdctx,sizeof(*fdctx));

	memcpy(&ictx->ctx.cctx,cctx,sizeof(*cctx));

	elements = sizeof(ictx->ctx.erribuf) / sizeof(*ictx->ctx.erribuf);

	ictx->ctx.errinfp  = &ictx->ctx.erriptr[0];

	ictx->ctx.erricap  = &ictx->ctx.erriptr[--elements];

	ictx->ctx.objlistv = objlistv;

	ictx->ctx.ctx.errv = ictx->ctx.errinfp;

	return &ictx->ctx;

}

static int slbt_lib_get_driver_ctx_fail(

	struct slbt_driver_ctx * dctx,

	struct argv_meta *       meta)

{

	if (dctx) {

		slbt_output_error_vector(dctx);

		slbt_lib_free_driver_ctx(dctx);

	} else {

		argv_free(meta);

	}

	return -1;

}

static int slbt_driver_fail_incompatible_args(

	int				fderr,

	uint64_t			drvflags,

	struct argv_meta *		meta,

	const char *			program,

	const char *			afirst,

	const char *			asecond)

{

	int fcolor;

	fcolor = (drvflags & SLBT_DRIVER_ANNOTATE_NEVER)

		? 0 : isatty(fderr);

	if (drvflags & SLBT_DRIVER_VERBOSITY_ERRORS){

		if (fcolor)

			slbt_dprintf(

				fderr,"%s%s",

				aclr_bold,aclr_red);

		slbt_dprintf(fderr,

			"%s: error: incompatible arguments: "

			"at the most one of %s and %s "

			"may be used.\n",

			program,afirst,asecond);

		if (fcolor)

			slbt_dprintf(

				fderr,"%s",

				aclr_reset);

	}

	return slbt_lib_get_driver_ctx_fail(0,meta);

}

static int slbt_driver_parse_tool_argv(const char * tool, char *** tool_argv)

{

	int             argc;

	char **         argv;

	const char *    ch;

	const char *    mark;

	if (!(ch = tool))

		return 0;

	argc = 1;

	for (; *ch == ' '; )

		ch++;

	for (; *ch; ) {

		if (*ch++ == ' ') {

			argc++;

			for (; (*ch == ' '); )

				ch++;

		}

	}

	if (argc == 1)

		return 0;

	if (!(*tool_argv = calloc(++argc,sizeof(char *))))

		return -1;

	for (ch=tool; (*ch == ' '); ch++)

		(void)0;

	argv = *tool_argv;

	mark = ch;

	for (; *ch; ) {

		if (*ch == ' ') {

			if (!(*argv++ = strndup(mark,ch-mark)))

				return -1;

			for (; (*ch == ' '); )

				ch++;

			mark = ch;

		} else {

			ch++;

		}

	}

	if (!(*argv++ = strndup(mark,ch-mark)))

		return -1;

	return 0;

}

int slbt_lib_get_driver_ctx(

	char **				argv,

	char **				envp,

	uint64_t			flags,

	const struct slbt_fd_ctx *	fdctx,

	struct slbt_driver_ctx **	pctx)

{

	struct slbt_split_vector	sargv;

	struct slbt_obj_list *		objlistv;

	struct slbt_driver_ctx_impl *	ctx;

	struct slbt_common_ctx		cctx;

	const struct argv_option *	optv[SLBT_OPTV_ELEMENTS];

	struct argv_meta *		meta;

	struct argv_entry *		entry;

	struct argv_entry *		cmdstatic;

	struct argv_entry *		cmdshared;

	struct argv_entry *		cmdnostatic;

	struct argv_entry *		cmdnoshared;

	const char *			program;

	const char *			lconf;

	uint64_t			lflags;

	size_t                          ndlopen;

	const char **			dlopenv;

	const char *                    cfgmeta_host;

	const char *                    cfgmeta_ar;

	const char *                    cfgmeta_as;

	const char *                    cfgmeta_nm;

	const char *                    cfgmeta_ranlib;

	const char *                    cfgmeta_dlltool;

	if (flags & SLBT_DRIVER_MODE_AR)

		argv_optv_init(slbt_ar_options,optv);

	else

		argv_optv_init(slbt_default_options,optv);

	if (!fdctx)

		fdctx = &slbt_default_fdctx;

	sargv.dargs = 0;

	sargv.dargv = 0;

	sargv.targv = 0;

	sargv.cargv = 0;

	objlistv    = 0;

	ndlopen     = 0;

	switch (slbt_split_argv(argv,flags,&sargv,&objlistv,fdctx->fderr,fdctx->fdcwd)) {

		case SLBT_OK:

			break;

		case SLBT_USAGE:

			return SLBT_USAGE;

		default:

			return slbt_free_argv_buffer(&sargv,objlistv);

	}

	if (!(meta = argv_get(

			sargv.targv,optv,

			slbt_argv_flags(flags),

			fdctx->fderr)))

		return slbt_free_argv_buffer(&sargv,objlistv);

	lconf   = 0;

	program = argv_program_name(argv[0]);

	memset(&cctx,0,sizeof(cctx));

	if (flags & SLBT_DRIVER_MODE_AR)

		cctx.mode = SLBT_MODE_AR;

	/* shared and static objects: enable by default, disable by ~switch */

	cctx.drvflags = flags | SLBT_DRIVER_SHARED | SLBT_DRIVER_STATIC;

	/* full annotation when annotation is on; */

	if (!(cctx.drvflags & SLBT_DRIVER_ANNOTATE_NEVER))

		cctx.drvflags |= SLBT_DRIVER_ANNOTATE_FULL;

	/* track incompatible command-line arguments */

	cmdstatic   = 0;

	cmdshared   = 0;

	cmdnostatic = 0;

	cmdnoshared = 0;

	cfgmeta_host   = 0;

	cfgmeta_ar     = 0;

	cfgmeta_as     = 0;

	cfgmeta_nm     = 0;

	cfgmeta_ranlib = 0;

	cfgmeta_dlltool = 0;

	/* get options */

	for (entry=meta->entries; entry->fopt || entry->arg; entry++) {

		if (entry->fopt) {

			switch (entry->tag) {

				case TAG_HELP:

				case TAG_HELP_ALL:

					switch (cctx.mode) {

						case SLBT_MODE_INSTALL:

						case SLBT_MODE_UNINSTALL:

						case SLBT_MODE_AR:

							break;

					default:

						return (flags & SLBT_DRIVER_VERBOSITY_USAGE)

							? slbt_driver_usage(

								fdctx->fdout,program,

								entry->arg,optv,

								meta,&sargv,objlistv,

								(cctx.drvflags & SLBT_DRIVER_ANNOTATE_NEVER))

							: SLBT_USAGE;

					}

					break;

				case TAG_VERSION:

					cctx.drvflags |= SLBT_DRIVER_VERSION;

					break;

				case TAG_HEURISTICS:

					cctx.drvflags |= SLBT_DRIVER_HEURISTICS;

					lconf = entry->arg;

					break;

				case TAG_MODE:

					if (!strcmp("clean",entry->arg))

						cctx.mode = SLBT_MODE_CLEAN;

					else if (!strcmp("compile",entry->arg))

						cctx.mode = SLBT_MODE_COMPILE;

					else if (!strcmp("execute",entry->arg))

						cctx.mode = SLBT_MODE_EXECUTE;

					else if (!strcmp("finish",entry->arg))

						cctx.mode = SLBT_MODE_FINISH;

					else if (!strcmp("install",entry->arg))

						cctx.mode = SLBT_MODE_INSTALL;

					else if (!strcmp("link",entry->arg))

						cctx.mode = SLBT_MODE_LINK;

					else if (!strcmp("uninstall",entry->arg))

						cctx.mode = SLBT_MODE_UNINSTALL;

					else if (!strcmp("ar",entry->arg))

						cctx.mode = SLBT_MODE_AR;

					break;

				case TAG_FINISH:

					cctx.mode = SLBT_MODE_FINISH;

					break;

				case TAG_DRY_RUN:

					cctx.drvflags |= SLBT_DRIVER_DRY_RUN;

					break;

				case TAG_TAG:

					if (!strcmp("CC",entry->arg))

						cctx.tag = SLBT_TAG_CC;

					else if (!strcmp("CXX",entry->arg))

						cctx.tag = SLBT_TAG_CXX;

					else if (!strcmp("FC",entry->arg))

						cctx.tag = SLBT_TAG_FC;

					else if (!strcmp("F77",entry->arg))

						cctx.tag = SLBT_TAG_F77;

					else if (!strcmp("ASM",entry->arg))

						cctx.tag = SLBT_TAG_ASM;

					else if (!strcmp("NASM",entry->arg))

						cctx.tag = SLBT_TAG_NASM;

					else if (!strcmp("RC",entry->arg))

						cctx.tag = SLBT_TAG_RC;

					else if (!strcmp("disable-static",entry->arg))

						cmdnostatic = entry;

					else if (!strcmp("disable-shared",entry->arg))

						cmdnoshared = entry;

					break;

				case TAG_INFO:

					cctx.drvflags |= SLBT_DRIVER_INFO;

					break;

				case TAG_CONFIG:

					cctx.drvflags |= SLBT_DRIVER_OUTPUT_CONFIG;

					break;

				case TAG_DUMPMACHINE:

					cctx.drvflags |= SLBT_DRIVER_OUTPUT_MACHINE;

					break;

				case TAG_DEBUG:

					cctx.drvflags |= SLBT_DRIVER_DEBUG;

					break;

				case TAG_FEATURES:

					cctx.drvflags |= SLBT_DRIVER_FEATURES;

					break;

				case TAG_LEGABITS:

					if (!entry->arg)

						cctx.drvflags |= SLBT_DRIVER_LEGABITS;

					else if (!strcmp("enabled",entry->arg))

						cctx.drvflags |= SLBT_DRIVER_LEGABITS;

					else

						cctx.drvflags &= ~(uint64_t)SLBT_DRIVER_LEGABITS;

					break;

				case TAG_CCWRAP:

					cctx.ccwrap = entry->arg;

					break;

				case TAG_IMPLIB:

					if (!strcmp("idata",entry->arg)) {

						cctx.drvflags |= SLBT_DRIVER_IMPLIB_IDATA;

						cctx.drvflags &= ~(uint64_t)SLBT_DRIVER_IMPLIB_DSOMETA;

					} else if (!strcmp("never",entry->arg)) {

						cctx.drvflags |= SLBT_DRIVER_IMPLIB_DSOMETA;

						cctx.drvflags &= ~(uint64_t)SLBT_DRIVER_IMPLIB_IDATA;

					}

					break;

				case TAG_WARNINGS:

					if (!strcmp("all",entry->arg))

						cctx.warnings = SLBT_WARNING_LEVEL_ALL;

					else if (!strcmp("error",entry->arg))

						cctx.warnings = SLBT_WARNING_LEVEL_ERROR;

					else if (!strcmp("none",entry->arg))

						cctx.warnings = SLBT_WARNING_LEVEL_NONE;

					break;

				case TAG_ANNOTATE:

					if (!strcmp("always",entry->arg)) {

						cctx.drvflags |= SLBT_DRIVER_ANNOTATE_ALWAYS;

						cctx.drvflags &= ~(uint64_t)SLBT_DRIVER_ANNOTATE_NEVER;

					} else if (!strcmp("never",entry->arg)) {

						cctx.drvflags |= SLBT_DRIVER_ANNOTATE_NEVER;

						cctx.drvflags &= ~(uint64_t)SLBT_DRIVER_ANNOTATE_ALWAYS;

					} else if (!strcmp("minimal",entry->arg)) {

						cctx.drvflags &= ~(uint64_t)SLBT_DRIVER_ANNOTATE_FULL;

					} else if (!strcmp("full",entry->arg)) {

						cctx.drvflags |= SLBT_DRIVER_ANNOTATE_FULL;

					}

					break;

				case TAG_DEPS:

					cctx.drvflags |= SLBT_DRIVER_DEPS;

					break;

				case TAG_SILENT:

					cctx.drvflags |= SLBT_DRIVER_SILENT;

					break;

				case TAG_VERBOSE:

					cctx.drvflags |= SLBT_DRIVER_VERBOSE;

					break;

				case TAG_HOST:

					cctx.host.host = entry->arg;

					cfgmeta_host   = cfgexplicit;

					break;

				case TAG_FLAVOR:

					cctx.host.flavor = entry->arg;

					break;

				case TAG_AR:

					cctx.host.ar = entry->arg;

					cfgmeta_ar   = cfgexplicit;

					break;

				case TAG_AS:

					cctx.host.as = entry->arg;

					cfgmeta_as   = cfgexplicit;

					break;

				case TAG_NM:

					cctx.host.nm = entry->arg;

					cfgmeta_nm   = cfgexplicit;

					break;

				case TAG_RANLIB:

					cctx.host.ranlib = entry->arg;

					cfgmeta_ranlib   = cfgexplicit;

					break;

				case TAG_WINDRES:

					cctx.host.windres = entry->arg;

					break;

				case TAG_DLLTOOL:

					cctx.host.dlltool = entry->arg;

					cfgmeta_dlltool   = cfgexplicit;

					break;

				case TAG_MDSO:

					cctx.host.mdso = entry->arg;

					break;

				case TAG_OUTPUT:

					cctx.output = entry->arg;

					break;

				case TAG_SHREXT:

					cctx.shrext = entry->arg;

					break;

				case TAG_RPATH:

					cctx.rpath = entry->arg;

					break;

				case TAG_SYSROOT:

					cctx.sysroot = entry->arg;

					break;