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