![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sh.dir.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / bin / csh|
Return to sh.dir.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / bin / csh |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley Software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char *sccsid = "@(#)sh.dir.c 5.4 (Berkeley) 4/14/88";
9: #endif
10:
11: #include "sh.h"
12: #include "sh.dir.h"
13:
14: /*
15: * C Shell - directory management
16: */
17:
18: struct directory *dfind();
19: char *dfollow();
20: char *dcanon();
21: struct directory dhead; /* "head" of loop */
22: int printd; /* force name to be printed */
23: static char *fakev[] = { "dirs", NOSTR };
24:
25: /*
26: * dinit - initialize current working directory
27: */
28: dinit(hp)
29: char *hp;
30: {
31: register char *cp;
32: register struct directory *dp;
33: char path[MAXPATHLEN];
34:
35: if (loginsh && hp)
36: cp = hp;
37: else {
38: cp = getwd(path);
39: if (cp == NULL) {
40: #define WDERR "csh: can't get current directory.\n"
41: (void) write(SHDIAG, WDERR, strlen(WDERR));
42: exit(1);
43: }
44: }
45: dp = (struct directory *)calloc(sizeof (struct directory), 1);
46: dp->di_name = savestr(cp);
47: dp->di_count = 0;
48: dhead.di_next = dhead.di_prev = dp;
49: dp->di_next = dp->di_prev = &dhead;
50: printd = 0;
51: dnewcwd(dp);
52: }
53:
54: /*
55: * dodirs - list all directories in directory loop
56: */
57: dodirs(v)
58: char **v;
59: {
60: register struct directory *dp;
61: bool lflag;
62: char *hp = value("home");
63:
64: if (*hp == '\0')
65: hp = NOSTR;
66: if (*++v != NOSTR)
67: if (eq(*v, "-l") && *++v == NOSTR)
68: lflag = 1;
69: else
70: error("Usage: dirs [ -l ]");
71: else
72: lflag = 0;
73: dp = dcwd;
74: do {
75: if (dp == &dhead)
76: continue;
77: if (!lflag && hp != NOSTR) {
78: dtildepr(hp, dp->di_name);
79: } else
80: printf("%s", dp->di_name);
81: printf(" ");
82: } while ((dp = dp->di_prev) != dcwd);
83: printf("\n");
84: }
85:
86: dtildepr(home, dir)
87: register char *home, *dir;
88: {
89:
90: if (!eq(home, "/") && prefix(home, dir))
91: printf("~%s", dir + strlen(home));
92: else
93: printf("%s", dir);
94: }
95:
96: /*
97: * dochngd - implement chdir command.
98: */
99: dochngd(v)
100: char **v;
101: {
102: register char *cp;
103: register struct directory *dp;
104:
105: printd = 0;
106: if (*++v == NOSTR) {
107: if ((cp = value("home")) == NOSTR || *cp == 0)
108: bferr("No home directory");
109: if (chdir(cp) < 0)
110: bferr("Can't change to home directory");
111: cp = savestr(cp);
112: } else if ((dp = dfind(*v)) != 0) {
113: printd = 1;
114: if (chdir(dp->di_name) < 0)
115: Perror(dp->di_name);
116: dcwd->di_prev->di_next = dcwd->di_next;
117: dcwd->di_next->di_prev = dcwd->di_prev;
118: goto flushcwd;
119: } else
120: cp = dfollow(*v);
121: dp = (struct directory *)calloc(sizeof (struct directory), 1);
122: dp->di_name = cp;
123: dp->di_count = 0;
124: dp->di_next = dcwd->di_next;
125: dp->di_prev = dcwd->di_prev;
126: dp->di_prev->di_next = dp;
127: dp->di_next->di_prev = dp;
128: flushcwd:
129: dfree(dcwd);
130: dnewcwd(dp);
131: }
132:
133: /*
134: * dfollow - change to arg directory; fall back on cdpath if not valid
135: */
136: char *
137: dfollow(cp)
138: register char *cp;
139: {
140: register char *dp;
141: struct varent *c;
142:
143: cp = globone(cp);
144: if (chdir(cp) >= 0)
145: goto gotcha;
146: if (cp[0] != '/' && !prefix("./", cp) && !prefix("../", cp)
147: && (c = adrof("cdpath"))) {
148: char **cdp;
149: register char *p;
150: char buf[MAXPATHLEN];
151:
152: for (cdp = c->vec; *cdp; cdp++) {
153: for (dp = buf, p = *cdp; *dp++ = *p++;)
154: ;
155: dp[-1] = '/';
156: for (p = cp; *dp++ = *p++;)
157: ;
158: if (chdir(buf) >= 0) {
159: printd = 1;
160: xfree(cp);
161: cp = savestr(buf);
162: goto gotcha;
163: }
164: }
165: }
166: dp = value(cp);
167: if ((dp[0] == '/' || dp[0] == '.') && chdir(dp) >= 0) {
168: xfree(cp);
169: cp = savestr(dp);
170: printd = 1;
171: goto gotcha;
172: }
173: xfree(cp); /* XXX, use after free */
174: Perror(cp);
175:
176: gotcha:
177: if (*cp != '/') {
178: register char *p, *q;
179: int cwdlen;
180:
181: /*
182: * All in the name of efficiency?
183: */
184: for (p = dcwd->di_name; *p++;)
185: ;
186: if ((cwdlen = p - dcwd->di_name - 1) == 1) /* root */
187: cwdlen = 0;
188: for (p = cp; *p++;)
189: ;
190: dp = xalloc((unsigned) (cwdlen + (p - cp) + 1));
191: for (p = dp, q = dcwd->di_name; *p++ = *q++;)
192: ;
193: if (cwdlen)
194: p[-1] = '/';
195: else
196: p--; /* don't add a / after root */
197: for (q = cp; *p++ = *q++;)
198: ;
199: xfree(cp);
200: cp = dp;
201: dp += cwdlen;
202: } else
203: dp = cp;
204: return dcanon(cp, dp);
205: }
206:
207: /*
208: * dopushd - push new directory onto directory stack.
209: * with no arguments exchange top and second.
210: * with numeric argument (+n) bring it to top.
211: */
212: dopushd(v)
213: char **v;
214: {
215: register struct directory *dp;
216:
217: printd = 1;
218: if (*++v == NOSTR) {
219: if ((dp = dcwd->di_prev) == &dhead)
220: dp = dhead.di_prev;
221: if (dp == dcwd)
222: bferr("No other directory");
223: if (chdir(dp->di_name) < 0)
224: Perror(dp->di_name);
225: dp->di_prev->di_next = dp->di_next;
226: dp->di_next->di_prev = dp->di_prev;
227: dp->di_next = dcwd->di_next;
228: dp->di_prev = dcwd;
229: dcwd->di_next->di_prev = dp;
230: dcwd->di_next = dp;
231: } else if (dp = dfind(*v)) {
232: if (chdir(dp->di_name) < 0)
233: Perror(dp->di_name);
234: } else {
235: register char *cp;
236:
237: cp = dfollow(*v);
238: dp = (struct directory *)calloc(sizeof (struct directory), 1);
239: dp->di_name = cp;
240: dp->di_count = 0;
241: dp->di_prev = dcwd;
242: dp->di_next = dcwd->di_next;
243: dcwd->di_next = dp;
244: dp->di_next->di_prev = dp;
245: }
246: dnewcwd(dp);
247: }
248:
249: /*
250: * dfind - find a directory if specified by numeric (+n) argument
251: */
252: struct directory *
253: dfind(cp)
254: register char *cp;
255: {
256: register struct directory *dp;
257: register int i;
258: register char *ep;
259:
260: if (*cp++ != '+')
261: return (0);
262: for (ep = cp; digit(*ep); ep++)
263: continue;
264: if (*ep)
265: return (0);
266: i = getn(cp);
267: if (i <= 0)
268: return (0);
269: for (dp = dcwd; i != 0; i--) {
270: if ((dp = dp->di_prev) == &dhead)
271: dp = dp->di_prev;
272: if (dp == dcwd)
273: bferr("Directory stack not that deep");
274: }
275: return (dp);
276: }
277:
278: /*
279: * dopopd - pop a directory out of the directory stack
280: * with a numeric argument just discard it.
281: */
282: dopopd(v)
283: char **v;
284: {
285: register struct directory *dp, *p;
286:
287: printd = 1;
288: if (*++v == NOSTR)
289: dp = dcwd;
290: else if ((dp = dfind(*v)) == 0)
291: bferr("Bad directory");
292: if (dp->di_prev == &dhead && dp->di_next == &dhead)
293: bferr("Directory stack empty");
294: if (dp == dcwd) {
295: if ((p = dp->di_prev) == &dhead)
296: p = dhead.di_prev;
297: if (chdir(p->di_name) < 0)
298: Perror(p->di_name);
299: }
300: dp->di_prev->di_next = dp->di_next;
301: dp->di_next->di_prev = dp->di_prev;
302: if (dp == dcwd)
303: dnewcwd(p);
304: else
305: dodirs(fakev);
306: dfree(dp);
307: }
308:
309: /*
310: * dfree - free the directory (or keep it if it still has ref count)
311: */
312: dfree(dp)
313: register struct directory *dp;
314: {
315:
316: if (dp->di_count != 0)
317: dp->di_next = dp->di_prev = 0;
318: else
319: xfree(dp->di_name), xfree((char *)dp);
320: }
321:
322: /*
323: * dcanon - canonicalize the pathname, removing excess ./ and ../ etc.
324: * we are of course assuming that the file system is standardly
325: * constructed (always have ..'s, directories have links)
326: */
327: char *
328: dcanon(cp, p)
329: register char *cp, *p;
330: {
331: register char *sp;
332: register char *p1, *p2; /* general purpose */
333: bool slash;
334:
335: if (*cp != '/')
336: abort();
337: while (*p) { /* for each component */
338: sp = p; /* save slash address */
339: while (*++p == '/') /* flush extra slashes */
340: ;
341: if (p != ++sp)
342: for (p1 = sp, p2 = p; *p1++ = *p2++;)
343: ;
344: p = sp; /* save start of component */
345: slash = 0;
346: while (*++p) /* find next slash or end of path */
347: if (*p == '/') {
348: slash = 1;
349: *p = 0;
350: break;
351: }
352: if (*sp == '\0') /* if component is null */
353: if (--sp == cp) /* if path is one char (i.e. /) */
354: break;
355: else
356: *sp = '\0';
357: else if (sp[0] == '.' && sp[1] == 0) {
358: if (slash) {
359: for (p1 = sp, p2 = p + 1; *p1++ = *p2++;)
360: ;
361: p = --sp;
362: } else if (--sp != cp)
363: *sp = '\0';
364: } else if (sp[0] == '.' && sp[1] == '.' && sp[2] == 0) {
365: char link[MAXPATHLEN];
366: int cc;
367: char *newcp;
368:
369: /*
370: * We have something like "yyy/xxx/..", where "yyy"
371: * can be null or a path starting at /, and "xxx"
372: * is a single component.
373: * Before compressing "xxx/..", we want to expand
374: * "yyy/xxx", if it is a symbolic link.
375: */
376: *--sp = 0; /* form the pathname for readlink */
377: if (sp != cp &&
378: (cc = readlink(cp, link, sizeof link)) >= 0) {
379: link[cc] = '\0';
380: if (slash)
381: *p = '/';
382: /*
383: * Point p to the '/' in "/..", and restore
384: * the '/'.
385: */
386: *(p = sp) = '/';
387: /*
388: * find length of p
389: */
390: for (p1 = p; *p1++;)
391: ;
392: if (*link != '/') {
393: /*
394: * Relative path, expand it between
395: * the "yyy/" and the "/..".
396: * First, back sp up to the character
397: * past "yyy/".
398: */
399: while (*--sp != '/')
400: ;
401: sp++;
402: *sp = 0;
403: /*
404: * New length is
405: * "yyy/" + link + "/.." and rest
406: */
407: p1 = newcp = xalloc((unsigned)
408: ((sp - cp) + cc + (p1 - p)));
409: /*
410: * Copy new path into newcp
411: */
412: for (p2 = cp; *p1++ = *p2++;)
413: ;
414: for (p1--, p2 = link; *p1++ = *p2++;)
415: ;
416: for (p1--, p2 = p; *p1++ = *p2++;)
417: ;
418: /*
419: * Restart canonicalization at
420: * expanded "/xxx".
421: */
422: p = sp - cp - 1 + newcp;
423: } else {
424: /*
425: * New length is link + "/.." and rest
426: */
427: p1 = newcp = xalloc((unsigned)
428: (cc + (p1 - p)));
429: /*
430: * Copy new path into newcp
431: */
432: for (p2 = link; *p1++ = *p2++;)
433: ;
434: for (p1--, p2 = p; *p1++ = *p2++;)
435: ;
436: /*
437: * Restart canonicalization at beginning
438: */
439: p = newcp;
440: }
441: xfree(cp);
442: cp = newcp;
443: continue; /* canonicalize the link */
444: }
445: *sp = '/';
446: if (sp != cp)
447: while (*--sp != '/')
448: ;
449: if (slash) {
450: for (p1 = sp + 1, p2 = p + 1; *p1++ = *p2++;)
451: ;
452: p = sp;
453: } else if (cp == sp)
454: *++sp = '\0';
455: else
456: *sp = '\0';
457: } else if (slash)
458: *p = '/';
459: }
460: return cp;
461: }
462:
463: /*
464: * dnewcwd - make a new directory in the loop the current one
465: */
466: dnewcwd(dp)
467: register struct directory *dp;
468: {
469:
470: dcwd = dp;
471: set("cwd", savestr(dcwd->di_name));
472: if (printd)
473: dodirs(fakev);
474: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.