usr/src/lib/libtsol/common/getpathbylabel.c - illumos-gate - Gitiles

 /*
  * 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 2006 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */

 #pragma ident	"%Z%%M%	%I%	%E% SMI"


 /*
  *	Name:		getpathbylabel.c
  *
  *	Description:	Returns the global zone pathname corresponding
  *			to the specified label. The pathname does
  *			not need to match an existing file system object.
  *
  */
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <tsol/label.h>
 #include <stdlib.h>
 #include <zone.h>
 #include <sys/mntent.h>
 #include <sys/mnttab.h>
 #include <stdarg.h>

 /*
  * This structure is used to chain mntent structures into a list
  * and to cache stat information for each member of the list.
  */
 struct mntlist {
 	struct mnttab	*mntl_mnt;
 	struct mntlist	*mntl_next;
 };


 /*
  * Return a pointer to the trailing suffix of full that follows the prefix
  * given by pref.  If pref isn't a prefix of full, return NULL.  Apply
  * pathname semantics to the prefix test, so that pref must match at a
  * component boundary.
  */
 static char *
 pathsuffix(char *full, char *pref)
 {
 	int preflen;

 	if (full == NULL || pref == NULL)
 		return (NULL);

 	preflen = strlen(pref);
 	if (strncmp(pref, full, preflen) != 0)
 		return (NULL);

 	/*
 	 * pref is a substring of full.  To be a subpath, it cannot cover a
 	 * partial component of full.  The last clause of the test handles the
 	 * special case of the root.
 	 */
 	if (full[preflen] != '\0' && full[preflen] != '/' && preflen > 1)
 		return (NULL);

 	if (preflen == 1 && full[0] == '/')
 		return (full);
 	else
 		return (full + preflen);
 }

 /*
  * Return zero iff the path named by sub is a leading subpath
  * of the path named by full.
  *
  * Treat null paths as matching nothing.
  */
 static int
 subpath(char *full, char *sub)
 {
 	return (pathsuffix(full, sub) == NULL);
 }

 static void
 tsol_mnt_free(struct mnttab *mnt)
 {
 	if (mnt->mnt_special)
 		free(mnt->mnt_special);
 	if (mnt->mnt_mountp)
 		free(mnt->mnt_mountp);
 	if (mnt->mnt_fstype)
 		free(mnt->mnt_fstype);
 	if (mnt->mnt_mntopts)
 		free(mnt->mnt_mntopts);
 	free(mnt);
 }

 static void
 tsol_mlist_free(struct mntlist *mlist)
 {
 	struct mntlist *mlp;

 	for (mlp = mlist; mlp; mlp = mlp->mntl_next) {
 		struct mnttab *mnt = mlp->mntl_mnt;

 		if (mnt)
 			tsol_mnt_free(mnt);
 		free(mlp);
 	}
 }

 static struct mnttab *
 mntdup(struct mnttab *mnt)
 {
 	struct mnttab *new;

 	new = (struct mnttab *)malloc(sizeof (*new));
 	if (new == NULL)
 		return (NULL);

 	new->mnt_special = NULL;
 	new->mnt_mountp = NULL;
 	new->mnt_fstype = NULL;
 	new->mnt_mntopts = NULL;

 	new->mnt_special = strdup(mnt->mnt_special);
 	if (new->mnt_special == NULL) {
 		tsol_mnt_free(new);
 		return (NULL);
 	}
 	new->mnt_mountp = strdup(mnt->mnt_mountp);
 	if (new->mnt_mountp == NULL) {
 		tsol_mnt_free(new);
 		return (NULL);
 	}
 	new->mnt_fstype = strdup(mnt->mnt_fstype);
 	if (new->mnt_fstype == NULL) {
 		tsol_mnt_free(new);
 		return (NULL);
 	}
 	new->mnt_mntopts = strdup(mnt->mnt_mntopts);
 	if (new->mnt_mntopts == NULL) {
 		tsol_mnt_free(new);
 		return (NULL);
 	}
 	return (new);
 }

 static struct mntlist *
 tsol_mkmntlist(void)
 {
 	FILE *mounted;
 	struct mntlist *mntl;
 	struct mntlist *mntst = NULL;
 	struct mnttab mnt;

 	if ((mounted = fopen(MNTTAB, "r")) == NULL) {
 		perror(MNTTAB);
 		return (NULL);
 	}
 	resetmnttab(mounted);
 	while (getmntent(mounted, &mnt) == NULL) {
 		mntl = (struct mntlist *)malloc(sizeof (*mntl));
 		if (mntl == NULL) {
 			tsol_mlist_free(mntst);
 			mntst = NULL;
 			break;
 		}
 		mntl->mntl_mnt = mntdup((struct mnttab *)(&mnt));
 		if (mntl->mntl_mnt == NULL) {
 			tsol_mlist_free(mntst);
 			mntst = NULL;
 			break;
 		}
 		mntl->mntl_next = mntst;
 		mntst = mntl;
 	}
 	(void) fclose(mounted);
 	return (mntst);
 }

 /*
  * This function attempts to convert local zone NFS mounted pathnames
  * into equivalent global zone NFS mounted pathnames. At present
  * it only works for automounted filesystems. It depends on the
  * assumption that both the local and global zone automounters
  * share the same nameservices. It also assumes that any automount
  * map used by a local zone is available to the global zone automounter.
  *
  * The algorithm used consists of three phases.
  *
  * 1. The local zone's mnttab is searched to find the automount map
  *    with the closest matching mountpath.
  *
  * 2. The matching autmount map name is looked up in the global zone's
  *    mnttab to determine the path where it should be mounted in the
  *    global zone.
  *
  * 3. A pathname covered by an appropiate autofs trigger mount in
  *    the global zone is generated as the resolved pathname
  *
  * Among the things that can go wrong is that global zone doesn't have
  * a matching automount map or the mount was not done via the automounter.
  * Either of these cases return a NULL path.
  */
 #define	ZONE_OPT "zone="
 static int
 getnfspathbyautofs(struct mntlist *mlist, zoneid_t zoneid,
     struct mnttab *autofs_mnt, char *globalpath, char *zonepath, int global_len)
 {
 	struct mntlist *mlp;
 	char zonematch[ZONENAME_MAX + 20];
 	char zonename[ZONENAME_MAX];
 	int  longestmatch;
 	struct	mnttab	*mountmatch;

 	if (autofs_mnt) {
 		mountmatch = autofs_mnt;
 		longestmatch = strlen(mountmatch->mnt_mountp);
 	} else {
 		/*
 		 * First we need to get the zonename to look for
 		 */
 		if (zone_getattr(zoneid, ZONE_ATTR_NAME, zonename,
 		    ZONENAME_MAX) == -1) {
 			return (0);
 		}

 		(void) strncpy(zonematch, ZONE_OPT, sizeof (zonematch));
 		(void) strlcat(zonematch, zonename, sizeof (zonematch));

 		/*
 		 * Find the best match for an automount map that
 		 * corresponds to the local zone's pathname
 		 */
 		longestmatch = 0;
 		for (mlp = mlist; mlp; mlp = mlp->mntl_next) {
 			struct mnttab *mnt = mlp->mntl_mnt;
 			int	len;
 			int	matchfound;
 			char	*token;
 			char	*lasts;
 			char	mntopts[MAXPATHLEN];

 			if (subpath(globalpath, mnt->mnt_mountp) != 0)
 				continue;
 			if (strcmp(mnt->mnt_fstype, MNTTYPE_AUTOFS))
 				continue;

 			matchfound = 0;
 			(void) strncpy(mntopts, mnt->mnt_mntopts, MAXPATHLEN);
 			if ((token = strtok_r(mntopts, ",", &lasts)) != NULL) {
 				if (strcmp(token, zonematch) == 0) {
 					matchfound = 1;
 				} else while ((token = strtok_r(NULL, ",",
 				    &lasts)) != NULL) {
 					if (strcmp(token, zonematch) == 0) {
 						matchfound = 1;
 						break;
 					}
 				}
 			}
 			if (matchfound) {
 				len = strlen(mnt->mnt_mountp);
 				if (len > longestmatch) {
 					mountmatch = mnt;
 					longestmatch = len;
 				}
 			}
 		}
 	}
 	if (longestmatch == 0) {
 		return (0);
 	} else {
 		/*
 		 * Now we may have found the corresponding autofs mount
 		 * Try to find the matching global zone autofs entry
 		 */

 		for (mlp = mlist; mlp; mlp = mlp->mntl_next) {
 			char p[MAXPATHLEN];
 			size_t zp_len;
 			size_t mp_len;

 			struct mnttab *mnt = mlp->mntl_mnt;

 			if (strcmp(mountmatch->mnt_special,
 			    mnt->mnt_special) != 0)
 				continue;
 			if (strcmp(mnt->mnt_fstype, MNTTYPE_AUTOFS))
 				continue;
 			if (strstr(mnt->mnt_mntopts, ZONE_OPT) != NULL)
 				continue;
 			/*
 			 * OK, we have a matching global zone automap
 			 * so adjust the path for the global zone.
 			 */
 			zp_len = strlen(zonepath);
 			mp_len = strlen(mnt->mnt_mountp);
 			(void) strncpy(p, globalpath + zp_len, MAXPATHLEN);
 			/*
 			 * If both global zone and zone-relative
 			 * mountpoint match, just use the same pathname
 			 */
 			if (strncmp(mnt->mnt_mountp, p, mp_len) == 0) {
 				(void) strncpy(globalpath, p, global_len);
 				return (1);
 			} else {
 				(void) strncpy(p, globalpath, MAXPATHLEN);
 				(void) strncpy(globalpath, mnt->mnt_mountp,
 				    global_len);
 				(void) strlcat(globalpath,
 				    p + strlen(mountmatch->mnt_mountp),
 				    global_len);
 				return (1);
 			}
 		}
 		return (0);
 	}
 }

 	/*
 	 * Find the pathname for the entry in mlist that corresponds to the
 	 * file named by path (i.e., that names a mount table entry for the
 	 * file system in which path lies).
 	 *
 	 * Return 0 is there an error.
 	 */
 	static int
 	getglobalpath(const char *path, zoneid_t zoneid, struct mntlist *mlist,
 	    char *globalpath)
 	{
 		struct mntlist *mlp;
 		char		lofspath[MAXPATHLEN];
 		char		zonepath[MAXPATHLEN];
 		int		longestmatch;
 		struct	mnttab	*mountmatch;

 		if (zoneid != GLOBAL_ZONEID) {
 			char	*prefix;

 			if ((prefix = getzonerootbyid(zoneid)) == NULL) {
 				return (0);
 			}
 			(void) strncpy(zonepath, prefix, MAXPATHLEN);
 			(void) strlcpy(globalpath, prefix, MAXPATHLEN);
 			(void) strlcat(globalpath, path, MAXPATHLEN);
 			free(prefix);
 		} else {
 			(void) strlcpy(globalpath, path, MAXPATHLEN);
 		}

 		for (;;) {
 			longestmatch = 0;
 			for (mlp = mlist; mlp; mlp = mlp->mntl_next) {
 				struct mnttab *mnt = mlp->mntl_mnt;
 				int	len;

 			if (subpath(globalpath, mnt->mnt_mountp) != 0)
 				continue;
 			len = strlen(mnt->mnt_mountp);
 			if (len > longestmatch) {
 				mountmatch = mnt;
 				longestmatch = len;
 			}
 		}
 		/*
 		 * Handle interesting mounts.
 		 */
 		if ((strcmp(mountmatch->mnt_fstype, MNTTYPE_NFS) == 0) ||
 		    (strcmp(mountmatch->mnt_fstype, MNTTYPE_AUTOFS) == 0)) {
 			if (zoneid > GLOBAL_ZONEID) {
 				struct mnttab *m = NULL;

 				if (strcmp(mountmatch->mnt_fstype,
 				    MNTTYPE_AUTOFS) == 0)
 					m = mountmatch;
 				if (getnfspathbyautofs(mlist, zoneid, m,
 				    globalpath, zonepath, MAXPATHLEN) == 0) {
 					return (0);
 				}
 			}
 			break;
 		} else if (strcmp(mountmatch->mnt_fstype, MNTTYPE_LOFS) == 0) {
 			/*
 			 * count up what's left
 			 */
 			int	remainder;

 			remainder = strlen(globalpath) - longestmatch;
 			if (remainder > 0) {
 				path = pathsuffix(globalpath,
 				    mountmatch->mnt_mountp);
 				(void) strlcpy(lofspath, path, MAXPATHLEN);
 			}
 			(void) strlcpy(globalpath, mountmatch->mnt_special,
 			    MAXPATHLEN);
 			if (remainder > 0) {
 				(void) strlcat(globalpath, lofspath,
 				    MAXPATHLEN);
 			}
 		} else {
 			if ((zoneid > GLOBAL_ZONEID) &&
 			    (strncmp(path, "/home/", strlen("/home/")) == 0)) {
 				char zonename[ZONENAME_MAX];

 				/*
 				 * If this is a cross-zone reference to
 				 * a home directory, it must be corrected.
 				 * We should only get here if the zone's
 				 * automounter hasn't yet mounted its
 				 * autofs trigger on /home.
 				 *
 				 * Since it is likely to do so in the
 				 * future, we will assume that the global
 				 * zone already has an equivalent autofs
 				 * mount established. By convention,
 				 * this should be mounted at the
 				 * /zone/<zonename>
 				 */

 				if (zone_getattr(zoneid, ZONE_ATTR_NAME,
 				    zonename, ZONENAME_MAX) == -1) {
 					return (0);
 				} else {
 					(void) snprintf(globalpath, MAXPATHLEN,
 					    "/zone/%s%s", zonename, path);
 				}
 			}
 			break;
 		}
 	}
 	return (1);
 }


 /*
  * This function is only useful for global zone callers
  * It uses the global zone mnttab to translate local zone pathnames
  * into global zone pathnames.
  */
 char *
 getpathbylabel(const char *path_name, char *resolved_path, size_t bufsize,
     const bslabel_t *sl) {
 	char		ret_path[MAXPATHLEN];	/* pathname to return */
 	zoneid_t	zoneid;
 	struct mntlist *mlist;

 	if (getzoneid() != GLOBAL_ZONEID) {
 		errno = EINVAL;
 		return (NULL);
 	}

 	if (path_name[0] != '/') {		/* need absolute pathname */
 		errno = EINVAL;
 		return (NULL);
 	}

 	if (resolved_path == NULL) {
 		errno = EINVAL;
 		return (NULL);
 	}

 	if ((zoneid = getzoneidbylabel(sl)) == -1)
 		return (NULL);

 	/*
 	 * Construct the list of mounted file systems.
 	 */

 	if ((mlist = tsol_mkmntlist()) == NULL) {
 		return (NULL);
 	}
 	if (getglobalpath(path_name, zoneid, mlist, ret_path) == 0) {
 		tsol_mlist_free(mlist);
 		return (NULL);
 	}
 	tsol_mlist_free(mlist);
 	if (strlen(ret_path) >= bufsize) {
 		errno = EFAULT;
 		return (NULL);
 	}
 	return (strcpy(resolved_path, ret_path));
 } /* end getpathbylabel() */
	/*
	* 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 2006 Sun Microsystems, Inc. All rights reserved.
	* Use is subject to license terms.
	*/

	#pragma ident "%Z%%M% %I% %E% SMI"


	/*
	* Name: getpathbylabel.c
	*
	* Description: Returns the global zone pathname corresponding
	* to the specified label. The pathname does
	* not need to match an existing file system object.
	*
	*/
	#include <stdio.h>
	#include <string.h>
	#include <unistd.h>
	#include <errno.h>
	#include <sys/types.h>
	#include <tsol/label.h>
	#include <stdlib.h>
	#include <zone.h>
	#include <sys/mntent.h>
	#include <sys/mnttab.h>
	#include <stdarg.h>

	/*
	* This structure is used to chain mntent structures into a list
	* and to cache stat information for each member of the list.
	*/
	struct mntlist {
	struct mnttab *mntl_mnt;
	struct mntlist *mntl_next;
	};


	/*
	* Return a pointer to the trailing suffix of full that follows the prefix
	* given by pref. If pref isn't a prefix of full, return NULL. Apply
	* pathname semantics to the prefix test, so that pref must match at a
	* component boundary.
	*/
	static char *
	pathsuffix(char full, char pref)
	{
	int preflen;

	if (full == NULL \|\| pref == NULL)
	return (NULL);

	preflen = strlen(pref);
	if (strncmp(pref, full, preflen) != 0)
	return (NULL);

	/*
	* pref is a substring of full. To be a subpath, it cannot cover a
	* partial component of full. The last clause of the test handles the
	* special case of the root.
	*/
	if (full[preflen] != '\0' && full[preflen] != '/' && preflen > 1)
	return (NULL);

	if (preflen == 1 && full[0] == '/')
	return (full);
	else
	return (full + preflen);
	}

	/*
	* Return zero iff the path named by sub is a leading subpath
	* of the path named by full.
	*
	* Treat null paths as matching nothing.
	*/
	static int
	subpath(char full, char sub)
	{
	return (pathsuffix(full, sub) == NULL);
	}

	static void
	tsol_mnt_free(struct mnttab *mnt)
	{
	if (mnt->mnt_special)
	free(mnt->mnt_special);
	if (mnt->mnt_mountp)
	free(mnt->mnt_mountp);
	if (mnt->mnt_fstype)
	free(mnt->mnt_fstype);
	if (mnt->mnt_mntopts)
	free(mnt->mnt_mntopts);
	free(mnt);
	}

	static void
	tsol_mlist_free(struct mntlist *mlist)
	{
	struct mntlist *mlp;

	for (mlp = mlist; mlp; mlp = mlp->mntl_next) {
	struct mnttab *mnt = mlp->mntl_mnt;

	if (mnt)
	tsol_mnt_free(mnt);
	free(mlp);
	}
	}

	static struct mnttab *
	mntdup(struct mnttab *mnt)
	{
	struct mnttab *new;

	new = (struct mnttab )malloc(sizeof (new));
	if (new == NULL)
	return (NULL);

	new->mnt_special = NULL;
	new->mnt_mountp = NULL;
	new->mnt_fstype = NULL;
	new->mnt_mntopts = NULL;

	new->mnt_special = strdup(mnt->mnt_special);
	if (new->mnt_special == NULL) {
	tsol_mnt_free(new);
	return (NULL);
	}
	new->mnt_mountp = strdup(mnt->mnt_mountp);
	if (new->mnt_mountp == NULL) {
	tsol_mnt_free(new);
	return (NULL);
	}
	new->mnt_fstype = strdup(mnt->mnt_fstype);
	if (new->mnt_fstype == NULL) {
	tsol_mnt_free(new);
	return (NULL);
	}
	new->mnt_mntopts = strdup(mnt->mnt_mntopts);
	if (new->mnt_mntopts == NULL) {
	tsol_mnt_free(new);
	return (NULL);
	}
	return (new);
	}

	static struct mntlist *
	tsol_mkmntlist(void)
	{
	FILE *mounted;
	struct mntlist *mntl;
	struct mntlist *mntst = NULL;
	struct mnttab mnt;

	if ((mounted = fopen(MNTTAB, "r")) == NULL) {
	perror(MNTTAB);
	return (NULL);
	}
	resetmnttab(mounted);
	while (getmntent(mounted, &mnt) == NULL) {
	mntl = (struct mntlist )malloc(sizeof (mntl));
	if (mntl == NULL) {
	tsol_mlist_free(mntst);
	mntst = NULL;
	break;
	}
	mntl->mntl_mnt = mntdup((struct mnttab *)(&mnt));
	if (mntl->mntl_mnt == NULL) {
	tsol_mlist_free(mntst);
	mntst = NULL;
	break;
	}
	mntl->mntl_next = mntst;
	mntst = mntl;
	}
	(void) fclose(mounted);
	return (mntst);
	}

	/*
	* This function attempts to convert local zone NFS mounted pathnames
	* into equivalent global zone NFS mounted pathnames. At present
	* it only works for automounted filesystems. It depends on the
	* assumption that both the local and global zone automounters
	* share the same nameservices. It also assumes that any automount
	* map used by a local zone is available to the global zone automounter.
	*
	* The algorithm used consists of three phases.
	*
	* 1. The local zone's mnttab is searched to find the automount map
	* with the closest matching mountpath.
	*
	* 2. The matching autmount map name is looked up in the global zone's
	* mnttab to determine the path where it should be mounted in the
	* global zone.
	*
	* 3. A pathname covered by an appropiate autofs trigger mount in
	* the global zone is generated as the resolved pathname
	*
	* Among the things that can go wrong is that global zone doesn't have
	* a matching automount map or the mount was not done via the automounter.
	* Either of these cases return a NULL path.
	*/
	#define ZONE_OPT "zone="
	static int
	getnfspathbyautofs(struct mntlist *mlist, zoneid_t zoneid,
	struct mnttab autofs_mnt, char globalpath, char *zonepath, int global_len)
	{
	struct mntlist *mlp;
	char zonematch[ZONENAME_MAX + 20];
	char zonename[ZONENAME_MAX];
	int longestmatch;
	struct mnttab *mountmatch;

	if (autofs_mnt) {
	mountmatch = autofs_mnt;
	longestmatch = strlen(mountmatch->mnt_mountp);
	} else {
	/*
	* First we need to get the zonename to look for
	*/
	if (zone_getattr(zoneid, ZONE_ATTR_NAME, zonename,
	ZONENAME_MAX) == -1) {
	return (0);
	}

	(void) strncpy(zonematch, ZONE_OPT, sizeof (zonematch));
	(void) strlcat(zonematch, zonename, sizeof (zonematch));

	/*
	* Find the best match for an automount map that
	* corresponds to the local zone's pathname
	*/
	longestmatch = 0;
	for (mlp = mlist; mlp; mlp = mlp->mntl_next) {
	struct mnttab *mnt = mlp->mntl_mnt;
	int len;
	int matchfound;
	char *token;
	char *lasts;
	char mntopts[MAXPATHLEN];

	if (subpath(globalpath, mnt->mnt_mountp) != 0)
	continue;
	if (strcmp(mnt->mnt_fstype, MNTTYPE_AUTOFS))
	continue;

	matchfound = 0;
	(void) strncpy(mntopts, mnt->mnt_mntopts, MAXPATHLEN);
	if ((token = strtok_r(mntopts, ",", &lasts)) != NULL) {
	if (strcmp(token, zonematch) == 0) {
	matchfound = 1;
	} else while ((token = strtok_r(NULL, ",",
	&lasts)) != NULL) {
	if (strcmp(token, zonematch) == 0) {
	matchfound = 1;
	break;
	}
	}
	}
	if (matchfound) {
	len = strlen(mnt->mnt_mountp);
	if (len > longestmatch) {
	mountmatch = mnt;
	longestmatch = len;
	}
	}
	}
	}
	if (longestmatch == 0) {
	return (0);
	} else {
	/*
	* Now we may have found the corresponding autofs mount
	* Try to find the matching global zone autofs entry
	*/

	for (mlp = mlist; mlp; mlp = mlp->mntl_next) {
	char p[MAXPATHLEN];
	size_t zp_len;
	size_t mp_len;

	struct mnttab *mnt = mlp->mntl_mnt;

	if (strcmp(mountmatch->mnt_special,
	mnt->mnt_special) != 0)
	continue;
	if (strcmp(mnt->mnt_fstype, MNTTYPE_AUTOFS))
	continue;
	if (strstr(mnt->mnt_mntopts, ZONE_OPT) != NULL)
	continue;
	/*
	* OK, we have a matching global zone automap
	* so adjust the path for the global zone.
	*/
	zp_len = strlen(zonepath);
	mp_len = strlen(mnt->mnt_mountp);
	(void) strncpy(p, globalpath + zp_len, MAXPATHLEN);
	/*
	* If both global zone and zone-relative
	* mountpoint match, just use the same pathname
	*/
	if (strncmp(mnt->mnt_mountp, p, mp_len) == 0) {
	(void) strncpy(globalpath, p, global_len);
	return (1);
	} else {
	(void) strncpy(p, globalpath, MAXPATHLEN);
	(void) strncpy(globalpath, mnt->mnt_mountp,
	global_len);
	(void) strlcat(globalpath,
	p + strlen(mountmatch->mnt_mountp),
	global_len);
	return (1);
	}
	}
	return (0);
	}
	}

	/*
	* Find the pathname for the entry in mlist that corresponds to the
	* file named by path (i.e., that names a mount table entry for the
	* file system in which path lies).
	*
	* Return 0 is there an error.
	*/
	static int
	getglobalpath(const char path, zoneid_t zoneid, struct mntlist mlist,
	char *globalpath)
	{
	struct mntlist *mlp;
	char lofspath[MAXPATHLEN];
	char zonepath[MAXPATHLEN];
	int longestmatch;
	struct mnttab *mountmatch;

	if (zoneid != GLOBAL_ZONEID) {
	char *prefix;

	if ((prefix = getzonerootbyid(zoneid)) == NULL) {
	return (0);
	}
	(void) strncpy(zonepath, prefix, MAXPATHLEN);
	(void) strlcpy(globalpath, prefix, MAXPATHLEN);
	(void) strlcat(globalpath, path, MAXPATHLEN);
	free(prefix);
	} else {
	(void) strlcpy(globalpath, path, MAXPATHLEN);
	}

	for (;;) {
	longestmatch = 0;
	for (mlp = mlist; mlp; mlp = mlp->mntl_next) {
	struct mnttab *mnt = mlp->mntl_mnt;
	int len;

	if (subpath(globalpath, mnt->mnt_mountp) != 0)
	continue;
	len = strlen(mnt->mnt_mountp);
	if (len > longestmatch) {
	mountmatch = mnt;
	longestmatch = len;
	}
	}
	/*
	* Handle interesting mounts.
	*/
	if ((strcmp(mountmatch->mnt_fstype, MNTTYPE_NFS) == 0) \|\|
	(strcmp(mountmatch->mnt_fstype, MNTTYPE_AUTOFS) == 0)) {
	if (zoneid > GLOBAL_ZONEID) {
	struct mnttab *m = NULL;

	if (strcmp(mountmatch->mnt_fstype,
	MNTTYPE_AUTOFS) == 0)
	m = mountmatch;
	if (getnfspathbyautofs(mlist, zoneid, m,
	globalpath, zonepath, MAXPATHLEN) == 0) {
	return (0);
	}
	}
	break;
	} else if (strcmp(mountmatch->mnt_fstype, MNTTYPE_LOFS) == 0) {
	/*
	* count up what's left
	*/
	int remainder;

	remainder = strlen(globalpath) - longestmatch;
	if (remainder > 0) {
	path = pathsuffix(globalpath,
	mountmatch->mnt_mountp);
	(void) strlcpy(lofspath, path, MAXPATHLEN);
	}
	(void) strlcpy(globalpath, mountmatch->mnt_special,
	MAXPATHLEN);
	if (remainder > 0) {
	(void) strlcat(globalpath, lofspath,
	MAXPATHLEN);
	}
	} else {
	if ((zoneid > GLOBAL_ZONEID) &&
	(strncmp(path, "/home/", strlen("/home/")) == 0)) {
	char zonename[ZONENAME_MAX];

	/*
	* If this is a cross-zone reference to
	* a home directory, it must be corrected.
	* We should only get here if the zone's
	* automounter hasn't yet mounted its
	* autofs trigger on /home.
	*
	* Since it is likely to do so in the
	* future, we will assume that the global
	* zone already has an equivalent autofs
	* mount established. By convention,
	* this should be mounted at the
	* /zone/<zonename>
	*/

	if (zone_getattr(zoneid, ZONE_ATTR_NAME,
	zonename, ZONENAME_MAX) == -1) {
	return (0);
	} else {
	(void) snprintf(globalpath, MAXPATHLEN,
	"/zone/%s%s", zonename, path);
	}
	}
	break;
	}
	}
	return (1);
	}


	/*
	* This function is only useful for global zone callers
	* It uses the global zone mnttab to translate local zone pathnames
	* into global zone pathnames.
	*/
	char *
	getpathbylabel(const char path_name, char resolved_path, size_t bufsize,
	const bslabel_t *sl) {
	char ret_path[MAXPATHLEN]; /* pathname to return */
	zoneid_t zoneid;
	struct mntlist *mlist;

	if (getzoneid() != GLOBAL_ZONEID) {
	errno = EINVAL;
	return (NULL);
	}

	if (path_name[0] != '/') { /* need absolute pathname */
	errno = EINVAL;
	return (NULL);
	}

	if (resolved_path == NULL) {
	errno = EINVAL;
	return (NULL);
	}

	if ((zoneid = getzoneidbylabel(sl)) == -1)
	return (NULL);

	/*
	* Construct the list of mounted file systems.
	*/

	if ((mlist = tsol_mkmntlist()) == NULL) {
	return (NULL);
	}
	if (getglobalpath(path_name, zoneid, mlist, ret_path) == 0) {
	tsol_mlist_free(mlist);
	return (NULL);
	}
	tsol_mlist_free(mlist);
	if (strlen(ret_path) >= bufsize) {
	errno = EFAULT;
	return (NULL);
	}
	return (strcpy(resolved_path, ret_path));
	} /* end getpathbylabel() */