1 /* $Header: /p/tcsh/cvsroot/tcsh/sh.dir.c,v 3.82 2011/10/16 16:25:05 christos Exp $ */
3 * sh.dir.c: Directory manipulation functions
6 * Copyright (c) 1980, 1991 The Regents of the University of California.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
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.
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
36 RCSID("$tcsh: sh.dir.c,v 3.82 2011/10/16 16:25:05 christos Exp $")
39 * C Shell - directory management
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 *,
53 static void dgetstack (void);
55 static struct directory dhead INIT_ZERO_STRUCT
; /* "head" of loop */
56 static int printd
; /* force name to be printed */
58 int bequiet
= 0; /* do not print dir stack -strike */
69 while (getcwd(buf
, len
) == NULL
) {
79 buf
= xrealloc(buf
, len
);
91 dstart(const char *from
)
93 xprintf(CGETS(12, 1, "%s: Trying to start from \"%s\"\n"), progname
, from
);
97 * dinit - initialize current working directory
103 struct directory
*dp
;
105 /* Don't believe the login shell home, because it may be a symlink */
108 xprintf("%s: %s\n", progname
, strerror(errno
));
110 char *xcp
= short2str(hp
);
112 if (chdir(xcp
) == -1)
121 if (chdir("/") == -1)
122 /* I am not even try to print an error message! */
129 struct stat swd
, shp
;
132 swd_ok
= stat(short2str(tcp
), &swd
) == 0;
134 * See if $HOME is the working directory we got and use that
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
)
144 * use PWD if we have it (for subshells)
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
) {
151 cleanup_push(tcp
, xfree
);
154 cleanup_push(tcp
, xfree
);
155 cp
= dcanon(tcp
, STRNULL
);
160 cleanup_push(tcp
, xfree
);
161 cp
= dcanon(tcp
, STRNULL
);
167 dp
= xcalloc(sizeof(struct directory
), 1);
170 dhead
.di_next
= dhead
.di_prev
= dp
;
171 dp
->di_next
= dp
->di_prev
= &dhead
;
174 setcopy(STRdirstack
, dp
->di_name
, VAR_READWRITE
|VAR_NOGLOB
);
181 * Don't call set() directly cause if the directory contains ` or
182 * other junk characters glob will fail.
184 setcopy(STRowd
, varval(STRcwd
), VAR_READWRITE
|VAR_NOGLOB
);
185 setcopy(STRcwd
, dp
, VAR_READWRITE
|VAR_NOGLOB
);
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 /* - */
199 skipargs(Char
***v
, const char *dstr
, const char *str
)
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 */
207 else if ((*n
)[1] == '-' && (*n
)[2] == '\0') { /* test for -- */
212 while (*s
!= '\0') /* examine flags */ {
213 if ((p
= strchr(dstr
, *s
++)) != NULL
)
214 dflag
|= (1 << (p
- dstr
));
216 stderror(ERR_DIRUS
, short2str(**v
), dstr
, str
);
219 if (*n
&& (dflag
& DIR_OLD
))
220 stderror(ERR_DIRUS
, short2str(**v
), dstr
, str
);
222 /* make -l, -v, and -n imply -p */
223 if (dflag
& (DIR_LONG
|DIR_VERT
|DIR_LINE
))
229 * dodirs - list all directories in directory loop
233 dodirs(Char
**v
, struct command
*c
)
235 static const char flags
[] = "plvnSLc";
236 int dflag
= skipargs(&v
, flags
, "");
239 if ((dflag
& DIR_CLEAR
) != 0) {
240 struct directory
*dp
, *fdp
;
241 for (dp
= dcwd
->di_next
; dp
!= dcwd
; ) {
247 dhead
.di_next
= dhead
.di_prev
= dp
;
248 dp
->di_next
= dp
->di_prev
= &dhead
;
250 if ((dflag
& DIR_LOAD
) != 0)
252 else if ((dflag
& DIR_SAVE
) != 0)
255 if (*v
&& (dflag
& (DIR_SAVE
|DIR_LOAD
)))
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
))
267 struct directory
*dp
;
277 if (dflag
& DIR_VERT
) {
278 xprintf("%d\t", idx
++);
283 if (!(dflag
& DIR_LONG
) && (user
= getusername(&s
)) != NULL
)
284 len
= (int) (Strlen(user
) + Strlen(s
) + 2);
286 len
= (int) (Strlen(s
) + 1);
289 if ((dflag
& DIR_LINE
) && cur
>= TermH
- 1 && len
< TermH
) {
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
))
305 if ((user
= getusername(&dir
)) != NULL
)
306 xprintf("~%-S%S", user
, dir
);
314 struct directory
*d
= dcwd
;
319 d
->di_name
= dcanon(d
->di_name
, STRNULL
);
320 } while ((d
= d
->di_prev
) != dcwd
);
327 * The path will be normalized if it
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.
336 dnormalize(const Char
*cp
, int expnd
)
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) == '/'))
345 struct Strbuf buf
= Strbuf_INIT
;
348 const Char
*start
= cp
;
349 # ifdef HAVE_SLASHSLASH
351 # endif /* HAVE_SLASHSLASH */
354 * count the number of "../xxx" or "xxx/../xxx" in the path
356 for ( ; *cp
&& *(cp
+ 1); cp
++)
357 if (IS_DOTDOT(start
, cp
))
361 * if none, we are done.
364 return (Strsave(start
));
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
376 * If the path doesn't exist, we are done too.
378 if (lstat(short2str(start
), &sb
) != 0 && errno
== ENOENT
)
379 return (Strsave(start
));
382 cwd
= xmalloc((Strlen(dcwd
->di_name
) + 3) * sizeof(Char
));
383 (void) Strcpy(cwd
, dcwd
->di_name
);
386 * If the path starts with a slash, we are not relative to
387 * the current working directory.
389 if (ABSOLUTEP(start
))
391 # ifdef HAVE_SLASHSLASH
392 slashslash
= cwd
[0] == '/' && cwd
[1] == '/';
393 # endif /* HAVE_SLASHSLASH */
396 * Ignore . and count ..'s
403 if (IS_DOT(start
, cp
)) {
407 else if (IS_DOTDOT(start
, cp
)) {
409 break; /* finish analyzing .././../xxx/[..] */
416 Strbuf_append1(&buf
, *cp
++);
418 Strbuf_terminate(&buf
);
420 if ((dp
= Strrchr(cwd
, '/')) != NULL
) {
421 # ifdef HAVE_SLASHSLASH
424 # endif /* HAVE_SLASHSLASH */
431 if (!*cwd
) { /* too many ..'s, starts with "/" */
433 # ifdef HAVE_SLASHSLASH
435 * Only append another slash, if already the former cwd
436 * was in a double-slash path.
438 cwd
[1] = slashslash
? '/' : '\0';
440 # else /* !HAVE_SLASHSLASH */
442 # endif /* HAVE_SLASHSLASH */
444 # ifdef HAVE_SLASHSLASH
445 else if (slashslash
&& cwd
[1] == '\0') {
449 # endif /* HAVE_SLASHSLASH */
455 if (TRM(cwd
[i
- 1]) != '/') {
459 dp
= Strspl(cwd
, TRM(buf
.s
[0]) == '/' ? &buf
.s
[1] : buf
.s
);
463 if (TRM(cwd
[i
]) == '/')
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":
473 if (0 != stat(short2str(cwd
), &exists
)) {
476 return Strsave(start
);
479 } while (*cp
!= '\0');
489 * dochngd - implement chdir command.
493 dochngd(Char
**v
, struct command
*c
)
496 struct directory
*dp
;
497 int dflag
= skipargs(&v
, "plvn", "[-|<dir>]");
501 cp
= (dflag
& DIR_OLD
) ? varval(STRowd
) : *v
;
504 if ((cp
= varval(STRhome
)) == STRNULL
|| *cp
== 0)
505 stderror(ERR_NAME
| ERR_NOHOMEDIR
);
506 if (chdir(short2str(cp
)) < 0)
507 stderror(ERR_NAME
| ERR_CANTCHANGE
);
510 else if ((dflag
& DIR_OLD
) == 0 && v
[1] != NULL
) {
511 stderror(ERR_NAME
| ERR_TOOMANY
);
515 else if ((dp
= dfind(cp
)) != 0) {
519 if (chdir(tmp
= short2str(dp
->di_name
)) < 0)
520 stderror(ERR_SYSTEM
, tmp
, strerror(errno
));
521 dcwd
->di_prev
->di_next
= dcwd
->di_next
;
522 dcwd
->di_next
->di_prev
= dcwd
->di_prev
;
528 if ((cp
= dfollow(cp
, dflag
& DIR_OLD
)) == NULL
)
530 dp
= xcalloc(sizeof(struct directory
), 1);
533 dp
->di_next
= dcwd
->di_next
;
534 dp
->di_prev
= dcwd
->di_prev
;
535 dp
->di_prev
->di_next
= dp
;
536 dp
->di_next
->di_prev
= dp
;
551 cwdlen
= Strlen(dcwd
->di_name
);
552 if (cwdlen
== 1) /* root */
554 dp
= xmalloc((cwdlen
+ Strlen(cp
) + 2) * sizeof(Char
));
555 for (p
= dp
, q
= dcwd
->di_name
; (*p
++ = *q
++) != '\0';)
560 p
--; /* don't add a / after root */
569 #if defined(WINNT_NATIVE)
571 #elif defined(__CYGWIN__)
572 if (ABSOLUTEP(cp
) && cp
[1] == ':') { /* Only DOS paths are treated that way */
575 cleanup_push(cp
, xfree
);
576 ret
= dcanon(cp
, dp
);
580 #else /* !WINNT_NATIVE */
581 cleanup_push(cp
, xfree
);
582 ret
= dcanon(cp
, dp
);
585 #endif /* WINNT_NATIVE */
590 * dfollow - change to arg directory; fall back on cdpath if not valid
593 dfollow(Char
*cp
, int old
)
599 cp
= old
? Strsave(cp
) : globone(cp
, G_ERROR
);
600 cleanup_push(cp
, xfree
);
602 if (Strchr(cp
, '`')) {
604 if (chdir(dptr
= short2str(cp
)) < 0)
605 stderror(ERR_SYSTEM
, dptr
, strerror(errno
));
607 cleanup_push(dp
, xfree
);
613 stderror(ERR_SYSTEM
, dptr
, strerror(errno
));
618 * if we are ignoring symlinks, try to fix relatives now.
619 * if we are expading symlinks, it should be done by now.
621 dp
= dnormalize(cp
, symlinks
== SYM_IGNORE
);
622 if (chdir(short2str(dp
)) >= 0) {
628 if (chdir(short2str(cp
)) >= 0) {
633 else if (errno
!= ENOENT
&& errno
!= ENOTDIR
) {
637 stderror(ERR_SYSTEM
, short2str(cp
), strerror(err
));
642 if (cp
[0] != '/' && !prefix(STRdotsl
, cp
) && !prefix(STRdotdotsl
, cp
)
643 && (c
= adrof(STRcdpath
)) && c
->vec
!= NULL
) {
644 struct Strbuf buf
= Strbuf_INIT
;
647 for (cdp
= c
->vec
; *cdp
; cdp
++) {
648 size_t len
= Strlen(*cdp
);
651 Strbuf_append(&buf
, *cdp
);
652 if ((*cdp
)[len
- 1] != '/')
653 Strbuf_append1(&buf
, '/');
655 Strbuf_append(&buf
, cp
);
656 Strbuf_terminate(&buf
);
658 * We always want to fix the directory here
659 * If we are normalizing symlinks
661 dp
= dnormalize(buf
.s
, symlinks
== SYM_IGNORE
||
662 symlinks
== SYM_EXPAND
);
663 if (chdir(short2str(dp
)) >= 0) {
669 else if (chdir(short2str(cp
)) >= 0) {
681 if ((dp
[0] == '/' || dp
[0] == '.') && chdir(short2str(dp
)) >= 0) {
688 * on login source of ~/.cshdirs, errors are eaten. the dir stack is all
689 * directories we could get to.
692 stderror(ERR_SYSTEM
, short2str(cp
), strerror(serrno
));
699 * dopushd - push new directory onto directory stack.
700 * with no arguments exchange top and second.
701 * with numeric argument (+n) bring it to top.
705 dopushd(Char
**v
, struct command
*c
)
707 struct directory
*dp
;
709 int dflag
= skipargs(&v
, "plvn", " [-|<dir>|+<n>]");
713 cp
= (dflag
& DIR_OLD
) ? varval(STRowd
) : *v
;
716 if (adrof(STRpushdtohome
)) {
717 if ((cp
= varval(STRhome
)) == STRNULL
|| *cp
== 0)
718 stderror(ERR_NAME
| ERR_NOHOMEDIR
);
719 if (chdir(short2str(cp
)) < 0)
720 stderror(ERR_NAME
| ERR_CANTCHANGE
);
721 if ((cp
= dfollow(cp
, dflag
& DIR_OLD
)) == NULL
)
723 dp
= xcalloc(sizeof(struct directory
), 1);
727 dp
->di_next
= dcwd
->di_next
;
729 dp
->di_next
->di_prev
= dp
;
734 if ((dp
= dcwd
->di_prev
) == &dhead
)
737 stderror(ERR_NAME
| ERR_NODIR
);
738 if (chdir(tmp
= short2str(dp
->di_name
)) < 0)
739 stderror(ERR_SYSTEM
, tmp
, strerror(errno
));
740 dp
->di_prev
->di_next
= dp
->di_next
;
741 dp
->di_next
->di_prev
= dp
->di_prev
;
742 dp
->di_next
= dcwd
->di_next
;
744 dcwd
->di_next
->di_prev
= dp
;
748 else if ((dflag
& DIR_OLD
) == 0 && v
[1] != NULL
) {
749 stderror(ERR_NAME
| ERR_TOOMANY
);
753 else if ((dp
= dfind(cp
)) != NULL
) {
756 if (chdir(tmp
= short2str(dp
->di_name
)) < 0)
757 stderror(ERR_SYSTEM
, tmp
, strerror(errno
));
759 * kfk - 10 Feb 1984 - added new "extraction style" pushd +n
761 if (adrof(STRdextract
))
767 if ((ccp
= dfollow(cp
, dflag
& DIR_OLD
)) == NULL
)
769 dp
= xcalloc(sizeof(struct directory
), 1);
773 dp
->di_next
= dcwd
->di_next
;
775 dp
->di_next
->di_prev
= dp
;
781 * dfind - find a directory if specified by numeric (+n) argument
783 static struct directory
*
786 struct directory
*dp
;
792 for (ep
= cp
; Isdigit(*ep
); ep
++)
799 for (dp
= dcwd
; i
!= 0; i
--) {
800 if ((dp
= dp
->di_prev
) == &dhead
)
803 stderror(ERR_NAME
| ERR_DEEP
);
809 * dopopd - pop a directory out of the directory stack
810 * with a numeric argument just discard it.
814 dopopd(Char
**v
, struct command
*c
)
817 struct directory
*dp
, *p
= NULL
;
818 int dflag
= skipargs(&v
, "plvn", " [-|+<n>]");
822 cp
= (dflag
& DIR_OLD
) ? varval(STRowd
) : *v
;
826 else if ((dflag
& DIR_OLD
) == 0 && v
[1] != NULL
) {
827 stderror(ERR_NAME
| ERR_TOOMANY
);
831 else if ((dp
= dfind(cp
)) == 0)
832 stderror(ERR_NAME
| ERR_BADDIR
);
833 if (dp
->di_prev
== &dhead
&& dp
->di_next
== &dhead
)
834 stderror(ERR_NAME
| ERR_EMPTY
);
838 if ((p
= dp
->di_prev
) == &dhead
)
840 if (chdir(tmp
= short2str(p
->di_name
)) < 0)
841 stderror(ERR_SYSTEM
, tmp
, strerror(errno
));
843 dp
->di_prev
->di_next
= dp
->di_next
;
844 dp
->di_next
->di_prev
= dp
->di_prev
;
855 * dfree - free the directory (or keep it if it still has ref count)
858 dfree(struct directory
*dp
)
861 if (dp
->di_count
!= 0) {
862 dp
->di_next
= dp
->di_prev
= 0;
871 * dcanon - canonicalize the pathname, removing excess ./ and ../ etc.
872 * we are of course assuming that the file system is standardly
873 * constructed (always have ..'s, directories have links)
876 dcanon(Char
*cp
, Char
*p
)
879 Char
*p1
, *p2
; /* general purpose */
881 #ifdef HAVE_SLASHSLASH
883 #endif /* HAVE_SLASHSLASH */
886 #ifdef S_IFLNK /* if we have symlinks */
895 * christos: if the path given does not start with a slash prepend cwd. If
896 * cwd does not start with a slash or the result would be too long try to
899 if (!ABSOLUTEP(cp
)) {
904 if (p1
== STRNULL
|| !ABSOLUTEP(p1
)) {
905 Char
*new_cwd
= agetcwd();
907 if (new_cwd
== NULL
) {
908 xprintf("%s: %s\n", progname
, strerror(errno
));
909 setcopy(STRcwd
, str2short("/"), VAR_READWRITE
|VAR_NOGLOB
);
912 setv(STRcwd
, new_cwd
, VAR_READWRITE
|VAR_NOGLOB
);
916 tmpdir
= xmalloc((len
+ clen
+ 2) * sizeof (*tmpdir
));
917 (void) Strcpy(tmpdir
, p1
);
918 (void) Strcat(tmpdir
, STRslash
);
919 (void) Strcat(tmpdir
, cp
);
924 #ifdef HAVE_SLASHSLASH
925 slashslash
= (cp
[0] == '/' && cp
[1] == '/');
926 #endif /* HAVE_SLASHSLASH */
928 while (*p
) { /* for each component */
929 sp
= p
; /* save slash address */
930 while (*++p
== '/') /* flush extra slashes */
933 for (p1
= sp
, p2
= p
; (*p1
++ = *p2
++) != '\0';)
935 p
= sp
; /* save start of component */
938 while (*++p
) /* find next slash or end of path */
945 #ifdef HAVE_SLASHSLASH
946 if (&cp
[1] == sp
&& sp
[0] == '.' && sp
[1] == '.' && sp
[2] == '\0')
948 #endif /* HAVE_SLASHSLASH */
949 if (*sp
== '\0') { /* if component is null */
950 if (--sp
== cp
) /* if path is one char (i.e. /) */
955 else if (sp
[0] == '.' && sp
[1] == 0) {
957 for (p1
= sp
, p2
= p
+ 1; (*p1
++ = *p2
++) != '\0';)
966 else if (sp
[0] == '.' && sp
[1] == '.' && sp
[2] == 0) {
968 * We have something like "yyy/xxx/..", where "yyy" can be null or
969 * a path starting at /, and "xxx" is a single component. Before
970 * compressing "xxx/..", we want to expand "yyy/xxx", if it is a
973 *--sp
= 0; /* form the pathname for readlink */
974 #ifdef S_IFLNK /* if we have symlinks */
975 if (sp
!= cp
&& /* symlinks != SYM_IGNORE && */
976 (tlink
= areadlink(short2str(cp
))) != NULL
) {
977 mlink
= str2short(tlink
);
983 * Point p to the '/' in "/..", and restore the '/'.
988 * Relative path, expand it between the "yyy/" and the
989 * "/..". First, back sp up to the character past "yyy/".
996 * New length is "yyy/" + mlink + "/.." and rest
998 p1
= newcp
= xmalloc(((sp
- cp
) + Strlen(mlink
) +
999 Strlen(p
) + 1) * sizeof(Char
));
1001 * Copy new path into newcp
1003 for (p2
= cp
; (*p1
++ = *p2
++) != '\0';)
1005 for (p1
--, p2
= mlink
; (*p1
++ = *p2
++) != '\0';)
1007 for (p1
--, p2
= p
; (*p1
++ = *p2
++) != '\0';)
1010 * Restart canonicalization at expanded "/xxx".
1012 p
= sp
- cp
- 1 + newcp
;
1015 newcp
= Strspl(mlink
, p
);
1017 * Restart canonicalization at beginning
1023 #ifdef HAVE_SLASHSLASH
1024 slashslash
= (cp
[0] == '/' && cp
[1] == '/');
1025 #endif /* HAVE_SLASHSLASH */
1026 continue; /* canonicalize the link */
1028 #endif /* S_IFLNK */
1031 while (*--sp
!= '/')
1034 for (p1
= sp
+ 1, p2
= p
+ 1; (*p1
++ = *p2
++) != '\0';)
1043 else { /* normal dir name (not . or .. or nothing) */
1045 #ifdef S_IFLNK /* if we have symlinks */
1046 if (sp
!= cp
&& symlinks
== SYM_CHASE
&&
1047 (tlink
= areadlink(short2str(cp
))) != NULL
) {
1048 mlink
= str2short(tlink
);
1058 * point sp to p (rather than backing up).
1062 if (*mlink
!= '/') {
1064 * Relative path, expand it between the "yyy/" and the
1065 * remainder. First, back sp up to the character past
1068 while (*--sp
!= '/')
1073 * New length is "yyy/" + mlink + "/.." and rest
1075 p1
= newcp
= xmalloc(((sp
- cp
) + Strlen(mlink
) +
1076 Strlen(p
) + 1) * sizeof(Char
));
1078 * Copy new path into newcp
1080 for (p2
= cp
; (*p1
++ = *p2
++) != '\0';)
1082 for (p1
--, p2
= mlink
; (*p1
++ = *p2
++) != '\0';)
1084 for (p1
--, p2
= p
; (*p1
++ = *p2
++) != '\0';)
1087 * Restart canonicalization at expanded "/xxx".
1089 p
= sp
- cp
- 1 + newcp
;
1092 newcp
= Strspl(mlink
, p
);
1094 * Restart canonicalization at beginning
1100 #ifdef HAVE_SLASHSLASH
1101 slashslash
= (cp
[0] == '/' && cp
[1] == '/');
1102 #endif /* HAVE_SLASHSLASH */
1103 continue; /* canonicalize the mlink */
1105 #endif /* S_IFLNK */
1115 p1
= varval(STRhome
);
1118 * See if we're not in a subdir of STRhome
1120 if (p1
&& *p1
== '/' && (Strncmp(p1
, cp
, cc
) != 0 ||
1121 (cp
[cc
] != '/' && cp
[cc
] != '\0'))) {
1122 static ino_t home_ino
= (ino_t
) -1;
1123 static dev_t home_dev
= (dev_t
) -1;
1124 static Char
*home_ptr
= NULL
;
1125 struct stat statbuf
;
1130 * Get dev and ino of STRhome
1132 if (home_ptr
!= p1
&&
1133 stat(short2str(p1
), &statbuf
) != -1) {
1134 home_dev
= statbuf
.st_dev
;
1135 home_ino
= statbuf
.st_ino
;
1139 * Start comparing dev & ino backwards
1141 p2
= copy
= Strsave(cp
);
1143 while (*p2
&& stat(short2str(p2
), &statbuf
) != -1) {
1144 if (DEV_DEV_COMPARE(statbuf
.st_dev
, home_dev
) &&
1145 statbuf
.st_ino
== home_ino
) {
1149 if ((sp
= Strrchr(p2
, '/')) != NULL
)
1153 * See if we found it
1157 * Use STRhome to make '~' work
1159 newcp
= Strspl(p1
, cp
+ Strlen(p2
));
1165 #endif /* S_IFLNK */
1167 #ifdef HAVE_SLASHSLASH
1170 p
= xmalloc((Strlen(cp
) + 2) * sizeof(Char
));
1172 (void) Strcpy(&p
[1], cp
);
1177 if (cp
[1] == '/' && cp
[2] == '/') {
1178 for (p1
= &cp
[1], p2
= &cp
[2]; (*p1
++ = *p2
++) != '\0';)
1181 #endif /* HAVE_SLASHSLASH */
1187 * dnewcwd - make a new directory in the loop the current one
1190 dnewcwd(struct directory
*dp
, int dflag
)
1194 if (adrof(STRdunique
)) {
1195 struct directory
*dn
;
1197 for (dn
= dhead
.di_prev
; dn
!= &dhead
; dn
= dn
->di_prev
)
1198 if (dn
!= dp
&& Strcmp(dn
->di_name
, dp
->di_name
) == 0) {
1199 dn
->di_next
->di_prev
= dn
->di_prev
;
1200 dn
->di_prev
->di_next
= dn
->di_next
;
1206 dset(dcwd
->di_name
);
1208 print
= printd
; /* if printd is set, print dirstack... */
1209 if (adrof(STRpushdsilent
)) /* but pushdsilent overrides printd... */
1211 if (dflag
& DIR_PRINT
) /* but DIR_PRINT overrides pushdsilent... */
1213 if (bequiet
) /* and bequiet overrides everything */
1217 cwd_cmd(); /* PWP: run the defined cwd command */
1225 struct directory
*dn
, *dp
;
1227 if ((vp
= adrof(STRdirstack
)) == NULL
|| vp
->vec
== NULL
)
1230 /* Free the whole stack */
1231 while ((dn
= dhead
.di_prev
) != &dhead
) {
1232 dn
->di_next
->di_prev
= dn
->di_prev
;
1233 dn
->di_prev
->di_next
= dn
->di_next
;
1238 /* thread the current working directory */
1239 dhead
.di_prev
= dhead
.di_next
= dcwd
;
1240 dcwd
->di_next
= dcwd
->di_prev
= &dhead
;
1242 /* put back the stack */
1243 for (cp
= vp
->vec
; cp
&& *cp
&& **cp
; cp
++) {
1244 dp
= xcalloc(sizeof(struct directory
), 1);
1245 dp
->di_name
= Strsave(*cp
);
1248 dp
->di_next
= dcwd
->di_next
;
1250 dp
->di_next
->di_prev
= dp
;
1252 dgetstack(); /* Make $dirstack reflect the current state */
1260 struct directory
*dn
;
1262 if (adrof(STRdirstack
) == NULL
)
1265 for (dn
= dhead
.di_prev
; dn
!= &dhead
; dn
= dn
->di_prev
, i
++)
1267 dbp
= dblk
= xmalloc((i
+ 1) * sizeof(Char
*));
1268 for (dn
= dhead
.di_prev
; dn
!= &dhead
; dn
= dn
->di_prev
, dbp
++)
1269 *dbp
= Strsave(dn
->di_name
);
1271 cleanup_push(dblk
, blk_cleanup
);
1272 setq(STRdirstack
, dblk
, &shvhed
, VAR_READWRITE
);
1273 cleanup_ignore(dblk
);
1274 cleanup_until(dblk
);
1278 * getstakd - added by kfk 17 Jan 1984
1279 * Support routine for the stack hack. Finds nth directory in
1280 * the directory stack, or finds last directory in stack.
1285 struct directory
*dp
;
1288 if (cnt
< 0) { /* < 0 ==> last dir requested. */
1306 * Karl Kleinpaste - 10 Feb 1984
1307 * Added dextract(), which is used in pushd +n.
1308 * Instead of just rotating the entire stack around, dextract()
1309 * lets the user have the nth dir extracted from its current
1310 * position, and pushes it onto the top.
1313 dextract(struct directory
*dp
)
1317 dp
->di_next
->di_prev
= dp
->di_prev
;
1318 dp
->di_prev
->di_next
= dp
->di_next
;
1319 dp
->di_next
= dcwd
->di_next
;
1321 dp
->di_next
->di_prev
= dp
;
1326 bequiet_cleanup(void *dummy
)
1333 loaddirs(Char
*fname
)
1335 static Char
*loaddirs_cmd
[] = { STRsource
, NULL
, NULL
};
1338 cleanup_push(&bequiet
, bequiet_cleanup
);
1340 loaddirs_cmd
[1] = fname
;
1341 else if ((fname
= varval(STRdirsfile
)) != STRNULL
)
1342 loaddirs_cmd
[1] = fname
;
1344 loaddirs_cmd
[1] = STRtildotdirs
;
1345 dosource(loaddirs_cmd
, NULL
);
1346 cleanup_until(&bequiet
);
1350 * create a file called ~/.cshdirs which has a sequence
1351 * of pushd commands which will restore the dir stack to
1352 * its state before exit/logout. remember that the order
1353 * is reversed in the file because we are pushing.
1357 recdirs(Char
*fname
, int def
)
1359 int fp
, ftmp
, oldidfds
;
1361 struct directory
*dp
;
1364 struct Strbuf qname
= Strbuf_INIT
;
1366 if (fname
== NULL
&& !def
)
1369 if (fname
== NULL
) {
1370 if ((fname
= varval(STRdirsfile
)) == STRNULL
)
1371 fname
= Strspl(varval(STRhome
), &STRtildotdirs
[1]);
1373 fname
= Strsave(fname
);
1376 fname
= globone(fname
, G_ERROR
);
1377 cleanup_push(fname
, xfree
);
1379 if ((fp
= xcreat(short2str(fname
), 0600)) == -1) {
1380 cleanup_until(fname
);
1384 if ((snum
= varval(STRsavedirs
)) == STRNULL
|| snum
[0] == '\0')
1385 num
= (unsigned int) ~0;
1387 num
= (unsigned int) atoi(short2str(snum
));
1394 cleanup_push(&qname
, Strbuf_cleanup
);
1402 xprintf("cd %S\n", quote_meta(&qname
, dp
->di_name
));
1405 xprintf("pushd %S\n", quote_meta(&qname
, dp
->di_name
));
1410 } while ((dp
= dp
->di_next
) != dcwd
->di_next
);
1415 cleanup_until(fname
);