* Copyright 2008 Sun Microsystems, Inc.  All rights reserved.

#include <assert.h>

#include <dlfcn.h>

#include <errno.h>

#include <libzonecfg.h>

#include <link.h>

#include <string.h>

#include <strings.h>

#include <sys/list.h>

#include <sys/types.h>

#include <sys/mkdev.h>

#include <sys/mman.h>

#include <sys/mnttab.h>

#include "Pcontrol.h"

struct path_node {

	struct path_node	*pn_next;

	char			*pn_path;

};

typedef struct path_node path_node_t;

static path_node_t *

pn_push(path_node_t **pnp, char *path)

{

	path_node_t *pn;

	if ((pn = calloc(sizeof (path_node_t), 1)) == NULL)

		return (NULL);

	if ((pn->pn_path = strdup(path)) == NULL) {

		free(pn);

		return (NULL);

	}

	pn->pn_next = *pnp;

	return (*pnp = pn);

}

static void

pn_free(path_node_t **pnp)

{

	path_node_t *pn;

	while (*pnp != NULL) {

		pn = *pnp;

		*pnp = pn->pn_next;

		free(pn->pn_path);

		free(pn);

	}

}

static void

pn_free2(path_node_t **pn1, path_node_t **pn2)

{

	pn_free(pn1);

	pn_free(pn2);

}

static char *

pn_pop(path_node_t **pnp, char *path)

{

	path_node_t *pn;

	if (*pnp == NULL)

		return (NULL);

	pn = *pnp;

	*pnp = pn->pn_next;

	pn->pn_next = NULL;

	if (path == NULL) {

		pn_free(&pn);

		return (NULL);

	}

	(void) strlcpy(path, pn->pn_path, PATH_MAX);

	pn_free(&pn);

	return (path);

}

/*

 * Libzonecfg.so links against libproc, so libproc can't link against

 * libzonecfg.so.  Also, libzonecfg.so is optional and might not be

 * installed.  Hence instead of relying on linking to access libzonecfg.so,

 * we'll try dlopening it here.  This trick is borrowed from

 * libc`zone_get_id(), see that function for more detailed comments.

 */

static int

i_zone_get_zonepath(char *zone_name, char *zonepath, size_t rp_sz)

{

	typedef	int (*zone_get_zonepath_t)(char *, char *, size_t);

	static zone_get_zonepath_t zone_get_zonepath_fp = NULL;

	if (zone_get_zonepath_fp == NULL) {

		/* There's no harm in doing this multiple times. */

		void *dlhandle = dlopen("libzonecfg.so.1", RTLD_LAZY);

		void *sym = (void *)(-1);

		if (dlhandle != NULL &&

		    (sym = dlsym(dlhandle, "zone_get_zonepath")) == NULL) {

			sym = (void *)(-1);

			(void) dlclose(dlhandle);

		}

		zone_get_zonepath_fp = (zone_get_zonepath_t)sym;

	}

	/* If we've successfully loaded it, call the real function */

	if (zone_get_zonepath_fp != (zone_get_zonepath_t)(-1))

		return (zone_get_zonepath_fp(zone_name, zonepath, rp_sz));

	return (Z_NO_ZONE);

}

/*

 * Get the zone name from the core file if we have it; look up the

 * name based on the zone id if this is a live process.

 */

char *

Pzonename(struct ps_prochandle *P, char *s, size_t n)

{

	if (P->state == PS_IDLE) {

		errno = ENODATA;

		return (NULL);

	}

	if (P->state == PS_DEAD) {

		if (P->core->core_zonename == NULL) {

			errno = ENODATA;

			return (NULL);

		}

		(void) strlcpy(s, P->core->core_zonename, n);

	} else {

		if (getzonenamebyid(P->status.pr_zoneid, s, n) < 0)

			return (NULL);

		s[n - 1] = '\0';

	}

	return (s);

}

char *

Pzoneroot(struct ps_prochandle *P, char *s, size_t n)

{

	char zname[ZONENAME_MAX], zpath[PATH_MAX], tmp[PATH_MAX];

	int rv;

	if (P->zoneroot != NULL) {

		(void) strlcpy(s, P->zoneroot, n);

		return (s);

	}

	if ((Pzonename(P, zname, sizeof (zname)) == NULL) ||

	    (strcmp(zname, GLOBAL_ZONENAME) == 0)) {

		if ((P->zoneroot = strdup("")) == NULL) {

			errno = ENOMEM;

			return (NULL);

		}

		dprintf("Pzoneroot defaulting to '%s'\n", GLOBAL_ZONENAME);

		(void) strlcpy(s, P->zoneroot, n);

		return (s);

	}

	if (i_zone_get_zonepath(zname, zpath, sizeof (zpath)) != Z_OK) {

		if ((P->zoneroot = strdup("")) == NULL) {

			errno = ENOMEM;

			return (NULL);

		}

		dprintf(

		    "Pzoneroot zone not found '%s', defaulting to '%s'\n",

		    zname, GLOBAL_ZONENAME);

		(void) strlcpy(s, P->zoneroot, n);

		return (s);

	}

	(void) strlcat(zpath, "/root", sizeof (zpath));

	if ((rv = resolvepath(zpath, tmp, sizeof (tmp) - 1)) < 0) {

		if ((P->zoneroot = strdup("")) == NULL) {

			errno = ENOMEM;

			return (NULL);

		}

		dprintf(

		    "Pzoneroot can't access '%s:%s', defaulting to '%s'\n",

		    zname, zpath, GLOBAL_ZONENAME);

		(void) strlcpy(s, P->zoneroot, n);

		return (s);

	}

	tmp[rv] = '\0';

	(void) strlcpy(zpath, tmp, sizeof (zpath));

	if ((P->zoneroot = strdup(zpath)) == NULL) {

		errno = ENOMEM;

		return (NULL);

	}

	dprintf("Pzoneroot found zone root '%s:%s'\n", zname, zpath);

	(void) strlcpy(s, P->zoneroot, n);

	return (s);

}

/*

 * Plofspath() takes a path, "path",  and removes any lofs components from

 * that path.  The resultant path (if different from the starting path)

 * is placed in "s", which is limited to "n" characters, and the return

 * value is the pointer s.  If there are no lofs components in the path

 * the NULL is returned and s is not modified.  It's ok for "path" and

 * "s" to be the same pointer.  (ie, the results can be stored directly

 * in the input buffer.)  The path that is passed in must be an absolute

 * path.

 *

 * Example:

 *	if "path" == "/foo/bar", and "/candy/" is lofs mounted on "/foo/"

 *	then "/candy/bar/" will be written into "s" and "s" will be returned.

 */

char *

Plofspath(const char *path, char *s, size_t n)

{

	char tmp[PATH_MAX + 1];

	struct mnttab mt, mt_find;

	FILE *fp;

	char *p, *p2;

	int rv;

	dprintf("Plofspath path '%s'\n", path);

	/* We only deal with absolute paths */

	if (path[0] != '/')

		return (NULL);

	/* Open /etc/mnttab */

	if ((fp = fopen(MNTTAB, "r")) == NULL)

		return (NULL);

	/* Make a copy of the path so that we can muck with it */

	(void) strlcpy(tmp, path, sizeof (tmp) - 1);

	/*

	 * Use resolvepath() to make sure there are no consecutive or

	 * trailing '/'s in the path.

	 */

	if ((rv = resolvepath(tmp, tmp, sizeof (tmp) - 1)) >= 0)

		tmp[rv] = '\0';

	/*

	 * So now we're going to search the path for any components that

	 * might be lofs mounts.  We'll start out search from the full

	 * path and then step back through each parent directly till

	 * we reach the root.  If we find a lofs mount point in the path

	 * then we'll replace the initial portion of the path (up

	 * to that mount point) with the source of that mount point

	 * and then start our search over again.

	 *

	 * Here's some of the variables we're going to use:

	 *

	 *	tmp - A pointer to our working copy of the path.  Sometimes

	 *		this path will be divided into two strings by a

	 *		'\0' (NUL) character.  The first string is the

	 *		component we're currently checking and the second

	 *		string is the path components we've already checked.

	 *

	 *	p - A pointer to the last '/' seen in the string.

	 *

	 *	p[1] - A pointer to the component of the string we've already

	 *		checked.

	 *

	 * Initially, p will point to the end of our path and p[1] will point

	 * to an extra '\0' (NUL) that we'll append to the end of the string.

	 * (This is why we declared tmp with a size of PATH_MAX + 1).

	 */

	p = &tmp[strlen(tmp)];

	p[1] = '\0';

	for (;;) {

		/* Check if tmp is a mount point */

		rewind(fp);

		bzero(&mt_find, sizeof (mt_find));

		mt_find.mnt_mountp = tmp;

		rv = getmntany(fp, &mt, &mt_find);

		/* We only care about lofs mount points */

		if ((rv == 0) && (strcmp(mt.mnt_fstype, "lofs") == 0)) {

			char tmp2[PATH_MAX + 1];

			/*

			 * We found a lofs mount.  Update the path that we're

			 * checking and start over.  This means append the

			 * portion of the path we've already checked to the

			 * source of the lofs mount and re-start this entire

			 * lofs resolution loop.  Use resolvepath() to make

			 * sure there are no consecutive or trailing '/'s

			 * in the path.

			 */

			(void) strlcpy(tmp2, mt.mnt_special, sizeof (tmp2) - 1);

			(void) strlcat(tmp2, "/", sizeof (tmp2) - 1);

			(void) strlcat(tmp2, &p[1], sizeof (tmp2) - 1);

			(void) strlcpy(tmp, tmp2, sizeof (tmp) - 1);

			if ((rv = resolvepath(tmp, tmp, sizeof (tmp) - 1)) >= 0)

				tmp[rv] = '\0';

			p = &tmp[strlen(tmp)];

			p[1] = '\0';

			continue;

		}

		/* No lofs mount found */

		if ((p2 = strrchr(tmp, '/')) == NULL) {

			char tmp2[PATH_MAX];

			/*

			 * We know that tmp was an absolute path, so if we

			 * made it here we know that (p == tmp) and that

			 * (*p == '\0').  This means that we've managed

			 * to check the whole path and so we're done.

			 */

			assert(p == tmp);

			assert(p[0] == '\0');

			(void) fclose(fp);

			/* Restore the leading '/' in the path */

			p[0] = '/';

			if (strcmp(tmp, path) == 0) {

				/* The path didn't change */

				return (NULL);

			}

			/*

			 * It's possible that lofs source path we just

			 * obtained contains a symbolic link.  Use

			 * resolvepath() to clean it up.

			 */

			(void) strlcpy(tmp2, tmp, sizeof (tmp2));

			if ((rv = resolvepath(tmp, tmp, sizeof (tmp) - 1)) >= 0)

				tmp[rv] = '\0';

			/*

			 * It's always possible that our lofs source path is

			 * actually another lofs mount.  So call ourselves

			 * recursively to resolve that path.

			 */

			(void) Plofspath(tmp, tmp, PATH_MAX);

			/* Copy out our final resolved lofs source path */

			(void) strlcpy(s, tmp, n);

			dprintf("Plofspath path result '%s'\n", s);

			return (s);

		}

		/*

		 * So the path we just checked is not a lofs mount.  Next we

		 * want to check the parent path component for a lofs mount.

		 *

		 * First, restore any '/' that we replaced with a '\0' (NUL).

		 * We can determine if we should do this by looking at p[1].

		 * If p[1] points to a '\0' (NUL) then we know that p points

		 * to the end of the string and there is no '/' to restore.

		 * if p[1] doesn't point to a '\0' (NUL) then it points to

		 * the part of the path that we've already verified so there

		 * is a '/' to restore.

		 */

		if (p[1] != '\0')

			p[0] = '/';

		/*

		 * Second, replace the last '/' in the part of the path

		 * that we've already checked with a '\0' (NUL) so that

		 * when we loop around we check the parent component of the

		 * path.

		 */

		p2[0] = '\0';

		p = p2;

	}

	/*NOTREACHED*/

}

/*

 * Pzonepath() - Way too much code to attempt to derive the full path of

 * an object within a zone.

 *

 * Pzonepath() takes a path and attempts to resolve it relative to the

 * root associated with the current process handle.  If it fails it will

 * not update the results string.  It is safe to specify the same pointer

 * for the file string and the results string.

 *

 * Doing this resolution is more difficult than it initially sounds.

 * We can't simply append the file path to the zone root, because in

 * a root directory, '..' is treated the same as '.'.  Also, symbolic

 * links that specify an absolute path need to be interpreted relative

 * to the zone root.

 *

 * It seems like perhaps we could do a chroot(<zone root>) followed by a

 * resolvepath().  But we can't do this because chroot requires special

 * privileges and affects the entire process.  Perhaps if there was a

 * special version of resolvepath() which took an addition root path

 * we could use that, but this isn't ideal either.  The reason is

 * that we want to have special handling for native paths.  (A native path

 * is a path that begins with "/native/" or "/.SUNWnative/".)  Native

 * paths could be passed explicity to this function or could be embedded

 * in a symlink that is part of the path passed into this function.

 * These paths are always lofs mounts of global zone paths, but lofs

 * mounts only exist when a zone is booted.  So if we were to try to do

 * a resolvepath() on a native path when the zone wasn't booted the

 * resolvepath() would fail even though we know that the components

 * exists in the global zone.

 *

 * Given all these constraints, we just implement a path walking function

 * that resolves a file path relative to a zone root by manually inspecting

 * each of the path components and verifying its existence.  This means that

 * we must have access to the zone and that all the components of the

 * path must exist for this operation to succeed.

 */

char *

Pzonepath(struct ps_prochandle *P, const char *path, char *s, size_t n)

{

	char zroot[PATH_MAX], zpath[PATH_MAX], tmp[PATH_MAX], link[PATH_MAX];

	path_node_t *pn_stack = NULL, *pn_links = NULL, *pn;

	struct stat64 sb;

	char *p;

	int i, rv;

	dprintf("Pzonepath lookup '%s'\n", path);

	/* First lookup the zone root */

	if (Pzoneroot(P, zroot, sizeof (zroot)) == NULL)

		return (NULL);

	/*

	 * Make a temporary copy of the path specified.

	 * If it's a relative path then make it into an absolute path.

	 */

	tmp[0] = '\0';

	if (path[0] != '/')

		(void) strlcat(tmp, "/", sizeof (tmp));

	(void) strlcat(tmp, path, sizeof (tmp));

	/*

	 * If the path that was passed in is the zone root, we're done.

	 * If the path that was passed in already contains the zone root

	 * then strip the zone root out and verify the rest of the path.

	 */

	if (strcmp(tmp, zroot) == 0) {

		(void) Plofspath(zroot, zroot, sizeof (zroot));

		dprintf("Pzonepath found zone path (1) '%s'\n", zroot);

		(void) strlcpy(s, zroot, n);

		return (s);

	}

	i = strlen(zroot);

	if ((strncmp(tmp, zroot, i) == 0) && (tmp[i] == '/'))

		(void) memmove(tmp, tmp + i, strlen(tmp + i) + 1);

	/* If no path is passed in, then it maps to the zone root */

	if (strlen(tmp) == 0) {

		(void) Plofspath(zroot, zroot, sizeof (zroot));

		dprintf("Pzonepath found zone path (2) '%s'\n", zroot);

		(void) strlcpy(s, zroot, n);

		return (s);

	}

	/*

	 * Push each path component that we plan to verify onto a stack of

	 * path components, with parent components at the top of the stack.

	 * So for example, if we're going to verify the path /foo/bar/bang

	 * then our stack will look like:

	 *	foo	(top)

	 *	bar