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

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

/*  Copyright (C) 2016--2018  Z. Gilboa                            */

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

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

#include <stdint.h>

#include <unistd.h>

#include <fcntl.h>

#define ARGV_DRIVER

#include <slibtool/slibtool.h>

#include "slibtool_version.h"

#include "slibtool_driver_impl.h"

#include "slibtool_errinfo_impl.h"

#include "argv/argv.h"

/* 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

};

/* flavor settings */

#define SLBT_FLAVOR_SETTINGS(flavor,bfmt,arp,ars,dsop,dsos,exep,exes,impp,imps,ldenv) \

	static const struct slbt_flavor_settings flavor = {		   \

		bfmt,arp,ars,dsop,dsos,exep,exes,impp,imps,ldenv}

SLBT_FLAVOR_SETTINGS(host_flavor_default, "elf",  "lib",".a", "lib",".so",    "","",     "",   "",       "LD_LIBRARY_PATH");

SLBT_FLAVOR_SETTINGS(host_flavor_midipix, "pe",   "lib",".a", "lib",".so",    "","",     "lib",".lib.a", "PATH");

SLBT_FLAVOR_SETTINGS(host_flavor_mingw,   "pe",   "lib",".a", "lib",".dll",   "",".exe", "lib",".dll.a", "PATH");

SLBT_FLAVOR_SETTINGS(host_flavor_cygwin,  "pe",   "lib",".a", "lib",".dll",   "",".exe", "lib",".dll.a", "PATH");

SLBT_FLAVOR_SETTINGS(host_flavor_darwin,  "macho","lib",".a", "lib",".dylib", "","",     "",   "",       "DYLD_LIBRARY_PATH");

/* annotation strings */

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

static const char cfghost[]     = "derived from <host>";

static const char cfgtarget[]   = "derived from <target>";

static const char cfgcompiler[] = "derived from <compiler>";

static const char cfgnmachine[] = "native (derived from -dumpmachine)";

static const char cfgxmachine[] = "foreign (derived from -dumpmachine)";

static const char cfgnative[]   = "native";

/* default compiler argv */

static char * slbt_default_cargv[] = {"cc",0};

/* elf rpath */

static const char*ldrpath_elf[] = {

	"/lib",

	"/lib/64",

	"/usr/lib",

	"/usr/lib64",

	"/usr/local/lib",

	"/usr/local/lib64",

	0};

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";

struct slbt_split_vector {

	char **		targv;

	char **		cargv;

};

struct slbt_driver_ctx_alloc {

	struct argv_meta *		meta;

	struct slbt_driver_ctx_impl	ctx;

	uint64_t			guard;

};

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

{

	char **		parg;

	char *		dot;

	const char *	color;

	bool		fcolor;

	(void)envp;

	if ((fcolor = isatty(fderr)))

		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 : "");

}

static uint32_t slbt_argv_flags(uint32_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_driver_usage(

	int				fdout,

	const char *			program,

	const char *			arg,

	const struct argv_option **	optv,

	struct argv_meta *		meta)

{

	char header[512];

	snprintf(header,sizeof(header),

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

		program);

	argv_usage(fdout,header,optv,arg);

	argv_free(meta);

	return SLBT_USAGE;

}

static struct slbt_driver_ctx_impl * slbt_driver_ctx_alloc(

	struct argv_meta *		meta,

	const struct slbt_fd_ctx *	fdctx,

	const struct slbt_common_ctx *	cctx)

{

	struct slbt_driver_ctx_alloc *	ictx;

	size_t				size;

	int				elements;

	size =  sizeof(struct slbt_driver_ctx_alloc);

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

		return 0;

	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->meta = meta;

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

	return &ictx->ctx;

}

static int slbt_get_driver_ctx_fail(struct argv_meta * meta)

{

	argv_free(meta);

	return -1;

}

static int slbt_split_argv(

	char **				argv,

	uint32_t			flags,

	struct slbt_split_vector *	sargv,

	int				fderr)

{

	int				i;

	int				argc;

	const char *			program;

	char *				compiler;

	char **				targv;

	char **				cargv;

	struct argv_meta *		meta;

	struct argv_entry *		entry;

	struct argv_entry *		mode;

	struct argv_entry *		config;

	struct argv_entry *		finish;

	struct argv_entry *		features;

	const struct argv_option **	popt;

	const struct argv_option **	optout;

	const struct argv_option *	optv[SLBT_OPTV_ELEMENTS];

	struct argv_ctx			ctx = {ARGV_VERBOSITY_NONE,

						ARGV_MODE_SCAN,

						0,0,0,0,0,0,0};

	program = argv_program_name(argv[0]);

	/* missing arguments? */

	argv_optv_init(slbt_default_options,optv);

	if (!argv[1] && (flags & SLBT_DRIVER_VERBOSITY_USAGE))

		return slbt_driver_usage(

			fderr,program,

			0,optv,0);

	/* initial argv scan: ... --mode=xxx ... <compiler> ... */

	argv_scan(argv,optv,&ctx,0);

	/* invalid slibtool arguments? */

	if (ctx.erridx && !ctx.unitidx) {

		if (flags & SLBT_DRIVER_VERBOSITY_ERRORS)

			argv_get(

				argv,optv,

				slbt_argv_flags(flags),

				fderr);

		return -1;

	}

	/* obtain slibtool's own arguments */

	if (ctx.unitidx) {

		compiler = argv[ctx.unitidx];

		argv[ctx.unitidx] = 0;

		meta = argv_get(argv,optv,ARGV_VERBOSITY_NONE,fderr);

		argv[ctx.unitidx] = compiler;

	} else {

		meta = argv_get(argv,optv,ARGV_VERBOSITY_NONE,fderr);

	}

	/* missing all of --mode, --config, --features, and --finish? */

	mode = config = finish = features = 0;

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

		if (entry->tag == TAG_MODE)

			mode = entry;

		else if (entry->tag == TAG_CONFIG)

			config = entry;

		else if (entry->tag == TAG_FINISH)

			finish = entry;

		else if (entry->tag == TAG_FEATURES)

			features = entry;

	argv_free(meta);

	if (!mode && !config && !finish && !features) {

		slbt_dprintf(fderr,

			"%s: error: --mode must be specified.\n",

			program);

		return -1;

	}

	/* missing compiler? */

	if (!ctx.unitidx && !finish && !features) {

		if (flags & SLBT_DRIVER_VERBOSITY_ERRORS)

			slbt_dprintf(fderr,

				"%s: error: <compiler> is missing.\n",

				program);

		return -1;

	}

	/* allocate split vectors */

	for (argc=0, targv=argv; *targv; targv++)

		argc++;

	if ((sargv->targv = calloc(2*(argc+1),sizeof(char *))))

		sargv->cargv = sargv->targv + argc + 1;

	else

		return -1;

	/* --features and no <compiler>? */

	if (features && !ctx.unitidx) {

		for (i=0; i

			sargv->targv[i] = argv[i];

		sargv->cargv = slbt_default_cargv;

		return 0;

	}

	/* split vectors: slibtool's own options */

	for (i=0; i

		sargv->targv[i] = argv[i];

	/* split vectors: legacy mixture */

	for (optout=optv; optout[0]->tag != TAG_OUTPUT; optout++)

		(void)0;

	targv = sargv->targv + i;

	cargv = sargv->cargv;

	for (; i

		if (argv[i][0] != '-') {

			if (argv[i+1] && (argv[i+1][0] == '+')

					&& (argv[i+1][1] == '=')

					&& (argv[i+1][2] == 0)

					&& !(strrchr(argv[i],'.')))

				/* libfoo_la_LDFLAGS += -Wl,.... */

				i++;

			else

				*cargv++ = argv[i];

		} else if (argv[i][1] == 'o') {

			*targv++ = argv[i];

			if (argv[i][2] == 0)

				*targv++ = argv[++i];

		}

		else if ((argv[i][1] == 'W')  && (argv[i][2] == 'c'))

			*cargv++ = argv[i];

		else if (!(strcmp("Xcompiler",&argv[i][1])))

			*cargv++ = argv[++i];

		else if ((argv[i][1] == 'R')  && (argv[i][2] == 0)) {

			*targv++ = argv[i++];

			*targv++ = argv[i];

		} else if (argv[i][1] == 'R') {

			*targv++ = argv[i];

		} else if (!(strcmp("bindir",&argv[i][1]))) {

			*targv++ = argv[i++];

			*targv++ = argv[i];

		} else if (!(strcmp("shrext",&argv[i][1]))) {

			*targv++ = argv[i++];

			*targv++ = argv[i];

		} else if (!(strcmp("rpath",&argv[i][1]))) {

			*targv++ = argv[i++];

			*targv++ = argv[i];

		} else if (!(strcmp("release",&argv[i][1]))) {

			*targv++ = argv[i++];

			*targv++ = argv[i];

		} else if (!(strcmp("dlopen",&argv[i][1]))) {

			*targv++ = argv[i++];

			*targv++ = argv[i];

		} else if (!(strcmp("export-dynamic",&argv[i][1]))) {

			*targv++ = argv[i];

		} else if (!(strcmp("export-symbols",&argv[i][1]))) {

			*targv++ = argv[i++];

			*targv++ = argv[i];

		} else if (!(strcmp("export-symbols-regex",&argv[i][1]))) {

			*targv++ = argv[i++];

			*targv++ = argv[i];

		} else if (!(strcmp("version-info",&argv[i][1]))) {

			*targv++ = argv[i++];

			*targv++ = argv[i];

		} else if (!(strcmp("version-number",&argv[i][1]))) {

			*targv++ = argv[i++];

			*targv++ = argv[i];

		} else if (!(strcmp("dlpreopen",&argv[i][1]))) {

			(void)0;

		} else {

			for (popt=optout; popt[0] && popt[0]->long_name; popt++)

				if (!(strcmp(popt[0]->long_name,&argv[i][1])))

					break;

			if (popt[0] && popt[0]->long_name)

				*targv++ = argv[i];

			else

				*cargv++ = argv[i];

		}

	}

	return 0;

}

static void slbt_get_host_quad(

	char *	hostbuf,

	char ** hostquad)

{

	char *	mark;

	char *	ch;

	int	i;

	for (i=0, ch=hostbuf, mark=hostbuf; *ch && i<4; ch++) {

		if (*ch == '-') {

			*ch = 0;

			hostquad[i++] = mark;

			mark = &ch[1];

		}

	}

	if (i<4)

		hostquad[i] = mark;

	if (i==3) {

		hostquad[1] = hostquad[2];

		hostquad[2] = hostquad[3];

		hostquad[3] = 0;

	}

}

static int slbt_init_host_params(

	const struct slbt_driver_ctx *	dctx,

	const struct slbt_common_ctx *	cctx,

	struct slbt_host_strs *		drvhost,

	struct slbt_host_params *	host,

	struct slbt_host_params *	cfgmeta)

{

	size_t		toollen;

	char *		dash;

	char *		base;

	char *		mark;

	const char *	machine;

	bool		ftarget       = false;

	bool		fhost         = false;

	bool		fcompiler     = false;

	bool		fnative       = false;

	bool		fdumpmachine  = false;

	char		buf        [256];

	char		hostbuf    [256];

	char		machinebuf [256];

	char *		hostquad   [4];

	char *		machinequad[4];

	/* base */

	if ((base = strrchr(cctx->cargv[0],'/')))

		base++;

	else

		base = cctx->cargv[0];

	fdumpmachine =  (cctx->mode == SLBT_MODE_COMPILE)

			|| (cctx->mode == SLBT_MODE_LINK)

			|| (cctx->mode == SLBT_MODE_INFO);

	/* support the portbld <--> unknown synonym */

	if (!(drvhost->machine = strdup(SLBT_MACHINE)))

		return -1;

	if ((mark = strstr(drvhost->machine,"-portbld-")))

		memcpy(mark,"-unknown",8);

	/* host */

	if (host->host) {

		cfgmeta->host = cfgexplicit;

		fhost         = true;

	} else if (cctx->target) {

		host->host    = cctx->target;

		cfgmeta->host = cfgtarget;

		ftarget       = true;

	} else if (strrchr(base,'-')) {

		if (!(drvhost->host = strdup(cctx->cargv[0])))

			return -1;

		dash          = strrchr(drvhost->host,'-');

		*dash         = 0;

		host->host    = drvhost->host;

		cfgmeta->host = cfgcompiler;

		fcompiler     = true;

	} else if (!fdumpmachine) {

		host->host    = drvhost->machine;

		cfgmeta->host = cfgnmachine;

	} else if (slbt_dump_machine(cctx->cargv[0],buf,sizeof(buf)) < 0) {

		if (dctx)

			slbt_dprintf(

				slbt_driver_fderr(dctx),

				"%s: could not determine host "

				"via -dumpmachine\n",

				dctx->program);

		return -1;

	} else {

		if (!(drvhost->host = strdup(buf)))

			return -1;

		host->host    = drvhost->host;

		fcompiler     = true;

		fnative       = !strcmp(host->host,drvhost->machine);

		cfgmeta->host = fnative ? cfgnmachine : cfgxmachine;

		if (!fnative) {

			strcpy(hostbuf,host->host);

			strcpy(machinebuf,drvhost->machine);

			slbt_get_host_quad(hostbuf,hostquad);

			slbt_get_host_quad(machinebuf,machinequad);

			if (hostquad[2] && machinequad[2])

				fnative = !strcmp(hostquad[0],machinequad[0])

					&& !strcmp(hostquad[1],machinequad[1])

					&& !strcmp(hostquad[2],machinequad[2]);

		}

	}

	/* flavor */

	if (host->flavor) {

		cfgmeta->flavor = cfgexplicit;

	} else {

		if (fhost) {

			machine         = host->host;

			cfgmeta->flavor = cfghost;

		} else if (ftarget) {

			machine         = cctx->target;

			cfgmeta->flavor = cfgtarget;

		} else if (fcompiler) {

			machine         = drvhost->host;

			cfgmeta->flavor = cfgcompiler;

		} else {

			machine         = drvhost->machine;

			cfgmeta->flavor = cfgnmachine;

		}

		dash = strrchr(machine,'-');

		cfgmeta->flavor = cfghost;

		if ((dash && !strcmp(dash,"-bsd")) || strstr(machine,"-bsd-"))

			host->flavor = "bsd";

		else if ((dash && !strcmp(dash,"-cygwin")) || strstr(machine,"-cygwin-"))

			host->flavor = "cygwin";

		else if ((dash && !strcmp(dash,"-darwin")) || strstr(machine,"-darwin"))

			host->flavor = "darwin";

		else if ((dash && !strcmp(dash,"-linux")) || strstr(machine,"-linux-"))

			host->flavor = "linux";

		else if ((dash && !strcmp(dash,"-midipix")) || strstr(machine,"-midipix-"))

			host->flavor = "midipix";

		else if ((dash && !strcmp(dash,"-mingw")) || strstr(machine,"-mingw-"))

			host->flavor = "mingw";

		else if ((dash && !strcmp(dash,"-mingw32")) || strstr(machine,"-mingw32-"))

			host->flavor = "mingw";

		else if ((dash && !strcmp(dash,"-mingw64")) || strstr(machine,"-mingw64-"))

			host->flavor = "mingw";

		else {

			host->flavor   = "default";

			cfgmeta->flavor = "fallback, unverified";

		}

		if (fcompiler && !fnative)

			if ((mark = strstr(drvhost->machine,host->flavor)))

				if (mark > drvhost->machine)

					fnative = (*--mark == '-');

	}

	/* toollen */

	toollen =  fnative ? 0 : strlen(host->host);

	toollen += strlen("-utility-name");

	/* ar */

	if (host->ar)

		cfgmeta->ar = cfgexplicit;

	else {

		if (!(drvhost->ar = calloc(1,toollen)))

			return -1;

		if (fnative) {

			strcpy(drvhost->ar,"ar");

			cfgmeta->ar = cfgnative;

		} else {

			sprintf(drvhost->ar,"%s-ar",host->host);

			cfgmeta->ar = cfghost;

		}

		host->ar = drvhost->ar;

	}

	/* ranlib */

	if (host->ranlib)

		cfgmeta->ranlib = cfgexplicit;

	else {

		if (!(drvhost->ranlib = calloc(1,toollen)))

			return -1;

		if (fnative) {

			strcpy(drvhost->ranlib,"ranlib");

			cfgmeta->ranlib = cfgnative;

		} else {

			sprintf(drvhost->ranlib,"%s-ranlib",host->host);

			cfgmeta->ranlib = cfghost;

		}

		host->ranlib = drvhost->ranlib;

	}

	/* dlltool */

	if (host->dlltool)

		cfgmeta->dlltool = cfgexplicit;

	else if (strcmp(host->flavor,"cygwin")

			&& strcmp(host->flavor,"midipix")

			&& strcmp(host->flavor,"mingw")) {

		host->dlltool = "";

		cfgmeta->dlltool = "not applicable";

	} else {

		if (!(drvhost->dlltool = calloc(1,toollen)))

			return -1;

		if (fnative) {

			strcpy(drvhost->dlltool,"dlltool");

			cfgmeta->dlltool = cfgnative;

		} else {

			sprintf(drvhost->dlltool,"%s-dlltool",host->host);

			cfgmeta->dlltool = cfghost;

		}

		host->dlltool = drvhost->dlltool;

	}

	/* mdso */

	if (host->mdso)

		cfgmeta->mdso = cfgexplicit;

	else if (strcmp(host->flavor,"cygwin")

			&& strcmp(host->flavor,"midipix")

			&& strcmp(host->flavor,"mingw")) {

		host->mdso = "";

		cfgmeta->mdso = "not applicable";

	} else {

		if (!(drvhost->mdso = calloc(1,toollen)))

			return -1;

		if (fnative) {

			strcpy(drvhost->mdso,"mdso");

			cfgmeta->mdso = cfgnative;

		} else {

			sprintf(drvhost->mdso,"%s-mdso",host->host);

			cfgmeta->mdso = cfghost;

		}

		host->mdso = drvhost->mdso;

	}

	return 0;

}

static void slbt_free_host_params(struct slbt_host_strs * host)

{

	if (host->machine)

		free(host->machine);

	if (host->host)

		free(host->host);

	if (host->flavor)

		free(host->flavor);

	if (host->ar)

		free(host->ar);

	if (host->ranlib)

		free(host->ranlib);

	if (host->dlltool)

		free(host->dlltool);

	if (host->mdso)

		free(host->mdso);

	memset(host,0,sizeof(*host));

}

static void slbt_init_flavor_settings(

	struct slbt_common_ctx *	cctx,

	const struct slbt_host_params * ahost,

	struct slbt_flavor_settings *	psettings)

{

	const struct slbt_host_params *     host;

	const struct slbt_flavor_settings * settings;

	const char *                        dot;

	host = ahost ? ahost : &cctx->host;

	if (!strcmp(host->flavor,"midipix"))

		settings = &host_flavor_midipix;

	else if (!strcmp(host->flavor,"mingw"))

		settings = &host_flavor_mingw;

	else if (!strcmp(host->flavor,"cygwin"))

		settings = &host_flavor_cygwin;

	else if (!strcmp(host->flavor,"darwin"))

		settings = &host_flavor_darwin;

	else

		settings = &host_flavor_default;

	if (!ahost) {

		if (!strcmp(settings->imagefmt,"elf"))

			cctx->drvflags |= SLBT_DRIVER_IMAGE_ELF;

		else if (!strcmp(settings->imagefmt,"pe"))

			cctx->drvflags |= SLBT_DRIVER_IMAGE_PE;

		else if (!strcmp(settings->imagefmt,"macho"))

			cctx->drvflags |= SLBT_DRIVER_IMAGE_MACHO;

	}

	memcpy(psettings,settings,sizeof(*settings));

	if (cctx->shrext)

		psettings->dsosuffix = (dot = strrchr(cctx->shrext,'.'))

			? dot : cctx->shrext;

}

static int slbt_init_ldrpath(

	struct slbt_common_ctx *  cctx,