usr/dash/cd.c

/*-
 * Copyright (c) 1991, 1993
 *	The Regents of the University of California.  All rights reserved.
 * Copyright (c) 1997-2005
 *	Herbert Xu <herbert@gondor.apana.org.au>.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Kenneth Almquist.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

/*
 * The cd and pwd commands.
 */

#include "shell.h"
#include "var.h"
#include "nodes.h"	/* for jobs.h */
#include "jobs.h"
#include "options.h"
#include "output.h"
#include "memalloc.h"
#include "error.h"
#include "exec.h"
#include "redir.h"
#include "mystring.h"
#include "show.h"
#include "cd.h"

#define CD_PHYSICAL 1
#define CD_PRINT 2

STATIC int docd(const char *, int);
STATIC const char *updatepwd(const char *);
STATIC char *getpwd(void);
STATIC int cdopt(void);

STATIC char *curdir = nullstr;		/* current working directory */
STATIC char *physdir = nullstr;		/* physical working directory */

STATIC int
cdopt()
{
	int flags = 0;
	int i, j;

	j = 'L';
	while ((i = nextopt("LP"))) {
		if (i != j) {
			flags ^= CD_PHYSICAL;
			j = i;
		}
	}

	return flags;
}

int
cdcmd(int argc, char **argv)
{
	const char *dest;
	const char *path;
	const char *p;
	char c;
	struct stat statb;
	int flags;

	flags = cdopt();
	dest = *argptr;
	if (!dest)
		dest = bltinlookup(homestr);
	else if (dest[0] == '-' && dest[1] == '\0') {
		dest = bltinlookup("OLDPWD");
		flags |= CD_PRINT;
	}
	if (!dest)
		dest = nullstr;
	if (*dest == '/')
		goto step7;
	if (*dest == '.') {
		c = dest[1];
dotdot:
		switch (c) {
		case '\0':
		case '/':
			goto step6;
		case '.':
			c = dest[2];
			if (c != '.')
				goto dotdot;
		}
	}
	if (!*dest)
		dest = ".";
	if (!(path = bltinlookup("CDPATH"))) {
step6:
step7:
		p = dest;
		goto docd;
	}
	do {
		c = *path;
		p = padvance(&path, dest);
		if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
			if (c && c != ':')
				flags |= CD_PRINT;
docd:
			if (!docd(p, flags))
				goto out;
			break;
		}
	} while (path);
	sh_error("can't cd to %s", dest);
	/* NOTREACHED */
out:
	if (flags & CD_PRINT)
		out1fmt(snlfmt, curdir);
	return 0;
}


/*
 * Actually do the chdir.  We also call hashcd to let the routines in exec.c
 * know that the current directory has changed.
 */

STATIC int
docd(const char *dest, int flags)
{
	const char *dir = 0;
	int err;

	TRACE(("docd(\"%s\", %d) called\n", dest, flags));

	INTOFF;
	if (!(flags & CD_PHYSICAL)) {
		dir = updatepwd(dest);
		if (dir)
			dest = dir;
	}
	err = chdir(dest);
	if (err)
		goto out;
	setpwd(dir, 1);
	hashcd();
out:
	INTON;
	return err;
}


/*
 * Update curdir (the name of the current directory) in response to a
 * cd command.
 */

STATIC const char *
updatepwd(const char *dir)
{
	char *new;
	char *p;
	char *cdcomppath;
	const char *lim;

	cdcomppath = sstrdup(dir);
	STARTSTACKSTR(new);
	if (*dir != '/') {
		if (curdir == nullstr)
			return 0;
		new = stputs(curdir, new);
	}
	new = makestrspace(strlen(dir) + 2, new);
	lim = stackblock() + 1;
	if (*dir != '/') {
		if (new[-1] != '/')
			USTPUTC('/', new);
		if (new > lim && *lim == '/')
			lim++;
	} else {
		USTPUTC('/', new);
		cdcomppath++;
		if (dir[1] == '/' && dir[2] != '/') {
			USTPUTC('/', new);
			cdcomppath++;
			lim++;
		}
	}
	p = strtok(cdcomppath, "/");
	while (p) {
		switch(*p) {
		case '.':
			if (p[1] == '.' && p[2] == '\0') {
				while (new > lim) {
					STUNPUTC(new);
					if (new[-1] == '/')
						break;
				}
				break;
			} else if (p[1] == '\0')
				break;
			/* fall through */
		default:
			new = stputs(p, new);
			USTPUTC('/', new);
		}
		p = strtok(0, "/");
	}
	if (new > lim)
		STUNPUTC(new);
	*new = 0;
	return stackblock();
}


#define MAXPWD 256

/*
 * Find out what the current directory is. If we already know the current
 * directory, this routine returns immediately.
 */
inline
STATIC char *
getpwd()
{
	char buf[PATH_MAX];
	char *dir = getcwd(buf, sizeof(buf));
	return dir ? savestr(dir) : nullstr;
}

int
pwdcmd(int argc, char **argv)
{
	int flags;
	const char *dir = curdir;

	flags = cdopt();
	if (flags) {
		if (physdir == nullstr)
			setpwd(dir, 0);
		dir = physdir;
	}
	out1fmt(snlfmt, dir);
	return 0;
}

void
setpwd(const char *val, int setold)
{
	char *oldcur, *dir;

	oldcur = dir = curdir;

	if (setold) {
		setvar("OLDPWD", oldcur, VEXPORT);
	}
	INTOFF;
	if (physdir != nullstr) {
		if (physdir != oldcur)
			free(physdir);
		physdir = nullstr;
	}
	if (oldcur == val || !val) {
		char *s = getpwd();
		physdir = s;
		if (!val)
			dir = s;
	} else
		dir = savestr(val);
	if (oldcur != dir && oldcur != nullstr) {
		free(oldcur);
	}
	curdir = dir;
	INTON;
	setvar("PWD", dir, VEXPORT);
}
1	niro	532	/*-
2			* Copyright (c) 1991, 1993
3			* The Regents of the University of California. All rights reserved.
4			* Copyright (c) 1997-2005
5			* Herbert Xu <herbert@gondor.apana.org.au>. All rights reserved.
6			*
7			* This code is derived from software contributed to Berkeley by
8			* Kenneth Almquist.
9			*
10			* Redistribution and use in source and binary forms, with or without
11			* modification, are permitted provided that the following conditions
12			* are met:
13			* 1. Redistributions of source code must retain the above copyright
14			* notice, this list of conditions and the following disclaimer.
15			* 2. Redistributions in binary form must reproduce the above copyright
16			* notice, this list of conditions and the following disclaimer in the
17			* documentation and/or other materials provided with the distribution.
18			* 3. Neither the name of the University nor the names of its contributors
19			* may be used to endorse or promote products derived from this software
20			* without specific prior written permission.
21			*
22			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32			* SUCH DAMAGE.
33			*/
34
35			#include <sys/types.h>
36			#include <sys/stat.h>
37			#include <stdlib.h>
38			#include <string.h>
39			#include <unistd.h>
40
41			/*
42			* The cd and pwd commands.
43			*/
44
45			#include "shell.h"
46			#include "var.h"
47			#include "nodes.h" /* for jobs.h */
48			#include "jobs.h"
49			#include "options.h"
50			#include "output.h"
51			#include "memalloc.h"
52			#include "error.h"
53			#include "exec.h"
54			#include "redir.h"
55			#include "mystring.h"
56			#include "show.h"
57			#include "cd.h"
58
59			#define CD_PHYSICAL 1
60			#define CD_PRINT 2
61
62			STATIC int docd(const char *, int);
63			STATIC const char updatepwd(const char );
64			STATIC char *getpwd(void);
65			STATIC int cdopt(void);
66
67			STATIC char curdir = nullstr; / current working directory */
68			STATIC char physdir = nullstr; / physical working directory */
69
70			STATIC int
71			cdopt()
72			{
73			int flags = 0;
74			int i, j;
75
76			j = 'L';
77			while ((i = nextopt("LP"))) {
78			if (i != j) {
79			flags ^= CD_PHYSICAL;
80			j = i;
81			}
82			}
83
84			return flags;
85			}
86
87			int
88			cdcmd(int argc, char **argv)
89			{
90			const char *dest;
91			const char *path;
92			const char *p;
93			char c;
94			struct stat statb;
95			int flags;
96
97			flags = cdopt();
98			dest = *argptr;
99			if (!dest)
100			dest = bltinlookup(homestr);
101			else if (dest[0] == '-' && dest[1] == '\0') {
102			dest = bltinlookup("OLDPWD");
103			flags \|= CD_PRINT;
104			}
105			if (!dest)
106			dest = nullstr;
107			if (*dest == '/')
108			goto step7;
109			if (*dest == '.') {
110			c = dest[1];
111			dotdot:
112			switch (c) {
113			case '\0':
114			case '/':
115			goto step6;
116			case '.':
117			c = dest[2];
118			if (c != '.')
119			goto dotdot;
120			}
121			}
122			if (!*dest)
123			dest = ".";
124			if (!(path = bltinlookup("CDPATH"))) {
125			step6:
126			step7:
127			p = dest;
128			goto docd;
129			}
130			do {
131			c = *path;
132			p = padvance(&path, dest);
133			if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
134			if (c && c != ':')
135			flags \|= CD_PRINT;
136			docd:
137			if (!docd(p, flags))
138			goto out;
139			break;
140			}
141			} while (path);
142			sh_error("can't cd to %s", dest);
143			/* NOTREACHED */
144			out:
145			if (flags & CD_PRINT)
146			out1fmt(snlfmt, curdir);
147			return 0;
148			}
149
150
151			/*
152			* Actually do the chdir. We also call hashcd to let the routines in exec.c
153			* know that the current directory has changed.
154			*/
155
156			STATIC int
157			docd(const char *dest, int flags)
158			{
159			const char *dir = 0;
160			int err;
161
162			TRACE(("docd(\"%s\", %d) called\n", dest, flags));
163
164			INTOFF;
165			if (!(flags & CD_PHYSICAL)) {
166			dir = updatepwd(dest);
167			if (dir)
168			dest = dir;
169			}
170			err = chdir(dest);
171			if (err)
172			goto out;
173			setpwd(dir, 1);
174			hashcd();
175			out:
176			INTON;
177			return err;
178			}
179
180
181			/*
182			* Update curdir (the name of the current directory) in response to a
183			* cd command.
184			*/
185
186			STATIC const char *
187			updatepwd(const char *dir)
188			{
189			char *new;
190			char *p;
191			char *cdcomppath;
192			const char *lim;
193
194			cdcomppath = sstrdup(dir);
195			STARTSTACKSTR(new);
196			if (*dir != '/') {
197			if (curdir == nullstr)
198			return 0;
199			new = stputs(curdir, new);
200			}
201			new = makestrspace(strlen(dir) + 2, new);
202			lim = stackblock() + 1;
203			if (*dir != '/') {
204			if (new[-1] != '/')
205			USTPUTC('/', new);
206			if (new > lim && *lim == '/')
207			lim++;
208			} else {
209			USTPUTC('/', new);
210			cdcomppath++;
211			if (dir[1] == '/' && dir[2] != '/') {
212			USTPUTC('/', new);
213			cdcomppath++;
214			lim++;
215			}
216			}
217			p = strtok(cdcomppath, "/");
218			while (p) {
219			switch(*p) {
220			case '.':
221			if (p[1] == '.' && p[2] == '\0') {
222			while (new > lim) {
223			STUNPUTC(new);
224			if (new[-1] == '/')
225			break;
226			}
227			break;
228			} else if (p[1] == '\0')
229			break;
230			/* fall through */
231			default:
232			new = stputs(p, new);
233			USTPUTC('/', new);
234			}
235			p = strtok(0, "/");
236			}
237			if (new > lim)
238			STUNPUTC(new);
239			*new = 0;
240			return stackblock();
241			}
242
243
244			#define MAXPWD 256
245
246			/*
247			* Find out what the current directory is. If we already know the current
248			* directory, this routine returns immediately.
249			*/
250			inline
251			STATIC char *
252			getpwd()
253			{
254			char buf[PATH_MAX];
255			char *dir = getcwd(buf, sizeof(buf));
256			return dir ? savestr(dir) : nullstr;
257			}
258
259			int
260			pwdcmd(int argc, char **argv)
261			{
262			int flags;
263			const char *dir = curdir;
264
265			flags = cdopt();
266			if (flags) {
267			if (physdir == nullstr)
268			setpwd(dir, 0);
269			dir = physdir;
270			}
271			out1fmt(snlfmt, dir);
272			return 0;
273			}
274
275			void
276			setpwd(const char *val, int setold)
277			{
278			char oldcur, dir;
279
280			oldcur = dir = curdir;
281
282			if (setold) {
283			setvar("OLDPWD", oldcur, VEXPORT);
284			}
285			INTOFF;
286			if (physdir != nullstr) {
287			if (physdir != oldcur)
288			free(physdir);
289			physdir = nullstr;
290			}
291			if (oldcur == val \|\| !val) {
292			char *s = getpwd();
293			physdir = s;
294			if (!val)
295			dir = s;
296			} else
297			dir = savestr(val);
298			if (oldcur != dir && oldcur != nullstr) {
299			free(oldcur);
300			}
301			curdir = dir;
302			INTON;
303			setvar("PWD", dir, VEXPORT);
304			}