1 /*-
2 * Copyright (c) 1980, 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. 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
34 #ifndef lint
35 #if 0
36 static char sccsid[] = "@(#)dir.c 8.1 (Berkeley) 5/31/93";
37 #else
38 static const char rcsid[] =
39 "$FreeBSD$";
40 #endif
41 #endif /* not lint */
42
43 #include <sys/param.h>
44 #include <sys/stat.h>
45 #include <errno.h>
46 #include <stdlib.h>
47 #include <string.h>
48 #include <unistd.h>
49 #if __STDC__
50 # include <stdarg.h>
51 #else
52 # include <varargs.h>
53 #endif
54
55 #include "csh.h"
56 #include "dir.h"
57 #include "extern.h"
58
59 /* Directory management. */
60
61 static struct directory
62 *dfind __P((Char *));
63 static Char *dfollow __P((Char *));
64 static void printdirs __P((void));
65 static Char *dgoto __P((Char *));
66 static void dnewcwd __P((struct directory *));
67 static void dset __P((Char *));
68
69 struct directory dhead; /* "head" of loop */
70 int printd; /* force name to be printed */
71
72 static int dirflag = 0;
73
74 /*
75 * dinit - initialize current working directory
76 */
77 void
dinit(hp)78 dinit(hp)
79 Char *hp;
80 {
81 char *tcp;
82 Char *cp;
83 struct directory *dp;
84 char path[MAXPATHLEN];
85 static char *emsg = "csh: Trying to start from \"%s\"\n";
86
87 /* Don't believe the login shell home, because it may be a symlink */
88 tcp = getcwd(path, MAXPATHLEN); /* see ngetwd.c for System V version */
89 if (tcp == NULL || *tcp == '\0') {
90 (void) fprintf(csherr, "csh: %s: %s\n", path, strerror(errno));
91 if (hp && *hp) {
92 tcp = short2str(hp);
93 if (chdir(tcp) == -1)
94 cp = NULL;
95 else
96 cp = hp;
97 (void) fprintf(csherr, emsg, vis_str(hp));
98 }
99 else
100 cp = NULL;
101 if (cp == NULL) {
102 (void) fprintf(csherr, emsg, "/");
103 if (chdir("/") == -1)
104 /* I am not even try to print an error message! */
105 xexit(1);
106 cp = SAVE("/");
107 }
108 }
109 else {
110 struct stat swd, shp;
111
112 /*
113 * See if $HOME is the working directory we got and use that
114 */
115 if (hp && *hp &&
116 stat(tcp, &swd) != -1 && stat(short2str(hp), &shp) != -1 &&
117 swd.st_dev == shp.st_dev && swd.st_ino == shp.st_ino)
118 cp = hp;
119 else {
120 char *cwd;
121
122 /*
123 * use PWD if we have it (for subshells)
124 */
125 if ((cwd = getenv("PWD")) != NULL) {
126 if (stat(cwd, &shp) != -1 && swd.st_dev == shp.st_dev &&
127 swd.st_ino == shp.st_ino)
128 tcp = cwd;
129 }
130 cp = dcanon(SAVE(tcp), STRNULL);
131 }
132 }
133
134 dp = (struct directory *) xcalloc(sizeof(struct directory), 1);
135 dp->di_name = Strsave(cp);
136 dp->di_count = 0;
137 dhead.di_next = dhead.di_prev = dp;
138 dp->di_next = dp->di_prev = &dhead;
139 printd = 0;
140 dnewcwd(dp);
141 }
142
143 static void
dset(dp)144 dset(dp)
145 Char *dp;
146 {
147 /*
148 * Don't call set() directly cause if the directory contains ` or
149 * other junk characters glob will fail.
150 */
151 Char **vec = (Char **) xmalloc((size_t) (2 * sizeof(Char **)));
152
153 vec[0] = Strsave(dp);
154 vec[1] = 0;
155 setq(STRcwd, vec, &shvhed);
156 Setenv(STRPWD, dp);
157 }
158
159 #define DIR_LONG 1
160 #define DIR_VERT 2
161 #define DIR_LINE 4
162
163 static void
skipargs(v,str)164 skipargs(v, str)
165 Char ***v;
166 char *str;
167 {
168 Char **n = *v, *s;
169
170 dirflag = 0;
171 for (n++; *n != NULL && (*n)[0] == '-'; n++)
172 for (s = &((*n)[1]); *s; s++)
173 switch (*s) {
174 case 'l':
175 dirflag |= DIR_LONG;
176 break;
177 case 'v':
178 dirflag |= DIR_VERT;
179 break;
180 case 'n':
181 dirflag |= DIR_LINE;
182 break;
183 default:
184 stderror(ERR_DIRUS, vis_str(**v), str);
185 break;
186 }
187 *v = n;
188 }
189
190 /*
191 * dodirs - list all directories in directory loop
192 */
193 void
194 /*ARGSUSED*/
dodirs(v,t)195 dodirs(v, t)
196 Char **v;
197 struct command *t;
198 {
199 skipargs(&v, "");
200
201 if (*v != NULL)
202 stderror(ERR_DIRUS, "dirs", "");
203 printdirs();
204 }
205
206 static void
printdirs()207 printdirs()
208 {
209 struct directory *dp;
210 Char *s, *hp = value(STRhome);
211 int idx, len, cur;
212
213 if (*hp == '\0')
214 hp = NULL;
215 dp = dcwd;
216 idx = 0;
217 cur = 0;
218 do {
219 if (dp == &dhead)
220 continue;
221 if (dirflag & DIR_VERT) {
222 (void) fprintf(cshout, "%d\t", idx++);
223 cur = 0;
224 }
225 if (!(dirflag & DIR_LONG) && hp != NULL && !eq(hp, STRslash) &&
226 (len = Strlen(hp), Strncmp(hp, dp->di_name, len) == 0) &&
227 (dp->di_name[len] == '\0' || dp->di_name[len] == '/'))
228 len = Strlen(s = (dp->di_name + len)) + 2;
229 else
230 len = Strlen(s = dp->di_name) + 1;
231
232 cur += len;
233 if ((dirflag & DIR_LINE) && cur >= 80 - 1 && len < 80) {
234 (void) fprintf(cshout, "\n");
235 cur = len;
236 }
237 (void) fprintf(cshout, s != dp->di_name ? "~%s%c" : "%s%c",
238 vis_str(s), (dirflag & DIR_VERT) ? '\n' : ' ');
239 } while ((dp = dp->di_prev) != dcwd);
240 if (!(dirflag & DIR_VERT))
241 (void) fprintf(cshout, "\n");
242 }
243
244 void
dtildepr(home,dir)245 dtildepr(home, dir)
246 Char *home, *dir;
247 {
248
249 if (!eq(home, STRslash) && prefix(home, dir))
250 (void) fprintf(cshout, "~%s", vis_str(dir + Strlen(home)));
251 else
252 (void) fprintf(cshout, "%s", vis_str(dir));
253 }
254
255 void
dtilde()256 dtilde()
257 {
258 struct directory *d = dcwd;
259
260 do {
261 if (d == &dhead)
262 continue;
263 d->di_name = dcanon(d->di_name, STRNULL);
264 } while ((d = d->di_prev) != dcwd);
265
266 dset(dcwd->di_name);
267 }
268
269
270 /* dnormalize():
271 * If the name starts with . or .. then we might need to normalize
272 * it depending on the symbolic link flags
273 */
274 Char *
dnormalize(cp)275 dnormalize(cp)
276 Char *cp;
277 {
278
279 #define UC (unsigned char)
280 #define ISDOT(c) (UC(c)[0] == '.' && ((UC(c)[1] == '\0') || (UC(c)[1] == '/')))
281 #define ISDOTDOT(c) (UC(c)[0] == '.' && ISDOT(&((c)[1])))
282
283 if ((unsigned char) cp[0] == '/')
284 return (Strsave(cp));
285
286 if (adrof(STRignore_symlinks)) {
287 int dotdot = 0;
288 Char *dp, *cwd;
289
290 cwd = (Char *) xmalloc((size_t) ((Strlen(dcwd->di_name) + 3) *
291 sizeof(Char)));
292 (void) Strcpy(cwd, dcwd->di_name);
293
294 /*
295 * Ignore . and count ..'s
296 */
297 while (*cp) {
298 if (ISDOT(cp)) {
299 if (*++cp)
300 cp++;
301 }
302 else if (ISDOTDOT(cp)) {
303 dotdot++;
304 cp += 2;
305 if (*cp)
306 cp++;
307 }
308 else
309 break;
310 }
311 while (dotdot > 0)
312 if ((dp = Strrchr(cwd, '/'))) {
313 *dp = '\0';
314 dotdot--;
315 }
316 else
317 break;
318
319 if (*cp) {
320 cwd[dotdot = Strlen(cwd)] = '/';
321 cwd[dotdot + 1] = '\0';
322 dp = Strspl(cwd, cp);
323 xfree((ptr_t) cwd);
324 return dp;
325 }
326 else {
327 if (!*cwd) {
328 cwd[0] = '/';
329 cwd[1] = '\0';
330 }
331 return cwd;
332 }
333 }
334 return Strsave(cp);
335 }
336
337 /*
338 * dochngd - implement chdir command.
339 */
340 void
341 /*ARGSUSED*/
dochngd(v,t)342 dochngd(v, t)
343 Char **v;
344 struct command *t;
345 {
346 Char *cp;
347 struct directory *dp;
348
349 skipargs(&v, " [<dir>]");
350 printd = 0;
351 if (*v == NULL) {
352 if ((cp = value(STRhome)) == NULL || *cp == 0)
353 stderror(ERR_NAME | ERR_NOHOMEDIR);
354 if (chdir(short2str(cp)) < 0)
355 stderror(ERR_NAME | ERR_CANTCHANGE);
356 cp = Strsave(cp);
357 }
358 else if (v[1] != NULL) {
359 stderror(ERR_NAME | ERR_TOOMANY);
360 /* NOTREACHED */
361 return;
362 }
363 else if ((dp = dfind(*v)) != 0) {
364 char *tmp;
365
366 printd = 1;
367 if (chdir(tmp = short2str(dp->di_name)) < 0)
368 stderror(ERR_SYSTEM, tmp, strerror(errno));
369 dcwd->di_prev->di_next = dcwd->di_next;
370 dcwd->di_next->di_prev = dcwd->di_prev;
371 dfree(dcwd);
372 dnewcwd(dp);
373 return;
374 }
375 else
376 cp = dfollow(*v);
377 dp = (struct directory *) xcalloc(sizeof(struct directory), 1);
378 dp->di_name = cp;
379 dp->di_count = 0;
380 dp->di_next = dcwd->di_next;
381 dp->di_prev = dcwd->di_prev;
382 dp->di_prev->di_next = dp;
383 dp->di_next->di_prev = dp;
384 dfree(dcwd);
385 dnewcwd(dp);
386 }
387
388 static Char *
dgoto(cp)389 dgoto(cp)
390 Char *cp;
391 {
392 Char *dp;
393
394 if (*cp != '/') {
395 Char *p, *q;
396 int cwdlen;
397
398 for (p = dcwd->di_name; *p++;)
399 continue;
400 if ((cwdlen = p - dcwd->di_name - 1) == 1) /* root */
401 cwdlen = 0;
402 for (p = cp; *p++;)
403 continue;
404 dp = (Char *) xmalloc((size_t)((cwdlen + (p - cp) + 1) * sizeof(Char)));
405 for (p = dp, q = dcwd->di_name; (*p++ = *q++) != '\0';)
406 continue;
407 if (cwdlen)
408 p[-1] = '/';
409 else
410 p--; /* don't add a / after root */
411 for (q = cp; (*p++ = *q++) != '\0';)
412 continue;
413 xfree((ptr_t) cp);
414 cp = dp;
415 dp += cwdlen;
416 }
417 else
418 dp = cp;
419
420 cp = dcanon(cp, dp);
421 return cp;
422 }
423
424 /*
425 * dfollow - change to arg directory; fall back on cdpath if not valid
426 */
427 static Char *
dfollow(cp)428 dfollow(cp)
429 Char *cp;
430 {
431 Char *dp;
432 struct varent *c;
433 char ebuf[MAXPATHLEN];
434 int serrno;
435
436 cp = globone(cp, G_ERROR);
437 /*
438 * if we are ignoring symlinks, try to fix relatives now.
439 */
440 dp = dnormalize(cp);
441 if (chdir(short2str(dp)) >= 0) {
442 xfree((ptr_t) cp);
443 return dgoto(dp);
444 }
445 else {
446 xfree((ptr_t) dp);
447 if (chdir(short2str(cp)) >= 0)
448 return dgoto(cp);
449 serrno = errno;
450 }
451
452 if (cp[0] != '/' && !prefix(STRdotsl, cp) && !prefix(STRdotdotsl, cp)
453 && (c = adrof(STRcdpath))) {
454 Char **cdp;
455 Char *p;
456 Char buf[MAXPATHLEN];
457
458 for (cdp = c->vec; *cdp; cdp++) {
459 for (dp = buf, p = *cdp; (*dp++ = *p++) != '\0';)
460 continue;
461 dp[-1] = '/';
462 for (p = cp; (*dp++ = *p++) != '\0';)
463 continue;
464 if (chdir(short2str(buf)) >= 0) {
465 printd = 1;
466 xfree((ptr_t) cp);
467 cp = Strsave(buf);
468 return dgoto(cp);
469 }
470 }
471 }
472 dp = value(cp);
473 if ((dp[0] == '/' || dp[0] == '.') && chdir(short2str(dp)) >= 0) {
474 xfree((ptr_t) cp);
475 cp = Strsave(dp);
476 printd = 1;
477 return dgoto(cp);
478 }
479 (void) strcpy(ebuf, short2str(cp));
480 xfree((ptr_t) cp);
481 stderror(ERR_SYSTEM, ebuf, strerror(serrno));
482 return (NULL);
483 }
484
485
486 /*
487 * dopushd - push new directory onto directory stack.
488 * with no arguments exchange top and second.
489 * with numeric argument (+n) bring it to top.
490 */
491 void
492 /*ARGSUSED*/
dopushd(v,t)493 dopushd(v, t)
494 Char **v;
495 struct command *t;
496 {
497 struct directory *dp;
498
499 skipargs(&v, " [<dir>|+<n>]");
500 printd = 1;
501 if (*v == NULL) {
502 char *tmp;
503
504 if ((dp = dcwd->di_prev) == &dhead)
505 dp = dhead.di_prev;
506 if (dp == dcwd)
507 stderror(ERR_NAME | ERR_NODIR);
508 if (chdir(tmp = short2str(dp->di_name)) < 0)
509 stderror(ERR_SYSTEM, tmp, strerror(errno));
510 dp->di_prev->di_next = dp->di_next;
511 dp->di_next->di_prev = dp->di_prev;
512 dp->di_next = dcwd->di_next;
513 dp->di_prev = dcwd;
514 dcwd->di_next->di_prev = dp;
515 dcwd->di_next = dp;
516 }
517 else if (v[1] != NULL) {
518 stderror(ERR_NAME | ERR_TOOMANY);
519 /* NOTREACHED */
520 return;
521 }
522 else if ((dp = dfind(*v)) != NULL) {
523 char *tmp;
524
525 if (chdir(tmp = short2str(dp->di_name)) < 0)
526 stderror(ERR_SYSTEM, tmp, strerror(errno));
527 }
528 else {
529 Char *ccp;
530
531 ccp = dfollow(*v);
532 dp = (struct directory *) xcalloc(sizeof(struct directory), 1);
533 dp->di_name = ccp;
534 dp->di_count = 0;
535 dp->di_prev = dcwd;
536 dp->di_next = dcwd->di_next;
537 dcwd->di_next = dp;
538 dp->di_next->di_prev = dp;
539 }
540 dnewcwd(dp);
541 }
542
543 /*
544 * dfind - find a directory if specified by numeric (+n) argument
545 */
546 static struct directory *
dfind(cp)547 dfind(cp)
548 Char *cp;
549 {
550 struct directory *dp;
551 int i;
552 Char *ep;
553
554 if (*cp++ != '+')
555 return (0);
556 for (ep = cp; Isdigit(*ep); ep++)
557 continue;
558 if (*ep)
559 return (0);
560 i = getn(cp);
561 if (i <= 0)
562 return (0);
563 for (dp = dcwd; i != 0; i--) {
564 if ((dp = dp->di_prev) == &dhead)
565 dp = dp->di_prev;
566 if (dp == dcwd)
567 stderror(ERR_NAME | ERR_DEEP);
568 }
569 return (dp);
570 }
571
572 /*
573 * dopopd - pop a directory out of the directory stack
574 * with a numeric argument just discard it.
575 */
576 void
577 /*ARGSUSED*/
dopopd(v,t)578 dopopd(v, t)
579 Char **v;
580 struct command *t;
581 {
582 struct directory *dp, *p = NULL;
583
584 skipargs(&v, " [+<n>]");
585 printd = 1;
586 if (*v == NULL)
587 dp = dcwd;
588 else if (v[1] != NULL) {
589 stderror(ERR_NAME | ERR_TOOMANY);
590 /* NOTREACHED */
591 return;
592 }
593 else if ((dp = dfind(*v)) == 0)
594 stderror(ERR_NAME | ERR_BADDIR);
595 if (dp->di_prev == &dhead && dp->di_next == &dhead)
596 stderror(ERR_NAME | ERR_EMPTY);
597 if (dp == dcwd) {
598 char *tmp;
599
600 if ((p = dp->di_prev) == &dhead)
601 p = dhead.di_prev;
602 if (chdir(tmp = short2str(p->di_name)) < 0)
603 stderror(ERR_SYSTEM, tmp, strerror(errno));
604 }
605 dp->di_prev->di_next = dp->di_next;
606 dp->di_next->di_prev = dp->di_prev;
607 if (dp == dcwd)
608 dnewcwd(p);
609 else {
610 printdirs();
611 }
612 dfree(dp);
613 }
614
615 /*
616 * dfree - free the directory (or keep it if it still has ref count)
617 */
618 void
dfree(dp)619 dfree(dp)
620 struct directory *dp;
621 {
622
623 if (dp->di_count != 0) {
624 dp->di_next = dp->di_prev = 0;
625 }
626 else {
627 xfree((char *) dp->di_name);
628 xfree((ptr_t) dp);
629 }
630 }
631
632 /*
633 * dcanon - canonicalize the pathname, removing excess ./ and ../ etc.
634 * we are of course assuming that the file system is standardly
635 * constructed (always have ..'s, directories have links)
636 */
637 Char *
dcanon(cp,p)638 dcanon(cp, p)
639 Char *cp, *p;
640 {
641 Char *sp;
642 Char *p1, *p2; /* general purpose */
643 bool slash;
644
645 Char link[MAXPATHLEN];
646 char tlink[MAXPATHLEN];
647 int cc;
648 Char *newcp;
649
650 /*
651 * christos: if the path given does not start with a slash prepend cwd. If
652 * cwd does not start with a path or the result would be too long abort().
653 */
654 if (*cp != '/') {
655 Char tmpdir[MAXPATHLEN];
656
657 p1 = value(STRcwd);
658 if (p1 == NULL || *p1 != '/')
659 abort();
660 if (Strlen(p1) + Strlen(cp) + 1 >= MAXPATHLEN)
661 abort();
662 (void) Strcpy(tmpdir, p1);
663 (void) Strcat(tmpdir, STRslash);
664 (void) Strcat(tmpdir, cp);
665 xfree((ptr_t) cp);
666 cp = p = Strsave(tmpdir);
667 }
668
669 while (*p) { /* for each component */
670 sp = p; /* save slash address */
671 while (*++p == '/') /* flush extra slashes */
672 continue;
673 if (p != ++sp)
674 for (p1 = sp, p2 = p; (*p1++ = *p2++) != '\0';)
675 continue;
676 p = sp; /* save start of component */
677 slash = 0;
678 while (*++p) /* find next slash or end of path */
679 if (*p == '/') {
680 slash = 1;
681 *p = 0;
682 break;
683 }
684
685 if (*sp == '\0') /* if component is null */
686 if (--sp == cp) /* if path is one char (i.e. /) */
687 break;
688 else
689 *sp = '\0';
690 else if (sp[0] == '.' && sp[1] == 0) {
691 if (slash) {
692 for (p1 = sp, p2 = p + 1; (*p1++ = *p2++) != '\0';)
693 continue;
694 p = --sp;
695 }
696 else if (--sp != cp)
697 *sp = '\0';
698 }
699 else if (sp[0] == '.' && sp[1] == '.' && sp[2] == 0) {
700 /*
701 * We have something like "yyy/xxx/..", where "yyy" can be null or
702 * a path starting at /, and "xxx" is a single component. Before
703 * compressing "xxx/..", we want to expand "yyy/xxx", if it is a
704 * symbolic link.
705 */
706 *--sp = 0; /* form the pathname for readlink */
707 if (sp != cp && !adrof(STRignore_symlinks) &&
708 (cc = readlink(short2str(cp), tlink, sizeof(tlink) - 1)) >= 0) {
709 (void) Strcpy(link, str2short(tlink));
710 link[cc] = '\0';
711
712 if (slash)
713 *p = '/';
714 /*
715 * Point p to the '/' in "/..", and restore the '/'.
716 */
717 *(p = sp) = '/';
718 /*
719 * find length of p
720 */
721 for (p1 = p; *p1++;)
722 continue;
723 if (*link != '/') {
724 /*
725 * Relative path, expand it between the "yyy/" and the
726 * "/..". First, back sp up to the character past "yyy/".
727 */
728 while (*--sp != '/')
729 continue;
730 sp++;
731 *sp = 0;
732 /*
733 * New length is "yyy/" + link + "/.." and rest
734 */
735 p1 = newcp = (Char *) xmalloc((size_t)
736 (((sp - cp) + cc + (p1 - p)) *
737 sizeof(Char)));
738 /*
739 * Copy new path into newcp
740 */
741 for (p2 = cp; (*p1++ = *p2++) != '\0';)
742 continue;
743 for (p1--, p2 = link; (*p1++ = *p2++) != '\0';)
744 continue;
745 for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
746 continue;
747 /*
748 * Restart canonicalization at expanded "/xxx".
749 */
750 p = sp - cp - 1 + newcp;
751 }
752 else {
753 /*
754 * New length is link + "/.." and rest
755 */
756 p1 = newcp = (Char *) xmalloc((size_t)
757 ((cc + (p1 - p)) * sizeof(Char)));
758 /*
759 * Copy new path into newcp
760 */
761 for (p2 = link; (*p1++ = *p2++) != '\0';)
762 continue;
763 for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
764 continue;
765 /*
766 * Restart canonicalization at beginning
767 */
768 p = newcp;
769 }
770 xfree((ptr_t) cp);
771 cp = newcp;
772 continue; /* canonicalize the link */
773 }
774 *sp = '/';
775 if (sp != cp)
776 while (*--sp != '/')
777 continue;
778 if (slash) {
779 for (p1 = sp + 1, p2 = p + 1; (*p1++ = *p2++) != '\0';)
780 continue;
781 p = sp;
782 }
783 else if (cp == sp)
784 *++sp = '\0';
785 else
786 *sp = '\0';
787 }
788 else { /* normal dir name (not . or .. or nothing) */
789
790 if (sp != cp && adrof(STRchase_symlinks) &&
791 !adrof(STRignore_symlinks) &&
792 (cc = readlink(short2str(cp), tlink, sizeof(tlink) - 1)) >= 0) {
793 (void) Strcpy(link, str2short(tlink));
794 link[cc] = '\0';
795
796 /*
797 * restore the '/'.
798 */
799 if (slash)
800 *p = '/';
801
802 /*
803 * point sp to p (rather than backing up).
804 */
805 sp = p;
806
807 /*
808 * find length of p
809 */
810 for (p1 = p; *p1++;)
811 continue;
812 if (*link != '/') {
813 /*
814 * Relative path, expand it between the "yyy/" and the
815 * remainder. First, back sp up to the character past
816 * "yyy/".
817 */
818 while (*--sp != '/')
819 continue;
820 sp++;
821 *sp = 0;
822 /*
823 * New length is "yyy/" + link + "/.." and rest
824 */
825 p1 = newcp = (Char *) xmalloc((size_t)
826 (((sp - cp) + cc + (p1 - p))
827 * sizeof(Char)));
828 /*
829 * Copy new path into newcp
830 */
831 for (p2 = cp; (*p1++ = *p2++) != '\0';)
832 continue;
833 for (p1--, p2 = link; (*p1++ = *p2++) != '\0';)
834 continue;
835 for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
836 continue;
837 /*
838 * Restart canonicalization at expanded "/xxx".
839 */
840 p = sp - cp - 1 + newcp;
841 }
842 else {
843 /*
844 * New length is link + the rest
845 */
846 p1 = newcp = (Char *) xmalloc((size_t)
847 ((cc + (p1 - p)) * sizeof(Char)));
848 /*
849 * Copy new path into newcp
850 */
851 for (p2 = link; (*p1++ = *p2++) != '\0';)
852 continue;
853 for (p1--, p2 = p; (*p1++ = *p2++) != '\0';)
854 continue;
855 /*
856 * Restart canonicalization at beginning
857 */
858 p = newcp;
859 }
860 xfree((ptr_t) cp);
861 cp = newcp;
862 continue; /* canonicalize the link */
863 }
864 if (slash)
865 *p = '/';
866 }
867 }
868
869 /*
870 * fix home...
871 */
872 p1 = value(STRhome);
873 cc = Strlen(p1);
874 /*
875 * See if we're not in a subdir of STRhome
876 */
877 if (p1 && *p1 == '/' &&
878 (Strncmp(p1, cp, cc) != 0 || (cp[cc] != '/' && cp[cc] != '\0'))) {
879 static ino_t home_ino = -1;
880 static dev_t home_dev = -1;
881 static Char *home_ptr = NULL;
882 struct stat statbuf;
883
884 /*
885 * Get dev and ino of STRhome
886 */
887 if (home_ptr != p1 &&
888 stat(short2str(p1), &statbuf) != -1) {
889 home_dev = statbuf.st_dev;
890 home_ino = statbuf.st_ino;
891 home_ptr = p1;
892 }
893 /*
894 * Start comparing dev & ino backwards
895 */
896 p2 = Strcpy(link, cp);
897 for (sp = NULL; *p2 && stat(short2str(p2), &statbuf) != -1;) {
898 if (statbuf.st_dev == home_dev &&
899 statbuf.st_ino == home_ino) {
900 sp = (Char *) - 1;
901 break;
902 }
903 if ((sp = Strrchr(p2, '/')) != NULL)
904 *sp = '\0';
905 }
906 /*
907 * See if we found it
908 */
909 if (*p2 && sp == (Char *) -1) {
910 /*
911 * Use STRhome to make '~' work
912 */
913 newcp = Strspl(p1, cp + Strlen(p2));
914 xfree((ptr_t) cp);
915 cp = newcp;
916 }
917 }
918 return cp;
919 }
920
921
922 /*
923 * dnewcwd - make a new directory in the loop the current one
924 */
925 static void
dnewcwd(dp)926 dnewcwd(dp)
927 struct directory *dp;
928 {
929 dcwd = dp;
930 dset(dcwd->di_name);
931 if (printd && !(adrof(STRpushdsilent)))
932 printdirs();
933 }
934