Import tcsh-6.17.00
[dragonfly.git] / contrib / tcsh-6 / sh.dir.c
CommitLineData
57e3f2b5 1/* $Header: /p/tcsh/cvsroot/tcsh/sh.dir.c,v 3.80 2007/05/08 21:05:34 christos Exp $ */
7d8fb588
MS
2/*
3 * sh.dir.c: Directory manipulation functions
4 */
5/*-
6 * Copyright (c) 1980, 1991 The Regents of the University of California.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33#include "sh.h"
34#include "ed.h"
35
57e3f2b5 36RCSID("$tcsh: sh.dir.c,v 3.80 2007/05/08 21:05:34 christos Exp $")
7d8fb588
MS
37
38/*
39 * C Shell - directory management
40 */
41
42static Char *agetcwd (void);
43static void dstart (const char *);
44static struct directory *dfind (Char *);
57e3f2b5 45static Char *dfollow (Char *, int);
7d8fb588
MS
46static void printdirs (int);
47static Char *dgoto (Char *);
48static void dnewcwd (struct directory *, int);
49static void dset (Char *);
50static void dextract (struct directory *);
51static int skipargs (Char ***, const char *,
52 const char *);
53static void dgetstack (void);
54
55static struct directory dhead INIT_ZERO_STRUCT; /* "head" of loop */
56static int printd; /* force name to be printed */
57
58int bequiet = 0; /* do not print dir stack -strike */
59
60static Char *
61agetcwd(void)
62{
63 char *buf;
64 Char *cwd;
65 size_t len;
66
67 len = MAXPATHLEN;
68 buf = xmalloc(len);
69 while (getcwd(buf, len) == NULL) {
70 int err;
71
72 err = errno;
73 if (err != ERANGE) {
74 xfree(buf);
75 errno = err;
76 return NULL;
77 }
78 len *= 2;
79 buf = xrealloc(buf, len);
80 }
81 if (*buf == '\0') {
82 xfree(buf);
83 return NULL;
84 }
85 cwd = SAVE(buf);
86 xfree(buf);
87 return cwd;
88}
89
90static void
91dstart(const char *from)
92{
93 xprintf(CGETS(12, 1, "%s: Trying to start from \"%s\"\n"), progname, from);
94}
95
96/*
97 * dinit - initialize current working directory
98 */
99void
100dinit(Char *hp)
101{
102 Char *cp, *tcp;
103 struct directory *dp;
104
105 /* Don't believe the login shell home, because it may be a symlink */
106 tcp = agetcwd();
107 if (tcp == NULL) {
108 xprintf("%s: %s\n", progname, strerror(errno));
109 if (hp && *hp) {
110 char *xcp = short2str(hp);
111 dstart(xcp);
112 if (chdir(xcp) == -1)
113 cp = NULL;
114 else
115 cp = Strsave(hp);
116 }
117 else
118 cp = NULL;
119 if (cp == NULL) {
120 dstart("/");
121 if (chdir("/") == -1)
122 /* I am not even try to print an error message! */
123 xexit(1);
124 cp = SAVE("/");
125 }
126 }
127 else {
128#ifdef S_IFLNK
129 struct stat swd, shp;
130 int swd_ok;
131
132 swd_ok = stat(short2str(tcp), &swd) == 0;
133 /*
134 * See if $HOME is the working directory we got and use that
135 */
136 if (swd_ok && hp && *hp && stat(short2str(hp), &shp) != -1 &&
137 DEV_DEV_COMPARE(swd.st_dev, shp.st_dev) &&
138 swd.st_ino == shp.st_ino)
139 cp = Strsave(hp);
140 else {
141 char *cwd;
142
143 /*
144 * use PWD if we have it (for subshells)
145 */
146 if (swd_ok && (cwd = getenv("PWD")) != NULL) {
147 if (stat(cwd, &shp) != -1 &&
148 DEV_DEV_COMPARE(swd.st_dev, shp.st_dev) &&
149 swd.st_ino == shp.st_ino) {
150 tcp = SAVE(cwd);
151 cleanup_push(tcp, xfree);
152 }
153 }
154 cleanup_push(tcp, xfree);
155 cp = dcanon(tcp, STRNULL);
156 cleanup_ignore(tcp);
157 cleanup_until(tcp);
158 }
159#else /* S_IFLNK */
160 cleanup_push(tcp, xfree);
161 cp = dcanon(tcp, STRNULL);
162 cleanup_ignore(tcp);
163 cleanup_until(tcp);
164#endif /* S_IFLNK */
165 }
166
167 dp = xcalloc(sizeof(struct directory), 1);
168 dp->di_name = cp;
169 dp->di_count = 0;
170 dhead.di_next = dhead.di_prev = dp;
171 dp->di_next = dp->di_prev = &dhead;
172 printd = 0;
173 dnewcwd(dp, 0);
174 setcopy(STRdirstack, dp->di_name, VAR_READWRITE|VAR_NOGLOB);
175}
176
177static void
178dset(Char *dp)
179{
180 /*
181 * Don't call set() directly cause if the directory contains ` or
182 * other junk characters glob will fail.
183 */
184 setcopy(STRowd, varval(STRcwd), VAR_READWRITE|VAR_NOGLOB);
185 setcopy(STRcwd, dp, VAR_READWRITE|VAR_NOGLOB);
186 tsetenv(STRPWD, dp);
187}
188
189#define DIR_PRINT 0x01 /* -p */
190#define DIR_LONG 0x02 /* -l */
191#define DIR_VERT 0x04 /* -v */
192#define DIR_LINE 0x08 /* -n */
193#define DIR_SAVE 0x10 /* -S */
194#define DIR_LOAD 0x20 /* -L */
195#define DIR_CLEAR 0x40 /* -c */
196#define DIR_OLD 0x80 /* - */
197
198static int
199skipargs(Char ***v, const char *dstr, const char *str)
200{
201 Char **n = *v, *s;
202
203 int dflag = 0, loop = 1;
204 for (n++; loop && *n != NULL && (*n)[0] == '-'; n++)
205 if (*(s = &((*n)[1])) == '\0') /* test for bare "-" argument */
206 dflag |= DIR_OLD;
207 else {
208 char *p;
209 while (*s != '\0') /* examine flags */
210 {
211 if ((p = strchr(dstr, *s++)) != NULL)
212 dflag |= (1 << (p - dstr));
213 else
214 stderror(ERR_DIRUS, short2str(**v), dstr, str);
215 }
216 }
217 if (*n && (dflag & DIR_OLD))
218 stderror(ERR_DIRUS, short2str(**v), dstr, str);
219 *v = n;
220 /* make -l, -v, and -n imply -p */
221 if (dflag & (DIR_LONG|DIR_VERT|DIR_LINE))
222 dflag |= DIR_PRINT;
223 return dflag;
224}
225
226/*
227 * dodirs - list all directories in directory loop
228 */
229/*ARGSUSED*/
230void
231dodirs(Char **v, struct command *c)
232{
233 static const char flags[] = "plvnSLc";
234 int dflag = skipargs(&v, flags, "");
235
236 USE(c);
237 if ((dflag & DIR_CLEAR) != 0) {
238 struct directory *dp, *fdp;
239 for (dp = dcwd->di_next; dp != dcwd; ) {
240 fdp = dp;
241 dp = dp->di_next;
242 if (fdp != &dhead)
243 dfree(fdp);
244 }
245 dhead.di_next = dhead.di_prev = dp;
246 dp->di_next = dp->di_prev = &dhead;
247 }
248 if ((dflag & DIR_LOAD) != 0)
249 loaddirs(*v);
250 else if ((dflag & DIR_SAVE) != 0)
251 recdirs(*v, 1);
252
253 if (*v && (dflag & (DIR_SAVE|DIR_LOAD)))
254 v++;
255
256 if (*v != NULL || (dflag & DIR_OLD))
257 stderror(ERR_DIRUS, "dirs", flags, "");
258 if ((dflag & (DIR_CLEAR|DIR_LOAD|DIR_SAVE)) == 0 || (dflag & DIR_PRINT))
259 printdirs(dflag);
260}
261
262static void
263printdirs(int dflag)
264{
265 struct directory *dp;
266 Char *s, *user;
267 int idx, len, cur;
268
269 dp = dcwd;
270 idx = 0;
271 cur = 0;
272 do {
273 if (dp == &dhead)
274 continue;
275 if (dflag & DIR_VERT) {
276 xprintf("%d\t", idx++);
277 cur = 0;
278 }
279 s = dp->di_name;
280 user = NULL;
281 if (!(dflag & DIR_LONG) && (user = getusername(&s)) != NULL)
282 len = (int) (Strlen(user) + Strlen(s) + 2);
283 else
284 len = (int) (Strlen(s) + 1);
285
286 cur += len;
287 if ((dflag & DIR_LINE) && cur >= TermH - 1 && len < TermH) {
288 xputchar('\n');
289 cur = len;
290 }
291 if (user)
292 xprintf("~%S", user);
293 xprintf("%-S%c", s, (dflag & DIR_VERT) ? '\n' : ' ');
294 } while ((dp = dp->di_prev) != dcwd);
295 if (!(dflag & DIR_VERT))
296 xputchar('\n');
297}
298
299void
300dtildepr(Char *dir)
301{
302 Char* user;
303 if ((user = getusername(&dir)) != NULL)
304 xprintf("~%-S%S", user, dir);
305 else
306 xprintf("%S", dir);
307}
308
309void
310dtilde(void)
311{
312 struct directory *d = dcwd;
313
314 do {
315 if (d == &dhead)
316 continue;
317 d->di_name = dcanon(d->di_name, STRNULL);
318 } while ((d = d->di_prev) != dcwd);
319
320 dset(dcwd->di_name);
321}
322
323
324/* dnormalize():
325 * The path will be normalized if it
326 * 1) is "..",
327 * 2) or starts with "../",
328 * 3) or ends with "/..",
329 * 4) or contains the string "/../",
330 * then it will be normalized, unless those strings are quoted.
331 * Otherwise, a copy is made and sent back.
332 */
333Char *
334dnormalize(const Char *cp, int expnd)
335{
336
337/* return true if dp is of the form "../xxx" or "/../xxx" */
338#define IS_DOTDOT(sp, p) (ISDOTDOT(p) && ((p) == (sp) || *((p) - 1) == '/'))
339#define IS_DOT(sp, p) (ISDOT(p) && ((p) == (sp) || *((p) - 1) == '/'))
340
341#ifdef S_IFLNK
342 if (expnd) {
343 struct Strbuf buf = Strbuf_INIT;
344 int dotdot = 0;
345 Char *dp, *cwd;
346 const Char *start = cp;
347# ifdef HAVE_SLASHSLASH
348 int slashslash;
349# endif /* HAVE_SLASHSLASH */
350
351 /*
352 * count the number of "../xxx" or "xxx/../xxx" in the path
353 */
354 for ( ; *cp && *(cp + 1); cp++)
355 if (IS_DOTDOT(start, cp))
356 dotdot++;
357
358 /*
359 * if none, we are done.
360 */
361 if (dotdot == 0)
362 return (Strsave(start));
363
364# ifdef notdef
365 struct stat sb;
366 /*
367 * We disable this test because:
368 * cd /tmp; mkdir dir1 dir2; cd dir2; ln -s /tmp/dir1; cd dir1;
369 * echo ../../dir1 does not expand. We had enabled this before
370 * because it was bothering people with expansions in compilation
371 * lines like -I../../foo. Maybe we need some kind of finer grain
372 * control?
373 *
374 * If the path doesn't exist, we are done too.
375 */
376 if (lstat(short2str(start), &sb) != 0 && errno == ENOENT)
377 return (Strsave(start));
378# endif
379
380 cwd = xmalloc((Strlen(dcwd->di_name) + 3) * sizeof(Char));
381 (void) Strcpy(cwd, dcwd->di_name);
382
383 /*
384 * If the path starts with a slash, we are not relative to
385 * the current working directory.
386 */
387 if (ABSOLUTEP(start))
388 *cwd = '\0';
389# ifdef HAVE_SLASHSLASH
390 slashslash = cwd[0] == '/' && cwd[1] == '/';
391# endif /* HAVE_SLASHSLASH */
392
393 /*
394 * Ignore . and count ..'s
395 */
396 cp = start;
397 do {
398 dotdot = 0;
399 buf.len = 0;
400 while (*cp)
401 if (IS_DOT(start, cp)) {
402 if (*++cp)
403 cp++;
404 }
405 else if (IS_DOTDOT(start, cp)) {
406 if (buf.len != 0)
407 break; /* finish analyzing .././../xxx/[..] */
408 dotdot++;
409 cp += 2;
410 if (*cp)
411 cp++;
412 }
413 else
414 Strbuf_append1(&buf, *cp++);
415
416 Strbuf_terminate(&buf);
417 while (dotdot > 0)
418 if ((dp = Strrchr(cwd, '/')) != NULL) {
419# ifdef HAVE_SLASHSLASH
420 if (dp == &cwd[1])
421 slashslash = 1;
422# endif /* HAVE_SLASHSLASH */
423 *dp = '\0';
424 dotdot--;
425 }
426 else
427 break;
428
429 if (!*cwd) { /* too many ..'s, starts with "/" */
430 cwd[0] = '/';
431# ifdef HAVE_SLASHSLASH
432 /*
433 * Only append another slash, if already the former cwd
434 * was in a double-slash path.
435 */
436 cwd[1] = slashslash ? '/' : '\0';
437 cwd[2] = '\0';
438# else /* !HAVE_SLASHSLASH */
439 cwd[1] = '\0';
440# endif /* HAVE_SLASHSLASH */
441 }
442# ifdef HAVE_SLASHSLASH
443 else if (slashslash && cwd[1] == '\0') {
444 cwd[1] = '/';
445 cwd[2] = '\0';
446 }
447# endif /* HAVE_SLASHSLASH */
448
449 if (buf.len != 0) {
450 size_t i;
451
452 i = Strlen(cwd);
453 if (TRM(cwd[i - 1]) != '/') {
454 cwd[i++] = '/';
455 cwd[i] = '\0';
456 }
457 dp = Strspl(cwd, TRM(buf.s[0]) == '/' ? &buf.s[1] : buf.s);
458 xfree(cwd);
459 cwd = dp;
460 i = Strlen(cwd) - 1;
461 if (TRM(cwd[i]) == '/')
462 cwd[i] = '\0';
463 }
464 /* Reduction of ".." following the stuff we collected in buf
465 * only makes sense if the directory item in buf really exists.
466 * Avoid reduction of "-I../.." (typical compiler call) to ""
467 * or "/usr/nonexistant/../bin" to "/usr/bin":
468 */
469 if (cwd[0]) {
470 struct stat exists;
471 if (0 != stat(short2str(cwd), &exists)) {
472 xfree(buf.s);
473 xfree(cwd);
474 return Strsave(start);
475 }
476 }
477 } while (*cp != '\0');
478 xfree(buf.s);
479 return cwd;
480 }
481#endif /* S_IFLNK */
482 return Strsave(cp);
483}
484
485
486/*
487 * dochngd - implement chdir command.
488 */
489/*ARGSUSED*/
490void
491dochngd(Char **v, struct command *c)
492{
493 Char *cp;
494 struct directory *dp;
495 int dflag = skipargs(&v, "plvn", "[-|<dir>]");
496
497 USE(c);
498 printd = 0;
499 cp = (dflag & DIR_OLD) ? varval(STRowd) : *v;
500
501 if (cp == NULL) {
502 if ((cp = varval(STRhome)) == STRNULL || *cp == 0)
503 stderror(ERR_NAME | ERR_NOHOMEDIR);
504 if (chdir(short2str(cp)) < 0)
505 stderror(ERR_NAME | ERR_CANTCHANGE);
506 cp = Strsave(cp);
507 }
508 else if ((dflag & DIR_OLD) == 0 && v[1] != NULL) {
509 stderror(ERR_NAME | ERR_TOOMANY);
510 /* NOTREACHED */
511 return;
512 }
513 else if ((dp = dfind(cp)) != 0) {
514 char *tmp;
515
516 printd = 1;
517 if (chdir(tmp = short2str(dp->di_name)) < 0)
518 stderror(ERR_SYSTEM, tmp, strerror(errno));
519 dcwd->di_prev->di_next = dcwd->di_next;
520 dcwd->di_next->di_prev = dcwd->di_prev;
521 dfree(dcwd);
522 dnewcwd(dp, dflag);
523 return;
524 }
525 else
57e3f2b5 526 if ((cp = dfollow(cp, dflag & DIR_OLD)) == NULL)
7d8fb588
MS
527 return;
528 dp = xcalloc(sizeof(struct directory), 1);
529 dp->di_name = cp;
530 dp->di_count = 0;
531 dp->di_next = dcwd->di_next;
532 dp->di_prev = dcwd->di_prev;
533 dp->di_prev->di_next = dp;
534 dp->di_next->di_prev = dp;
535 dfree(dcwd);
536 dnewcwd(dp, dflag);
537}
538
539static Char *
540dgoto(Char *cp)
541{
542 Char *dp, *ret;
543
544 if (!ABSOLUTEP(cp))
545 {
546 Char *p, *q;
547 size_t cwdlen;
548
549 cwdlen = Strlen(dcwd->di_name);
550 if (cwdlen == 1) /* root */
551 cwdlen = 0;
552 dp = xmalloc((cwdlen + Strlen(cp) + 2) * sizeof(Char));
553 for (p = dp, q = dcwd->di_name; (*p++ = *q++) != '\0';)
554 continue;
555 if (cwdlen)
556 p[-1] = '/';
557 else
558 p--; /* don't add a / after root */
559 Strcpy(p, cp);
560 xfree(cp);
561 cp = dp;
562 dp += cwdlen;
563 }
564 else
565 dp = cp;
566
567#if defined(WINNT_NATIVE)
568 return agetcwd();
569#elif defined(__CYGWIN__)
570 if (ABSOLUTEP(cp) && cp[1] == ':') { /* Only DOS paths are treated that way */
571 return agetcwd();
572 } else {
573 cleanup_push(cp, xfree);
574 ret = dcanon(cp, dp);
575 cleanup_ignore(cp);
576 cleanup_until(cp);
577 }
578#else /* !WINNT_NATIVE */
579 cleanup_push(cp, xfree);
580 ret = dcanon(cp, dp);
581 cleanup_ignore(cp);
582 cleanup_until(cp);
583#endif /* WINNT_NATIVE */
584 return ret;
585}
586
587/*
588 * dfollow - change to arg directory; fall back on cdpath if not valid
589 */
590static Char *
57e3f2b5 591dfollow(Char *cp, int old)
7d8fb588
MS
592{
593 Char *dp;
594 struct varent *c;
595 int serrno;
596
57e3f2b5 597 cp = old ? Strsave(cp) : globone(cp, G_ERROR);
7d8fb588
MS
598 cleanup_push(cp, xfree);
599#ifdef apollo
600 if (Strchr(cp, '`')) {
601 char *dptr;
602 if (chdir(dptr = short2str(cp)) < 0)
603 stderror(ERR_SYSTEM, dptr, strerror(errno));
604 dp = agetcwd();
605 cleanup_push(dp, xfree);
606 if (dp != NULL) {
607 cleanup_until(cp);
608 return dgoto(dp);
609 }
610 else
611 stderror(ERR_SYSTEM, dptr, strerror(errno));
612 }
613#endif /* apollo */
614
615 /*
616 * if we are ignoring symlinks, try to fix relatives now.
617 * if we are expading symlinks, it should be done by now.
618 */
619 dp = dnormalize(cp, symlinks == SYM_IGNORE);
620 if (chdir(short2str(dp)) >= 0) {
621 cleanup_until(cp);
622 return dgoto(dp);
623 }
624 else {
625 xfree(dp);
626 if (chdir(short2str(cp)) >= 0) {
627 cleanup_ignore(cp);
628 cleanup_until(cp);
629 return dgoto(cp);
630 }
631 else if (errno != ENOENT && errno != ENOTDIR) {
632 int err;
633
634 err = errno;
635 stderror(ERR_SYSTEM, short2str(cp), strerror(err));
636 }
637 serrno = errno;
638 }
639
640 if (cp[0] != '/' && !prefix(STRdotsl, cp) && !prefix(STRdotdotsl, cp)
641 && (c = adrof(STRcdpath)) && c->vec != NULL) {
642 struct Strbuf buf = Strbuf_INIT;
643 Char **cdp;
644
645 for (cdp = c->vec; *cdp; cdp++) {
646 buf.len = 0;
647 Strbuf_append(&buf, *cdp);
648 Strbuf_append1(&buf, '/');
649 Strbuf_append(&buf, cp);
650 Strbuf_terminate(&buf);
651 /*
652 * We always want to fix the directory here
653 * If we are normalizing symlinks
654 */
655 dp = dnormalize(buf.s, symlinks == SYM_IGNORE ||
656 symlinks == SYM_EXPAND);
657 if (chdir(short2str(dp)) >= 0) {
658 printd = 1;
659 xfree(buf.s);
660 cleanup_until(cp);
661 return dgoto(dp);
662 }
663 else if (chdir(short2str(cp)) >= 0) {
664 printd = 1;
665 xfree(dp);
666 xfree(buf.s);
667 cleanup_ignore(cp);
668 cleanup_until(cp);
669 return dgoto(cp);
670 }
671 }
672 xfree(buf.s);
673 }
674 dp = varval(cp);
675 if ((dp[0] == '/' || dp[0] == '.') && chdir(short2str(dp)) >= 0) {
676 cleanup_until(cp);
677 cp = Strsave(dp);
678 printd = 1;
679 return dgoto(cp);
680 }
681 /*
682 * on login source of ~/.cshdirs, errors are eaten. the dir stack is all
683 * directories we could get to.
684 */
685 if (!bequiet)
686 stderror(ERR_SYSTEM, short2str(cp), strerror(serrno));
687 cleanup_until(cp);
688 return (NULL);
689}
690
691
692/*
693 * dopushd - push new directory onto directory stack.
694 * with no arguments exchange top and second.
695 * with numeric argument (+n) bring it to top.
696 */
697/*ARGSUSED*/
698void
699dopushd(Char **v, struct command *c)
700{
701 struct directory *dp;
702 Char *cp;
703 int dflag = skipargs(&v, "plvn", " [-|<dir>|+<n>]");
704
705 USE(c);
706 printd = 1;
707 cp = (dflag & DIR_OLD) ? varval(STRowd) : *v;
708
709 if (cp == NULL) {
710 if (adrof(STRpushdtohome)) {
711 if ((cp = varval(STRhome)) == STRNULL || *cp == 0)
712 stderror(ERR_NAME | ERR_NOHOMEDIR);
713 if (chdir(short2str(cp)) < 0)
714 stderror(ERR_NAME | ERR_CANTCHANGE);
57e3f2b5 715 if ((cp = dfollow(cp, dflag & DIR_OLD)) == NULL)
7d8fb588
MS
716 return;
717 dp = xcalloc(sizeof(struct directory), 1);
718 dp->di_name = cp;
719 dp->di_count = 0;
720 dp->di_prev = dcwd;
721 dp->di_next = dcwd->di_next;
722 dcwd->di_next = dp;
723 dp->di_next->di_prev = dp;
724 }
725 else {
726 char *tmp;
727
728 if ((dp = dcwd->di_prev) == &dhead)
729 dp = dhead.di_prev;
730 if (dp == dcwd)
731 stderror(ERR_NAME | ERR_NODIR);
732 if (chdir(tmp = short2str(dp->di_name)) < 0)
733 stderror(ERR_SYSTEM, tmp, strerror(errno));
734 dp->di_prev->di_next = dp->di_next;
735 dp->di_next->di_prev = dp->di_prev;
736 dp->di_next = dcwd->di_next;
737 dp->di_prev = dcwd;
738 dcwd->di_next->di_prev = dp;
739 dcwd->di_next = dp;
740 }
741 }
742 else if ((dflag & DIR_OLD) == 0 && v[1] != NULL) {
743 stderror(ERR_NAME | ERR_TOOMANY);
744 /* NOTREACHED */
745 return;
746 }
747 else if ((dp = dfind(cp)) != NULL) {
748 char *tmp;
749
750 if (chdir(tmp = short2str(dp->di_name)) < 0)
751 stderror(ERR_SYSTEM, tmp, strerror(errno));
752 /*
753 * kfk - 10 Feb 1984 - added new "extraction style" pushd +n
754 */
755 if (adrof(STRdextract))
756 dextract(dp);
757 }
758 else {
759 Char *ccp;
760
57e3f2b5 761 if ((ccp = dfollow(cp, dflag & DIR_OLD)) == NULL)
7d8fb588
MS
762 return;
763 dp = xcalloc(sizeof(struct directory), 1);
764 dp->di_name = ccp;
765 dp->di_count = 0;
766 dp->di_prev = dcwd;
767 dp->di_next = dcwd->di_next;
768 dcwd->di_next = dp;
769 dp->di_next->di_prev = dp;
770 }
771 dnewcwd(dp, dflag);
772}
773
774/*
775 * dfind - find a directory if specified by numeric (+n) argument
776 */
777static struct directory *
778dfind(Char *cp)
779{
780 struct directory *dp;
781 int i;
782 Char *ep;
783
784 if (*cp++ != '+')
785 return (0);
786 for (ep = cp; Isdigit(*ep); ep++)
787 continue;
788 if (*ep)
789 return (0);
790 i = getn(cp);
791 if (i <= 0)
792 return (0);
793 for (dp = dcwd; i != 0; i--) {
794 if ((dp = dp->di_prev) == &dhead)
795 dp = dp->di_prev;
796 if (dp == dcwd)
797 stderror(ERR_NAME | ERR_DEEP);
798 }
799 return (dp);
800}
801
802/*
803 * dopopd - pop a directory out of the directory stack
804 * with a numeric argument just discard it.
805 */
806/*ARGSUSED*/
807void
808dopopd(Char **v, struct command *c)
809{
810 Char *cp;
811 struct directory *dp, *p = NULL;
812 int dflag = skipargs(&v, "plvn", " [-|+<n>]");
813
814 USE(c);
815 printd = 1;
816 cp = (dflag & DIR_OLD) ? varval(STRowd) : *v;
817
818 if (cp == NULL)
819 dp = dcwd;
820 else if ((dflag & DIR_OLD) == 0 && v[1] != NULL) {
821 stderror(ERR_NAME | ERR_TOOMANY);
822 /* NOTREACHED */
823 return;
824 }
825 else if ((dp = dfind(cp)) == 0)
826 stderror(ERR_NAME | ERR_BADDIR);
827 if (dp->di_prev == &dhead && dp->di_next == &dhead)
828 stderror(ERR_NAME | ERR_EMPTY);
829 if (dp == dcwd) {
830 char *tmp;
831
832 if ((p = dp->di_prev) == &dhead)
833 p = dhead.di_prev;
834 if (chdir(tmp = short2str(p->di_name)) < 0)
835 stderror(ERR_SYSTEM, tmp, strerror(errno));
836 }
837 dp->di_prev->di_next = dp->di_next;
838 dp->di_next->di_prev = dp->di_prev;
839 dfree(dp);
840 if (dp == dcwd) {
841 dnewcwd(p, dflag);
842 }
843 else {
844 printdirs(dflag);
845 }
846}
847
848/*
849 * dfree - free the directory (or keep it if it still has ref count)
850 */
851void
852dfree(struct directory *dp)
853{
854
855 if (dp->di_count != 0) {
856 dp->di_next = dp->di_prev = 0;
857 }
858 else {
859 xfree(dp->di_name);
860 xfree(dp);
861 }
862}
863
864/*
865 * dcanon - canonicalize the pathname, removing excess ./ and ../ etc.
866 * we are of course assuming that the file system is standardly
867 * constructed (always have ..'s, directories have links)
868 */
869Char *
870dcanon(Char *cp, Char *p)
871{
872 Char *sp;
873 Char *p1, *p2; /* general purpose */
874 int slash;
875#ifdef HAVE_SLASHSLASH
876 int slashslash;
877#endif /* HAVE_SLASHSLASH */
878 size_t clen;
879
880#ifdef S_IFLNK /* if we have symlinks */
881 Char *mlink, *newcp;
882 char *tlink;
883 size_t cc;
884#endif /* S_IFLNK */
885
886 clen = Strlen(cp);
887
888 /*
889 * christos: if the path given does not start with a slash prepend cwd. If
890 * cwd does not start with a slash or the result would be too long try to
891 * correct it.
892 */
893 if (!ABSOLUTEP(cp)) {
894 Char *tmpdir;
895 size_t len;
896
897 p1 = varval(STRcwd);
898 if (p1 == STRNULL || !ABSOLUTEP(p1)) {
899 Char *new_cwd = agetcwd();
900
901 if (new_cwd == NULL) {
902 xprintf("%s: %s\n", progname, strerror(errno));
903 setcopy(STRcwd, str2short("/"), VAR_READWRITE|VAR_NOGLOB);
904 }
905 else
906 setv(STRcwd, new_cwd, VAR_READWRITE|VAR_NOGLOB);
907 p1 = varval(STRcwd);
908 }
909 len = Strlen(p1);
910 tmpdir = xmalloc((len + clen + 2) * sizeof (*tmpdir));
911 (void) Strcpy(tmpdir, p1);
912 (void) Strcat(tmpdir, STRslash);
913 (void) Strcat(tmpdir, cp);
914 xfree(cp);
915 cp = p = tmpdir;
916 }
917
918#ifdef HAVE_SLASHSLASH
919 slashslash = (cp[0] == '/' && cp[1] == '/');
920#endif /* HAVE_SLASHSLASH */
921
922 while (*p) { /* for each component */
923 sp = p; /* save slash address */
924 while (*++p == '/') /* flush extra slashes */
925 continue;
926 if (p != ++sp)
927 for (p1 = sp, p2 = p; (*p1++ = *p2++) != '\0';)
928 continue;
929 p = sp; /* save start of component */
930 slash = 0;
931 if (*p)
932 while (*++p) /* find next slash or end of path */
933 if (*p == '/') {
934 slash = 1;
935 *p = 0;
936 break;
937 }
938
939#ifdef HAVE_SLASHSLASH
940 if (&cp[1] == sp && sp[0] == '.' && sp[1] == '.' && sp[2] == '\0')
941 slashslash = 1;
942#endif /* HAVE_SLASHSLASH */
943 if (*sp == '\0') { /* if component is null */
944 if (--sp == cp) /* if path is one char (i.e. /) */
945 break;
946 else
947 *sp = '\0';
948 }
949 else if (sp[0] == '.' && sp[1] == 0) {
950 if (slash) {
951 for (p1 = sp, p2 = p + 1; (*p1++ = *p2++) != '\0';)
952 continue;
953 p = --sp;
954 }
955 else if (--sp != cp)
956 *sp = '\0';
957 else
958 sp[1] = '\0';
959 }
960 else if (sp[0] == '.' && sp[1] == '.' && sp[2] == 0) {
961 /*
962 * We have something like "yyy/xxx/..", where "yyy" can be null or
963 * a path starting at /, and "xxx" is a single component. Before
964 * compressing "xxx/..", we want to expand "yyy/xxx", if it is a
965 * symbolic link.
966 */
967 *--sp = 0; /* form the pathname for readlink */
968#ifdef S_IFLNK /* if we have symlinks */
969 if (sp != cp && /* symlinks != SYM_IGNORE && */
970 (tlink = areadlink(short2str(cp))) != NULL) {
971 mlink = str2short(tlink);
972 xfree(tlink);
973
974 if (slash)
975 *p = '/';
976 /*
977 * Point p to the '/' in "/..", and restore the '/'.
978 */
979 *(p = sp) = '/';
980 if (*mlink != '/') {
981 /*
982 * Relative path, expand it between the "yyy/" and the
983 * "/..". First, back sp up to the character past "yyy/".
984 */
985 while (*--sp != '/')
986 continue;
987 sp++;
988 *sp = 0;
989 /*
990 * New length is "yyy/" + mlink + "/.." and rest
991 */
992 p1 = newcp = xmalloc(((sp - cp) + Strlen(mlink) +
993 Strlen(p) + 1) * sizeof(Char));
994 /*
995 * Copy new path into newcp
996 */
997 for (p2 = cp; (*p1++ = *p2++) != '\0';)
998 continue;
999 for (p1--, p2 = mlink; (*p1++ = *p2++) != '\0';)
1000 continue;
1001 for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
1002 continue;
1003 /*
1004 * Restart canonicalization at expanded "/xxx".
1005 */
1006 p = sp - cp - 1 + newcp;
1007 }
1008 else {
1009 newcp = Strspl(mlink, p);
1010 /*
1011 * Restart canonicalization at beginning
1012 */
1013 p = newcp;
1014 }
1015 xfree(cp);
1016 cp = newcp;
1017#ifdef HAVE_SLASHSLASH
1018 slashslash = (cp[0] == '/' && cp[1] == '/');
1019#endif /* HAVE_SLASHSLASH */
1020 continue; /* canonicalize the link */
1021 }
1022#endif /* S_IFLNK */
1023 *sp = '/';
1024 if (sp != cp)
1025 while (*--sp != '/')
1026 continue;
1027 if (slash) {
1028 for (p1 = sp + 1, p2 = p + 1; (*p1++ = *p2++) != '\0';)
1029 continue;
1030 p = sp;
1031 }
1032 else if (cp == sp)
1033 *++sp = '\0';
1034 else
1035 *sp = '\0';
1036 }
1037 else { /* normal dir name (not . or .. or nothing) */
1038
1039#ifdef S_IFLNK /* if we have symlinks */
1040 if (sp != cp && symlinks == SYM_CHASE &&
1041 (tlink = areadlink(short2str(cp))) != NULL) {
1042 mlink = str2short(tlink);
1043 xfree(tlink);
1044
1045 /*
1046 * restore the '/'.
1047 */
1048 if (slash)
1049 *p = '/';
1050
1051 /*
1052 * point sp to p (rather than backing up).
1053 */
1054 sp = p;
1055
1056 if (*mlink != '/') {
1057 /*
1058 * Relative path, expand it between the "yyy/" and the
1059 * remainder. First, back sp up to the character past
1060 * "yyy/".
1061 */
1062 while (*--sp != '/')
1063 continue;
1064 sp++;
1065 *sp = 0;
1066 /*
1067 * New length is "yyy/" + mlink + "/.." and rest
1068 */
1069 p1 = newcp = xmalloc(((sp - cp) + Strlen(mlink) +
1070 Strlen(p) + 1) * sizeof(Char));
1071 /*
1072 * Copy new path into newcp
1073 */
1074 for (p2 = cp; (*p1++ = *p2++) != '\0';)
1075 continue;
1076 for (p1--, p2 = mlink; (*p1++ = *p2++) != '\0';)
1077 continue;
1078 for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
1079 continue;
1080 /*
1081 * Restart canonicalization at expanded "/xxx".
1082 */
1083 p = sp - cp - 1 + newcp;
1084 }
1085 else {
1086 newcp = Strspl(mlink, p);
1087 /*
1088 * Restart canonicalization at beginning
1089 */
1090 p = newcp;
1091 }
1092 xfree(cp);
1093 cp = newcp;
1094#ifdef HAVE_SLASHSLASH
1095 slashslash = (cp[0] == '/' && cp[1] == '/');
1096#endif /* HAVE_SLASHSLASH */
1097 continue; /* canonicalize the mlink */
1098 }
1099#endif /* S_IFLNK */
1100 if (slash)
1101 *p = '/';
1102 }
1103 }
1104
1105 /*
1106 * fix home...
1107 */
1108#ifdef S_IFLNK
1109 p1 = varval(STRhome);
1110 cc = Strlen(p1);
1111 /*
1112 * See if we're not in a subdir of STRhome
1113 */
1114 if (p1 && *p1 == '/' && (Strncmp(p1, cp, cc) != 0 ||
1115 (cp[cc] != '/' && cp[cc] != '\0'))) {
1116 static ino_t home_ino = (ino_t) -1;
1117 static dev_t home_dev = (dev_t) -1;
1118 static Char *home_ptr = NULL;
1119 struct stat statbuf;
1120 int found;
1121 Char *copy;
1122
1123 /*
1124 * Get dev and ino of STRhome
1125 */
1126 if (home_ptr != p1 &&
1127 stat(short2str(p1), &statbuf) != -1) {
1128 home_dev = statbuf.st_dev;
1129 home_ino = statbuf.st_ino;
1130 home_ptr = p1;
1131 }
1132 /*
1133 * Start comparing dev & ino backwards
1134 */
1135 p2 = copy = Strsave(cp);
1136 found = 0;
1137 while (*p2 && stat(short2str(p2), &statbuf) != -1) {
1138 if (DEV_DEV_COMPARE(statbuf.st_dev, home_dev) &&
1139 statbuf.st_ino == home_ino) {
1140 found = 1;
1141 break;
1142 }
1143 if ((sp = Strrchr(p2, '/')) != NULL)
1144 *sp = '\0';
1145 }
1146 /*
1147 * See if we found it
1148 */
1149 if (*p2 && found) {
1150 /*
1151 * Use STRhome to make '~' work
1152 */
1153 newcp = Strspl(p1, cp + Strlen(p2));
1154 xfree(cp);
1155 cp = newcp;
1156 }
1157 xfree(copy);
1158 }
1159#endif /* S_IFLNK */
1160
1161#ifdef HAVE_SLASHSLASH
1162 if (slashslash) {
1163 if (cp[1] != '/') {
1164 p = xmalloc((Strlen(cp) + 2) * sizeof(Char));
1165 *p = '/';
1166 (void) Strcpy(&p[1], cp);
1167 xfree(cp);
1168 cp = p;
1169 }
1170 }
1171 if (cp[1] == '/' && cp[2] == '/') {
1172 for (p1 = &cp[1], p2 = &cp[2]; (*p1++ = *p2++) != '\0';)
1173 continue;
1174 }
1175#endif /* HAVE_SLASHSLASH */
1176 return cp;
1177}
1178
1179
1180/*
1181 * dnewcwd - make a new directory in the loop the current one
1182 */
1183static void
1184dnewcwd(struct directory *dp, int dflag)
1185{
1186 int print;
1187
1188 if (adrof(STRdunique)) {
1189 struct directory *dn;
1190
1191 for (dn = dhead.di_prev; dn != &dhead; dn = dn->di_prev)
1192 if (dn != dp && Strcmp(dn->di_name, dp->di_name) == 0) {
1193 dn->di_next->di_prev = dn->di_prev;
1194 dn->di_prev->di_next = dn->di_next;
1195 dfree(dn);
1196 break;
1197 }
1198 }
1199 dcwd = dp;
1200 dset(dcwd->di_name);
1201 dgetstack();
1202 print = printd; /* if printd is set, print dirstack... */
1203 if (adrof(STRpushdsilent)) /* but pushdsilent overrides printd... */
1204 print = 0;
1205 if (dflag & DIR_PRINT) /* but DIR_PRINT overrides pushdsilent... */
1206 print = 1;
1207 if (bequiet) /* and bequiet overrides everything */
1208 print = 0;
1209 if (print)
1210 printdirs(dflag);
1211 cwd_cmd(); /* PWP: run the defined cwd command */
1212}
1213
1214void
1215dsetstack(void)
1216{
1217 Char **cp;
1218 struct varent *vp;
1219 struct directory *dn, *dp;
1220
1221 if ((vp = adrof(STRdirstack)) == NULL || vp->vec == NULL)
1222 return;
1223
1224 /* Free the whole stack */
1225 while ((dn = dhead.di_prev) != &dhead) {
1226 dn->di_next->di_prev = dn->di_prev;
1227 dn->di_prev->di_next = dn->di_next;
1228 if (dn != dcwd)
1229 dfree(dn);
1230 }
1231
1232 /* thread the current working directory */
1233 dhead.di_prev = dhead.di_next = dcwd;
1234 dcwd->di_next = dcwd->di_prev = &dhead;
1235
1236 /* put back the stack */
1237 for (cp = vp->vec; cp && *cp && **cp; cp++) {
1238 dp = xcalloc(sizeof(struct directory), 1);
1239 dp->di_name = Strsave(*cp);
1240 dp->di_count = 0;
1241 dp->di_prev = dcwd;
1242 dp->di_next = dcwd->di_next;
1243 dcwd->di_next = dp;
1244 dp->di_next->di_prev = dp;
1245 }
1246 dgetstack(); /* Make $dirstack reflect the current state */
1247}
1248
1249static void
1250dgetstack(void)
1251{
1252 int i = 0;
1253 Char **dblk, **dbp;
1254 struct directory *dn;
1255
1256 if (adrof(STRdirstack) == NULL)
1257 return;
1258
1259 for (dn = dhead.di_prev; dn != &dhead; dn = dn->di_prev, i++)
1260 continue;
1261 dbp = dblk = xmalloc((i + 1) * sizeof(Char *));
1262 for (dn = dhead.di_prev; dn != &dhead; dn = dn->di_prev, dbp++)
1263 *dbp = Strsave(dn->di_name);
1264 *dbp = NULL;
1265 cleanup_push(dblk, blk_cleanup);
1266 setq(STRdirstack, dblk, &shvhed, VAR_READWRITE);
1267 cleanup_ignore(dblk);
1268 cleanup_until(dblk);
1269}
1270
1271/*
1272 * getstakd - added by kfk 17 Jan 1984
1273 * Support routine for the stack hack. Finds nth directory in
1274 * the directory stack, or finds last directory in stack.
1275 */
1276const Char *
1277getstakd(int cnt)
1278{
1279 struct directory *dp;
1280
1281 dp = dcwd;
1282 if (cnt < 0) { /* < 0 ==> last dir requested. */
1283 dp = dp->di_next;
1284 if (dp == &dhead)
1285 dp = dp->di_next;
1286 }
1287 else {
1288 while (cnt-- > 0) {
1289 dp = dp->di_prev;
1290 if (dp == &dhead)
1291 dp = dp->di_prev;
1292 if (dp == dcwd)
1293 return NULL;
1294 }
1295 }
1296 return dp->di_name;
1297}
1298
1299/*
1300 * Karl Kleinpaste - 10 Feb 1984
1301 * Added dextract(), which is used in pushd +n.
1302 * Instead of just rotating the entire stack around, dextract()
1303 * lets the user have the nth dir extracted from its current
1304 * position, and pushes it onto the top.
1305 */
1306static void
1307dextract(struct directory *dp)
1308{
1309 if (dp == dcwd)
1310 return;
1311 dp->di_next->di_prev = dp->di_prev;
1312 dp->di_prev->di_next = dp->di_next;
1313 dp->di_next = dcwd->di_next;
1314 dp->di_prev = dcwd;
1315 dp->di_next->di_prev = dp;
1316 dcwd->di_next = dp;
1317}
1318
1319static void
1320bequiet_cleanup(void *dummy)
1321{
1322 USE(dummy);
1323 bequiet = 0;
1324}
1325
1326void
1327loaddirs(Char *fname)
1328{
1329 static Char *loaddirs_cmd[] = { STRsource, NULL, NULL };
1330
1331 bequiet = 1;
1332 cleanup_push(&bequiet, bequiet_cleanup);
1333 if (fname)
1334 loaddirs_cmd[1] = fname;
1335 else if ((fname = varval(STRdirsfile)) != STRNULL)
1336 loaddirs_cmd[1] = fname;
1337 else
1338 loaddirs_cmd[1] = STRtildotdirs;
1339 dosource(loaddirs_cmd, NULL);
1340 cleanup_until(&bequiet);
1341}
1342
1343/*
1344 * create a file called ~/.cshdirs which has a sequence
1345 * of pushd commands which will restore the dir stack to
1346 * its state before exit/logout. remember that the order
1347 * is reversed in the file because we are pushing.
1348 * -strike
1349 */
1350void
1351recdirs(Char *fname, int def)
1352{
1353 int fp, ftmp, oldidfds;
1354 int cdflag = 0;
1355 struct directory *dp;
1356 unsigned int num;
1357 Char *snum;
1358 struct Strbuf qname = Strbuf_INIT;
1359
1360 if (fname == NULL && !def)
1361 return;
1362
1363 if (fname == NULL) {
1364 if ((fname = varval(STRdirsfile)) == STRNULL)
1365 fname = Strspl(varval(STRhome), &STRtildotdirs[1]);
1366 else
1367 fname = Strsave(fname);
1368 }
1369 else
1370 fname = globone(fname, G_ERROR);
1371 cleanup_push(fname, xfree);
1372
1373 if ((fp = xcreat(short2str(fname), 0600)) == -1) {
1374 cleanup_until(fname);
1375 return;
1376 }
1377
1378 if ((snum = varval(STRsavedirs)) == STRNULL || snum[0] == '\0')
1379 num = (unsigned int) ~0;
1380 else
1381 num = (unsigned int) atoi(short2str(snum));
1382
1383 oldidfds = didfds;
1384 didfds = 0;
1385 ftmp = SHOUT;
1386 SHOUT = fp;
1387
1388 cleanup_push(&qname, Strbuf_cleanup);
1389 dp = dcwd->di_next;
1390 do {
1391 if (dp == &dhead)
1392 continue;
1393
1394 if (cdflag == 0) {
1395 cdflag = 1;
1396 xprintf("cd %S\n", quote_meta(&qname, dp->di_name));
1397 }
1398 else
1399 xprintf("pushd %S\n", quote_meta(&qname, dp->di_name));
1400
1401 if (num-- == 0)
1402 break;
1403
1404 } while ((dp = dp->di_next) != dcwd->di_next);
1405
1406 xclose(fp);
1407 SHOUT = ftmp;
1408 didfds = oldidfds;
1409 cleanup_until(fname);
1410}