/*
 * 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 2015 PALO, Richard.
 */

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

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


/*
 *	UNIX shell
 */

#include	"mac.h"
#include	<errno.h>
#include	<sys/types.h>
#include	<sys/stat.h>
#include	<limits.h>
#include	"defs.h"

#define	DOT		'.'
#define	NULLCHAR	'\0'
#define	SLASH		'/'
#define	PARTLY		2

static void rmslash(unsigned char *string);
#ifdef __STDC__
extern const char	longpwd[];
#else
extern char	longpwd[];
#endif
extern char *getcwd();

unsigned char cwdname[PATH_MAX+1];

static int 	didpwd = FALSE;

void
cwd(unsigned char *dir)
{
	unsigned char *pcwd;
	unsigned char *pdir;

	/* First remove extra /'s */

	rmslash(dir);

	/* Now remove any .'s */

	pdir = dir;
	if (*dir == SLASH)
		pdir++;
	while (*pdir) {			/* remove /./ by itself */
		if ((*pdir == DOT) && (*(pdir+1) == SLASH)) {
			movstr(pdir+2, pdir);
			continue;
		}
		pdir++;
		while ((*pdir) && (*pdir != SLASH))
			pdir++;
		if (*pdir)
			pdir++;
	}
	/* take care of trailing /. */
	if (*(--pdir) == DOT && pdir > dir && *(--pdir) == SLASH) {
		if (pdir > dir) {
			*pdir = NULLCHAR;
		} else {
			*(pdir+1) = NULLCHAR;
		}

	}

	/* Remove extra /'s */

	rmslash(dir);

	/* Now that the dir is canonicalized, process it */

	if (*dir == DOT && *(dir+1) == NULLCHAR) {
		return;
	}


	if (*dir == SLASH) {
		/* Absolute path */

		pcwd = cwdname;
		*pcwd++ = *dir++;
		didpwd = PARTLY;
	}
	else
	{
		/* Relative path */

		if (didpwd == FALSE)
			return;
		didpwd = PARTLY;
		pcwd = cwdname + length(cwdname) - 1;
		if (pcwd != cwdname+1)
			*pcwd++ = SLASH;
	}
	while (*dir) {
		if (*dir == DOT &&
		    *(dir+1) == DOT &&
		    (*(dir+2) == SLASH || *(dir+2) == NULLCHAR)) {
			/* Parent directory, so backup one */

			if (pcwd > cwdname+2)
				--pcwd;
			while (*(--pcwd) != SLASH)
				;
			pcwd++;
			dir += 2;
			if (*dir == SLASH) {
				dir++;
			}
			continue;
		}
		if (pcwd >= &cwdname[PATH_MAX+1]) {
			didpwd = FALSE;
			return;
		}
		*pcwd++ = *dir++;
		while ((*dir) && (*dir != SLASH)) {
			if (pcwd >= &cwdname[PATH_MAX+1]) {
				didpwd = FALSE;
				return;
			}
			*pcwd++ = *dir++;
		}
		if (*dir) {
			if (pcwd >= &cwdname[PATH_MAX+1]) {
				didpwd = FALSE;
				return;
			}
			*pcwd++ = *dir++;
		}
	}
	if (pcwd >= &cwdname[PATH_MAX+1]) {
		didpwd = FALSE;
		return;
	}
	*pcwd = NULLCHAR;

	--pcwd;
	if (pcwd > cwdname && *pcwd == SLASH) {
		/* Remove trailing / */

		*pcwd = NULLCHAR;
	}
}

void
cwd2()
{
	struct stat stat1, stat2;
	unsigned char *pcwd;
	/* check if there are any symbolic links in pathname */

	if (didpwd == FALSE)
		return;
	pcwd = cwdname + 1;
	if (didpwd == PARTLY) {
		while (*pcwd) {
			char c;
			do {
				c = *pcwd++;
			} while (c != SLASH && c != NULLCHAR);
			*--pcwd = NULLCHAR;
			if (lstat((char *)cwdname, &stat1) == -1 ||
			    (stat1.st_mode & S_IFMT) == S_IFLNK) {
				didpwd = FALSE;
				*pcwd = c;
				return;
			}
			*pcwd = c;
			if (c)
				pcwd++;
		}
		didpwd = TRUE;
	} else
		if (stat((char *)cwdname, &stat1) == -1) {
			didpwd = FALSE;
			return;
		}
	/*
	 * check if ino's and dev's match; pathname could
	 * consist of symbolic links with ".."
	 */

	if (stat(".", &stat2) == -1 ||
	    stat1.st_dev != stat2.st_dev ||
	    stat1.st_ino != stat2.st_ino)
		didpwd = FALSE;
}

unsigned char *
cwdget()
{
	cwd2();
	if (didpwd == FALSE) {
		if (getcwd((char *)cwdname, PATH_MAX+1) == NULL)
			*cwdname = NULLCHAR;
		didpwd = TRUE;
	}
	return (cwdname);
}

/*
 *	Print the current working directory.
 */

void
cwdprint(void)
{
	unsigned char *cp;

	cwd2();
	if (didpwd == FALSE) {
		if (getcwd((char *)cwdname, PATH_MAX+1) == NULL) {
			if (errno && errno != ERANGE)
				error(badpwd);
			else
				error(longpwd);
		}
		didpwd = TRUE;
	}

	for (cp = cwdname; *cp; cp++) {
		prc_buff(*cp);
	}

	prc_buff(NL);
}

/*
 *	This routine will remove repeated slashes from string.
 */

static void
rmslash(unsigned char *string)
{
	unsigned char *pstring;

	pstring = string;
	while (*pstring) {
		if (*pstring == SLASH && *(pstring+1) == SLASH) {
			/* Remove repeated SLASH's */

			movstr(pstring+1, pstring);
			continue;
		}
		pstring++;
	}

	--pstring;
	if (pstring > string && *pstring == SLASH) {
		/* Remove trailing / */

		*pstring = NULLCHAR;
	}
}