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