/*
 * 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 (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */


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

extern int	holdcinfo;

#define	WRN_SCARYLINK	"WARNING: <%s>, target of symlink <%s>, does not exist."

#define	ERR_PATHLONG	"path argument too long"
#define	ERR_CLASSLONG	"classname argument too long"
#define	ERR_CLASSCHAR	"bad character in classname"
#define	ERR_STAT	"unable to stat <%s>"
#define	ERR_WRITE	"write of entry failed"
#define	ERR_POPEN	"unable to create pipe to <%s>"
#define	ERR_PCLOSE	"unable to close pipe to <%s>"
#define	ERR_RDLINK	"unable to read link for <%s>"
#define	ERR_MEMORY	"memory allocation failure, errno=%d"

#define	LINK	1

struct link {
	char	*path;
	ino_t	ino;
	dev_t	dev;
	struct link *next;
};

static struct link *firstlink = (struct link *)0;
static struct link *lastlink = (struct link *)0;
static char *scan_raw_ln(char *targ_name, char *link_name);

static char	*def_class = "none";

static int	errflg = 0;
static int	iflag = 0;	/* follow symlinks */
static int	xflag = 0;	/* confirm contents of files */
static int	nflag = 0;
static char	construction[PATH_MAX], mylocal[PATH_MAX];

static void	findlink(struct cfent *ept, char *path, char *svpath);
static void	follow(char *path);
static void	output(char *path, int n, char *local);
static void	usage(void);

int
main(int argc, char *argv[])
{
	int c;
	char *pt, path[PATH_MAX];
	char	*abi_sym_ptr;
	extern char	*optarg;
	extern int	optind;

	(void) setlocale(LC_ALL, "");

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

	(void) set_prog_name(argv[0]);

	while ((c = getopt(argc, argv, "xnic:?")) != EOF) {
		switch (c) {
		    case 'x':	/* include content info */
			xflag++;
			break;

		    case 'n':
			nflag++;
			break;

		    case 'c':	/* assign class */
			def_class = optarg;
			/* validate that classname is acceptable */
			if (strlen(def_class) > (size_t)CLSSIZ) {
				progerr(gettext(ERR_CLASSLONG));
				exit(1);
			}
			for (pt = def_class; *pt; pt++) {
				if (!isalpha(*pt) && !isdigit(*pt)) {
					progerr(gettext(ERR_CLASSCHAR));
					exit(1);
				}
			}
			break;

		    case 'i':	/* follow symlinks */
			iflag++;
			break;

		    default:
			usage();
		}
	}

	if (iflag) {
		/* follow symlinks */
		set_nonABI_symlinks();
	} else {
		/* bug id 4244631, not ABI compliant */
		abi_sym_ptr = getenv("PKG_NONABI_SYMLINKS");
		if (abi_sym_ptr && strncasecmp(abi_sym_ptr, "TRUE", 4) == 0) {
			set_nonABI_symlinks();
		}
	}
	holdcinfo = !xflag;
	if (optind == argc) {
		/* take path list from stdin */
		while (fgets(path, sizeof (path), stdin) != (char *)NULL) {
			output(path, 0, NULL);
		}
	} else {
		while (optind < argc) {
			follow(argv[optind++]);
		}
	}

	return (errflg ? 1 : 0);
}

static void
output(char *path, int n, char *local)
{
	char		mypath[PATH_MAX];
	int		len;
	int		s;
	struct cfent	entry;

	/*
	 * remove any trailing newline characters from the end of path
	 */

	len = strlen(path);
	while ((len > 0) && (path[len-1] == '\n')) {
		path[--len] = '\0';
	}

	entry.volno = 0;
	entry.ftype = '?';
	entry.path = mypath;
	(void) strlcpy(entry.pkg_class, def_class, sizeof (entry.pkg_class));
	(void) strlcpy(entry.path, path, PATH_MAX);
	entry.ainfo.local = NULL;
	entry.ainfo.mode = BADMODE;
	(void) strlcpy(entry.ainfo.owner, BADOWNER, sizeof (entry.ainfo.owner));
	(void) strlcpy(entry.ainfo.group, BADGROUP, sizeof (entry.ainfo.group));
	errflg = 0;

	if (xflag) {
		entry.ftype = '?';
		if (cverify(0, &entry.ftype, path, &entry.cinfo, 1)) {
			errflg++;
			logerr(gettext("ERROR: %s"), path);
			logerr(getErrbufAddr());
			return;
		}
	}

	/*
	 * Use averify to figure out the attributes. This has trouble
	 * divining the identity of a symlink which points to a
	 * non-existant target. For that reason, if it comes back as
	 * an existence problem, we fake in a symlink and see if averify
	 * likes that. If it does, all we have is a risky symlink.
	 */
	if ((s = averify(0, &entry.ftype, path, &entry.ainfo)) == VE_EXIST &&
	    !iflag) {
		entry.ftype = 's';	/* try again assuming symlink */
		/* try to read what it points to */
		if ((s = readlink(path, mylocal, PATH_MAX)) > 0) {
			mylocal[s] = '\000';	/* terminate it */
			entry.ainfo.local = mylocal;
			if (averify(0, &entry.ftype, path, &entry.ainfo)) {
				errflg++;
			} else
				/* It's a link to a file not in this package. */
				ptext(stderr, gettext(WRN_SCARYLINK),
				    mylocal, path);
		} else {
			errflg++;
		}
	} else if (s != 0 && s != VE_CONT)
		errflg++;

	if (errflg) {
		logerr(gettext("ERROR: %s"), path);
		logerr(getErrbufAddr());
		return;
	}

	if (n) {
		/* replace first n characters with 'local' */
		if (strchr("fev", entry.ftype)) {
			entry.ainfo.local = mylocal;
			(void) strlcpy(entry.ainfo.local, entry.path,
				PATH_MAX);
			canonize(entry.ainfo.local);
		}
		if (local[0]) {
			entry.ainfo.local = mylocal;
			(void) strlcpy(entry.path, local, PATH_MAX);
			(void) strcat(entry.path, path+n);
		} else
			(void) strlcpy(entry.path,
				(path[n] == '/') ? path+n+1 : path+n,
				PATH_MAX);
	}

	canonize(entry.path);
	if (entry.path[0]) {
		findlink(&entry, path, entry.path);
		if (strchr("dcbp", entry.ftype) ||
		(nflag && !strchr("sl", entry.ftype)))
			entry.ainfo.local = NULL;
		if (ppkgmap(&entry, stdout)) {
			progerr(gettext(ERR_WRITE));
			exit(99);
		}
	}
}

static void
follow(char *path)
{
	struct stat stbuf;
	FILE	*pp;
	char	*pt,
		local[PATH_MAX],
		newpath[PATH_MAX],
		cmd[PATH_MAX+32];
	int n;

	errflg = 0;

	if (pt = strchr(path, '=')) {
		*pt++ = '\0';
		n = ((unsigned int)pt - (unsigned int)path - 1);
		if (n >= PATH_MAX) {
			progerr(gettext(ERR_PATHLONG));
			errflg++;
			return;
		}

		n = strlen(pt);

		if (n < PATH_MAX) {
			(void) strlcpy(local, pt, sizeof (local));
			n = strlen(path);
		} else {
			progerr(gettext(ERR_PATHLONG));
			errflg++;
			return;
		}
	} else {
		n = 0;
		local[0] = '\0';
	}

	if (stat(path, &stbuf)) {
		progerr(gettext(ERR_STAT), path);
		errflg++;
		return;
	}

	if (stbuf.st_mode & S_IFDIR) {
		(void) snprintf(cmd, sizeof (cmd), "find %s -print", path);
		if ((pp = popen(cmd, "r")) == NULL) {
			progerr(gettext(ERR_POPEN), cmd);
			exit(1);
		}
		while (fscanf(pp, "%[^\n]\n", newpath) == 1)
			output(newpath, n, local);
		if (pclose(pp)) {
			progerr(gettext(ERR_PCLOSE), cmd);
			errflg++;
		}
	} else
		output(path, n, local);
}

/*
 * Scan a raw link for origination errors. Given
 *	targ_name = hlink/path/file1
 *		and
 *	link_name = hlink/path/file2
 * we don't want the link to be verbatim since link_name must be relative
 * to it's source. This functions checks for identical directory paths
 * and if it's clearly a misplaced relative path, the duplicate
 * directories are stripped. This is necessary because pkgadd is actually
 * in the source directory (hlink/path) when it creates the link.
 *
 * NOTE : The buffer we get with targ_name is going to be used later
 * and cannot be modified. That's why we have yet another PATH_MAX
 * size buffer in this function.
 */
static char *
scan_raw_ln(char *targ_name, char *link_name)
{
	char *const_ptr;	/* what we return */
	char *file_name;	/* name of the file in link_name */
	char *this_dir;		/* current directory in targ_name */
	char *next_dir;		/* next directory in targ_name  */
	char *targ_ptr;		/* current character in targ_name */

	const_ptr = targ_name;	/* Point to here 'til we know it's different. */

	/*
	 * If the link is absolute or it is in the current directory, no
	 * further testing necessary.
	 */
	if (RELATIVE(targ_name) &&
	    (file_name = strrchr(link_name, '/')) != NULL) {

		/*
		 * This will be walked down to the highest directory
		 * not common to both the link and the target.
		 */
		targ_ptr = targ_name;

		/*
		 * At this point targ_name is a relative path through at
		 * least one directory.
		 */
		this_dir = targ_ptr;	/* first directory in targ_name */
		file_name++;		/* point to the name not the '/' */

		/*
		 * Scan across the pathname until we reach a different
		 * directory or the final file name.
		 */
		do {
			size_t str_size;

			next_dir = strchr(targ_ptr, '/');
			if (next_dir)
				next_dir++;	/* point to name not '/' */
			else	/* point to the end of the string */
				next_dir = targ_ptr+strlen(targ_ptr);

			/* length to compare */
			str_size = ((ptrdiff_t)next_dir - (ptrdiff_t)this_dir);

			/*
			 * If both paths begin with the same directory, then
			 * skip that common directory in both the link and
			 * the target.
			 */
			if (strncmp(this_dir, link_name, str_size) == 0) {
				/* point to the target so far */
				const_ptr = this_dir = next_dir;
				/* Skip past it in the target */
				targ_ptr = (char *)(targ_ptr+str_size);
				/* Skip past it in the link */
				link_name = (char *)(link_name+str_size);
			/*
			 * If these directories don't match then the
			 * directory above is the lowest common directory. We
			 * need to construct a relative path from the lowest
			 * child up to that directory.
			 */
			} else {
				int d = 0;
				char *dptr = link_name;

				/* Count the intermediate directories. */
				while ((dptr = strchr(dptr, '/')) != NULL) {
					dptr++;
					d++;
				}
				/*
				 * Now targ_ptr is pointing to the fork in
				 * the path and dptr is pointing to the lowest
				 * child in the link. We now insert the
				 * appropriate number of "../'s" to get to
				 * the first common directory. We'll
				 * construct this in the construction
				 * buffer.
				 */
				if (d) {
					char *tptr;

					const_ptr = tptr = construction;
					while (d--) {
						(void) strlcpy(tptr,
							"../", PATH_MAX);
						tptr += 3;
					}
					(void) strlcpy(tptr, targ_ptr,
						PATH_MAX);
				}
				break;		/* done */
			}
		} while (link_name != file_name);	/* at file name */
	}

	return (const_ptr);
}

static void
findlink(struct cfent *ept, char *path, char *svpath)
{
	struct stat	statbuf;
	struct link	*link, *new;
	char		buf[PATH_MAX];
	int		n;

	if (lstat(path, &statbuf)) {
		progerr(gettext(ERR_STAT), path);
		errflg++;
	}
	if ((statbuf.st_mode & S_IFMT) == S_IFLNK) {
		if (!iflag) {
			ept->ainfo.local = mylocal;
			ept->ftype = 's';
			n = readlink(path, buf, PATH_MAX);
			if (n <= 0) {
				progerr(gettext(ERR_RDLINK), path);
				errflg++;
				(void) strlcpy(ept->ainfo.local,
					"unknown", PATH_MAX);
			} else {
				(void) strncpy(ept->ainfo.local, buf, n);
				ept->ainfo.local[n] = '\0';
			}
		}
		return;
	}

	if (stat(path, &statbuf))
		return;
	if (statbuf.st_nlink <= 1)
		return;

	for (link = firstlink; link; link = link->next) {
		if ((statbuf.st_ino == link->ino) &&
		(statbuf.st_dev == link->dev)) {
			ept->ftype = 'l';
			ept->ainfo.local = mylocal;
			(void) strlcpy(ept->ainfo.local,
					scan_raw_ln(link->path, ept->path),
					PATH_MAX);
			return;
		}
	}
	if ((new = (struct link *)calloc(1, sizeof (struct link))) == NULL) {
		progerr(gettext(ERR_MEMORY), errno);
		exit(1);
	}

	if (firstlink) {
		lastlink->next = new;
		lastlink = new;
	} else
		firstlink = lastlink = new;

	new->path = strdup(svpath);
	new->ino = statbuf.st_ino;
	new->dev = statbuf.st_dev;
}

static void
usage(void)
{
	(void) fprintf(stderr,
	    gettext("usage: %s [-i] [-c class] [path ...]\n"), get_prog_name());
	exit(1);
	/*NOTREACHED*/
}