/*
 * 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 (c) 2017 Peter Tribble.
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */


#include <stdio.h>
#include <limits.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <dirent.h>
#include <sys/stat.h>
#include <pkginfo.h>
#include <pkglocs.h>
#include <sys/types.h>
#include <pkgstrct.h>
#include <pkgtrans.h>
#include <locale.h>
#include <libintl.h>
#include <pkglib.h>
#include <libadm.h>
#include <libinst.h>

#define	MAXPATHS	1024

#define	MSG_CHK_STRM	"Checking uninstalled stream format package " \
				"<%s> from <%s>\n"
#define	MSG_CHK_DIR	"Checking uninstalled directory format package " \
				"<%s> from <%s>\n"
#define	MSG_NOTROOT	"NOTE: \"root\" permission may be required to " \
				"validate all objects in the client filesystem."
#define	MSG_CONT	"Continuing."

#define	WRN_F_SPOOL	"WARNING: %s is spooled. Ignoring \"f\" argument"

#define	ERR_ROOT_SET	"Could not set install root from the environment."
#define	ERR_ROOT_CMD	"Command line install root contends with environment."
#define	ERR_IOPEN	"unable to open input file <%s>"
#define	ERR_IEMPTY	"no pathnames in file specified by -i option"
#define	ERR_POPTION	"no pathname included with -p option"
#define	ERR_PARTIAL_POPTION	"no pathname included with -P option"
#define	ERR_MAXPATHS	"too many pathnames in option list (limit is %d)"
#define	ERR_NOTROOT	"You must be \"root\" for \"%s -f\" to" \
					"execute properly."
#define	ERR_SEL_PKG "No packages selected for verification."
#define	ERR_CAT_LNGTH "The category argument exceeds the SVr4 ABI\n" \
		"        defined maximum supported length of 16 characters."
#define	ERR_CAT_FND "Category argument <%s> cannot be found."
#define	ERR_CAT_INV "Category argument <%s> is invalid."
#define	ERR_TOO_MANY "too many pathnames in list, limit is %d"
#define	ERR_PATHS_INVALID "Pathnames in %s are not valid."
#define	ERR_MKDIR "unable to make directory <%s>"
#define	ERR_USAGE	"usage:\n" \
		"\t%s [-l|vqacnxf] [-R rootdir] [-p path[, ...] | " \
		"-P path[, ...]]\n" \
		"\t\t[-i file] [options]\n" \
		"\t%s -d device [-f][-l|v] [-p path[, ...] | " \
		"-P path[, ...]]\n" \
		"\t\t[-V ...] [-M] [-i file] [-Y category[, ...] | " \
		"pkginst [...]]\n" \
		"\twhere options may include ONE of the " \
		"following:\n " \
		"\t\t-m pkgmap [-e envfile]\n" \
		"\t\tpkginst [...]\n" \
		"\t\t-Y category[, ...]\n"

#define	LINK	1

char	**pkg = NULL;
int	pkgcnt = 0;
char	*basedir;
char	*pathlist[MAXPATHS], *ppathlist[MAXPATHS], pkgspool[PATH_MAX];
short	used[MAXPATHS];
short	npaths;
struct cfent **eptlist;

int	aflag = (-1);
int	cflag = (-1);
int	vflag = 0;
int	nflag = 0;
int	lflag = 0;
int	Lflag = 0;
int	fflag = 0;
int	xflag = 0;
int	qflag = 0;
int	Rflag = 0;
int	dflag = 0;
char	*device;

char	*uniTmp;

static char	*mapfile,
		*spooldir,
		*tmpdir,
		*envfile;
static int	errflg = 0;
static int	map_client = 1;

void	quit(int);
static void	setpathlist(char *);
static void	usage(void);

extern	char	**environ;
extern	char	*pkgdir;

/* checkmap.c */
extern int	checkmap(int, int, char *, char *, char *, char *, int);
/* scriptvfy.c */
extern int	checkscripts(char *inst_dir, int silent);

int
main(int argc, char *argv[])
{
	int	pkgfmt = 0;	/* Makes more sense as a pointer, but */
				/*	18N is compromised. */
	char	file[PATH_MAX+1],
	    *abi_sym_ptr,
	    *vfstab_file = NULL;
	char *all_pkgs[4] = {"all", NULL};
	char **category = NULL;
	char *catg_arg = NULL;
	int	c;
	int	n = 0;
	char	*prog, *Rvalue = NULL, *dvalue = NULL;
	int pathtype;

	/* initialize locale mechanism */

	(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)	/* Should be defined by cc -D */
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	/* determine program name */

	prog = set_prog_name(argv[0]);

	/* establish installation root directory */

	if (!set_inst_root(getenv("PKG_INSTALL_ROOT"))) {
		progerr(gettext(ERR_ROOT_SET));
		quit(1);
	}

	/* check if not ABI compliant mode */
	abi_sym_ptr = getenv("PKG_NONABI_SYMLINKS");
	if (abi_sym_ptr && strncasecmp(abi_sym_ptr, "TRUE", 4) == 0) {
		set_nonABI_symlinks();
	}

	/* bugId 4012147 */
	if ((uniTmp = getenv("PKG_NO_UNIFIED")) != NULL)
		map_client = 0;

	while ((c = getopt(argc, argv, "Y:R:e:p:d:nLli:vaV:Mm:cqxfP:?"))
	    != EOF) {
		switch (c) {
		case 'p':
			pathlist[npaths] = strtok(optarg, " , ");
			if (pathlist[npaths++] == NULL) {
				progerr(gettext(ERR_POPTION));
				quit(1);
			}
			while (pathlist[npaths] = strtok(NULL, " , ")) {
				if (npaths++ >= MAXPATHS) {
					progerr(gettext(ERR_MAXPATHS),
					    MAXPATHS);
					quit(1);
				}
			}
			break;

		case 'd':
			dvalue = optarg;
			dflag = 1;
			break;

		case 'n':
			nflag++;
			break;

		case 'M':
			map_client = 0;
			break;

		/*
		 * Allow admin to establish the client filesystem using a
		 * vfstab-like file of stable format.
		 */
		case 'V':
			vfstab_file = flex_device(optarg, 2);
			map_client = 1;
			break;

		case 'f':
			if (getuid()) {
				progerr(gettext(ERR_NOTROOT), prog);
				quit(1);
			}
			fflag++;
			break;

		case 'i':
			setpathlist(optarg);
			break;

		case 'v':
			vflag++;
			break;

		case 'l':
			lflag++;
			break;

		case 'L':
			Lflag++;
			break;

		case 'x':
			if (aflag < 0)
				aflag = 0;
			if (cflag < 0)
				cflag = 0;
			xflag++;
			break;

		case 'q':
			qflag++;
			break;

		case 'a':
			if (cflag < 0)
				cflag = 0;
			aflag = 1;
			break;

		case 'c':
			if (aflag < 0)
				aflag = 0;
			cflag = 1;
			break;

		case 'e':
			envfile = optarg;
			break;

		case 'm':
			mapfile = optarg;
			break;

		case 'R':
			Rvalue = optarg;
			Rflag = 1;
			break;

		case 'Y':
			catg_arg = strdup(optarg);

			if ((category = get_categories(catg_arg)) == NULL) {
				progerr(gettext(ERR_CAT_INV), catg_arg);
				quit(1);
			} else if (is_not_valid_length(category)) {
				progerr(gettext(ERR_CAT_LNGTH));
				quit(1);
			}
			break;

		case 'P':
			ppathlist[npaths] = strtok(optarg, " , ");
			if ((ppathlist[npaths] == NULL) ||
			    (ppathlist[npaths][0] == '-')) {
				progerr(gettext(ERR_PARTIAL_POPTION));
				quit(1);
			}
			npaths++;
			while (ppathlist[npaths] = strtok(NULL, " , ")) {
				if (npaths++ >= MAXPATHS) {
					progerr(gettext(ERR_MAXPATHS),
					    MAXPATHS);
					quit(1);
				}
			}
			break;

		default:
			usage();
			/*NOTREACHED*/
			/*
			 * Although usage() calls a noreturn function,
			 * needed to add return (1);  so that main() would
			 * pass compilation checks. The statement below
			 * should never be executed.
			 */
			return (1);
		}
	}

	/* Check for incompatible options */
	if (dflag && Rflag)
		usage();

	/* Check for root dir and device dir if set */
	if (Rflag) {
		if (!set_inst_root(Rvalue)) {
			progerr(gettext(ERR_ROOT_CMD));
			quit(1);
		}
	}

	if (dflag)
		device = flex_device(dvalue, 1);

	if (lflag || Lflag) {
		/* we're only supposed to list information */
		if ((cflag >= 0) || (aflag >= 0) ||
		    qflag || xflag || fflag || nflag || vflag)
			usage();
	}

	set_PKGpaths(get_inst_root());

	if (catg_arg != NULL && device == NULL) {
		if (argc - optind) {
			usage();
		}
		pkg = gpkglist(pkgdir, all_pkgs, category);
		if (pkg == NULL) {
			progerr(gettext(ERR_CAT_FND), catg_arg);
			quit(1);
		} else {
			for (pkgcnt = 0; pkg[pkgcnt] != NULL; pkgcnt++)
				;
		}
	} else if (catg_arg != NULL && optind < argc) {
		usage();
	} else {
		pkg = &argv[optind];
		pkgcnt = (argc - optind);
	}

	/* read the environment for the pkgserver */
	pkgserversetmode(DEFAULTMODE);

	environ = NULL;		/* Sever the parent environment. */

	if (vcfile() == 0) {
		quit(99);
	}

	errflg = 0;
	if (mapfile) {
		/* check for incompatible options */
		if (device || pkgcnt)
			usage();
		put_path_params();	/* Restore what's needed. */

		/* send pathtype if partial path */
		pathtype = (ppathlist[0] != NULL) ? 1 : 0;
		if (checkmap(0, (device != NULL), mapfile, envfile, NULL,
		    NULL, pathtype))
			errflg++;
	} else if (device) {
		/* check for incompatible options */
		if ((cflag >= 0) || (aflag >= 0))
			usage();
		if (qflag || xflag || nflag || envfile)
			usage();
		tmpdir = NULL;
		if ((spooldir = devattr(device, "pathname")) == NULL)
			spooldir = device;
		if (isdir(spooldir)) {
			tmpdir = spooldir = qstrdup(tmpnam(NULL));
			if (fflag) {
				logerr(gettext(WRN_F_SPOOL), *pkg);
				fflag = 0;
			}
			if (mkdir(spooldir, 0755)) {
				progerr(gettext(ERR_MKDIR), spooldir);
				quit(99);
			}
			if (n = pkgtrans(device, spooldir, pkg, PT_SILENT))
				quit(n);
			if (catg_arg != NULL)
				pkg = gpkglist(spooldir, all_pkgs, category);
			else
				pkg = gpkglist(spooldir, all_pkgs, NULL);
			pkgfmt = 0;
		} else {
			if (catg_arg != NULL)
				pkg = gpkglist(spooldir,
				    pkgcnt ? pkg : all_pkgs, category);
			else
				pkg = gpkglist(spooldir,
				    pkgcnt ? pkg : all_pkgs, NULL);
			pkgfmt = 1;
		}

		/*
		 * At this point pkg[] is the list of packages to check. They
		 * are in directory format in spooldir.
		 */
		if (pkg == NULL) {
			if (catg_arg != NULL) {
				progerr(gettext(ERR_CAT_FND), catg_arg);
				quit(1);
			} else {
				progerr(gettext(ERR_SEL_PKG));
				quit(1);
			}
		}

		aflag = 0;

		for (n = 0; pkg[n]; n++) {
			char locenv[PATH_MAX];

			if (pkgfmt)
				(void) printf(
				    gettext(MSG_CHK_DIR), pkg[n], device);
			else
				(void) printf(
				    gettext(MSG_CHK_STRM), pkg[n], device);

			(void) snprintf(pkgspool, sizeof (pkgspool),
			    "%s/%s", spooldir, pkg[n]);
			(void) snprintf(file, sizeof (file),
			    "%s/install", pkgspool);
			/* Here we check the install scripts. */
			(void) printf(
			    gettext("## Checking control scripts.\n"));
			(void) checkscripts(file, 0);
			/* Verify consistency with the pkgmap. */
			(void) printf(
			    gettext("## Checking package objects.\n"));
			(void) snprintf(file, sizeof (file),
			    "%s/pkgmap", pkgspool);
			(void) snprintf(locenv, sizeof (locenv),
			    "%s/pkginfo", pkgspool);
			envfile = locenv;

			/*
			 * NOTE : checkmap() frees the environ data and
			 * pointer when it's through with them.
			 */
			if (checkmap(0, (device != NULL), file, envfile,
			    pkg[n], NULL, 0))
				errflg++;
			(void) printf(
			    gettext("## Checking is complete.\n"));
		}
	} else {
		if (envfile)
			usage();

		put_path_params();	/* Restore what's needed. */

		/*
		 * If this is a check of a client of some sort, we'll need to
		 * mount up the client's filesystems. If the caller isn't
		 * root, this may not be possible.
		 */
		if (is_an_inst_root()) {
			if (getuid()) {
				logerr(gettext(MSG_NOTROOT));
				logerr(gettext(MSG_CONT));
			} else {
				if (get_mntinfo(map_client, vfstab_file))
					map_client = 0;
				if (map_client)
					mount_client();
			}
		}

		(void) snprintf(file, sizeof (file),
		    "%s/contents", get_PKGADM());
		if (ppathlist[0] != NULL) {
			for (n = 0; ppathlist[n]; n++) {
				if (checkmap(1, (device != NULL), file, NULL,
				    NULL, ppathlist[n], 1))
					errflg++;
			}
		} else if (pkg[0] != NULL) {
				if (checkmap(1, (device != NULL), file, NULL,
				    pkg[0], NULL, 0)) {
					errflg++;
				}
		} else {
			if (checkmap(1, (device != NULL), file, NULL,
			    NULL, NULL, 0)) {
				errflg++;
			}
		}

		if (map_client) {
			unmount_client();
		}
	}
	quit(errflg ? 1 : 0);
	/* LINTED: no return */
}

static void
setpathlist(char *file)
{
	int fd;
	struct stat st;
	FILE *fplist;
	char pathname[PATH_MAX];
	/*
	 * This trap laid to catch a mismatch between the declaration above and
	 * the hard-coded constant in the fscanf below
	 */
#if PATH_MAX != 1024
#error "PATH_MAX changed, so we have a bug to fix"
#endif

	if (strcmp(file, "-") == 0) {
		fplist = stdin;
	} else {
		if ((fd = open(file, O_RDONLY)) == -1) {
			progerr(gettext(ERR_IOPEN), file);
			quit(1);
		}
		if (fstat(fd, &st) == -1) {
			progerr(gettext(ERR_IOPEN), file);
			quit(1);
		}
		if (S_ISDIR(st.st_mode) || S_ISBLK(st.st_mode)) {
			progerr(gettext(ERR_PATHS_INVALID), file);
			quit(1);
		}
		if ((fplist = fdopen(fd, "r")) == NULL) {
			progerr(gettext(ERR_IOPEN), file);
			quit(1);
		}
	}
	while (fscanf(fplist, "%1024s", pathname) == 1) {
		if (*pathname == '\0') {
			progerr(gettext(ERR_PATHS_INVALID), file);
			quit(1);
		}
		pathlist[npaths] = qstrdup(pathname);
		if (npaths++ > MAXPATHS) {
			progerr(gettext(ERR_TOO_MANY), MAXPATHS);
			quit(1);
		}
	}
	if (npaths == 0) {
		progerr(gettext(ERR_IEMPTY));
		quit(1);
	}
	(void) fclose(fplist);
}

void
quit(int n)
{
	/* cleanup any temporary directories */
	(void) chdir("/");
	if (tmpdir != NULL) {
		(void) rrmdir(tmpdir);
		free(tmpdir);
		tmpdir = NULL;
	}
	(void) pkghead(NULL);
	exit(n);
	/*NOTREACHED*/
}

static void
usage(void)
{
	char *prog = get_prog_name();

	(void) fprintf(stderr, gettext(ERR_USAGE), prog, prog);
	quit(1);
	/*NOTREACHED*/
}