![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin|
Return to rm.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 root 1: /*
2: * rm.c
3: * 6/4/91
4: * Remove files or directories and their contents.
5: * Usage: rm [-firtv] file ...
6: *
7: * Rec'd from Lauren Weinstein, 7-16-84.
8: * This command is setuid to root to allow directory unlinks.
9: * Interrupts are handled to prevent mangled directories.
10: * Exit status of 1 indicates an error:
11: * couldn't find current directory,
12: * couldn't find root directory,
13: * pathname too long,
14: * couldn't find parent directory,
15: * couldn't stat argument,
16: * directory argument without -r flag,
17: * no permission on directory,
18: * directory is current directory,
19: * directory is root directory,
20: * unlink failed,
21: * couldn't open directory,
22: * couldn't read directory,
23: * ran out of memory saving directory entries.
24: * Failure to delete a directory because it is not empty due to interactive
25: * file selection is not an error.
26: * All the synonyms for pwd and root are identified by letting the system
27: * map them into stat buffers and comparing device x inode pairs.
28: */
29:
30: #include <stdio.h>
31: #include <sys/stat.h>
32: #include <sys/dir.h>
33: #include <access.h>
34: #include <signal.h>
35:
36: extern int errno;
37:
38: char *save();
39:
40: #define NFNAME 1000 /* Largest filename expansion in `-r' option */
41: #define equals(s1, s2) (strcmp((s1), (s2)) == 0)
42:
43: char fname[NFNAME]; /* current argument name */
44: struct stat sb; /* current argument status buffer */
45: FILE *dfp; /* directory read stream */
46: char iobuf[BUFSIZ]; /* stdio buffer */
47: struct direct db; /* directory entry buffer */
48: struct stat dot_sb; /* current directory status buffer */
49: struct stat root_sb; /* root status buffer */
50: int interrupted; /* interrupt flag */
51: char *dot = ".";
52: char *dotdot = "..";
53: char *root = "/";
54: char *cmd = "rm: "; /* for messages */
55:
56: int fflag; /* Force removal */
57: int iflag; /* Interactive removal */
58: int rflag; /* Recursive removal of directory */
59: int tflag; /* Test, do not perform removes */
60: int vflag; /* Verbose report */
61: int ntflag; /* Non-zero if stdin not a terminal */
62:
63: main(argc, argv) int argc; char *argv[];
64: {
65: register char *ap;
66: register int i;
67: register int estat = 0;
68:
69: while (argc>1 && *argv[1]=='-') {
70: for (ap=&argv[1][1]; *ap != '\0'; ap++)
71: switch (*ap) {
72: case 'f': fflag = 1; break;
73: case 'i': iflag = 1; break;
74: case 'r': rflag = 1; break;
75: case 't': tflag = 1; break;
76: case 'v': vflag = 1; break;
77: default:
78: usage();
79: }
80: argc--;
81: argv++;
82: }
83: if (argc < 2)
84: usage();
85: if (!isatty(fileno(stdin))) {
86: ntflag = 1;
87: if (iflag) {
88: fprintf(stderr, "rm: -i illegal with redirection\n");
89: exit(1);
90: }
91: }
92: if (stat(dot, &dot_sb)) {
93: lerror(dot);
94: exit(1);
95: }
96: if (stat(root, &root_sb)) {
97: lerror(root);
98: exit(1);
99: }
100:
101: catch(SIGINT);
102: catch(SIGHUP);
103: signal(SIGQUIT, SIG_IGN);
104:
105: for (i=1; i<argc; i++) {
106: if (copy(fname, argv[i], NFNAME-2)) {
107: toolong(argv[i]);
108: estat = 1;
109: } else
110: estat |= (remove() == -1);
111: }
112: exit(estat);
113: }
114:
115: /*
116: * Remove the entry with name fname.
117: * Check for all flags and permissions.
118: * Return: -1 for errors; 1 for entries remain; 0 for removal.
119: */
120: remove()
121: {
122: register int isdir;
123:
124: if (stat(fname, &sb))
125: return ((fflag) ? 0 : didnt(NULL));
126: if (isdir = ((sb.st_mode & S_IFMT) == S_IFDIR)) {
127: if (!rflag)
128: return (didnt("directory"));
129: if (access(fname, ALIST|ADEL|ASRCH) < 0)
130: return (didnt(NULL));
131: if (sb.st_dev == dot_sb.st_dev && sb.st_ino == dot_sb.st_ino)
132: return (didnt("current directory"));
133: if (sb.st_dev == root_sb.st_dev && sb.st_ino == root_sb.st_ino)
134: return (didnt("root directory"));
135: } else if (accparent() < 0)
136: return (didnt(NULL));
137: if (iflag) {
138: if (!query("%s?", fname))
139: return (report(1));
140: } else if (!fflag && access(fname, AWRITE) < 0) {
141: if (ntflag) /* stdin not a terminal? */
142: fprintf(stderr,"%sno write permission for %s",
143: cmd, fname);
144: else if (!query("override protection %o for %s?",
145: (sb.st_mode & 0777), fname))
146: return(report(1)); /* abort */
147: }
148: if (isdir) {
149: if (isdir = rmdir())
150: return (report(isdir));
151: } else {
152: if (rmfile() < 0)
153: return (didnt(NULL));
154: }
155: return (report(0));
156: }
157:
158: /*
159: * Check that the parent of this file has delete permission.
160: * Rmdir checks parents of directories.
161: */
162: accparent()
163: {
164: register char *sp;
165: register int c;
166: register int accpar;
167:
168: for (sp = fname; *sp; sp += 1) /* find end */
169: ;
170: while (sp > fname && sp[-1] != '/') /* find last / */
171: sp -= 1;
172: if (sp > fname) { /* a real name */
173: c = *sp;
174: *sp = '\0';
175: accpar = access(fname, ADEL);
176: *sp = c;
177: } else /* simple name */
178: accpar = access(dot, ADEL);
179: return (accpar);
180: }
181:
182: /*
183: * Recursive removal of directories.
184: * Scan the directory entries and append them to fname successively.
185: * Call remove to remove everything except original fname, fname/., and
186: * fname/.. which are rmfiled directly.
187: */
188: rmdir()
189: {
190: register char *cp, *np;
191: int limit;
192: int rmstat = 0;
193: char *nbase = NULL, *ntops = NULL;
194:
195: /* save directory name */
196: cp = fname;
197: while (*cp++)
198: ;
199: cp[-1] = '/';
200: *cp = '\0';
201: limit = NFNAME - 2 - (cp - fname);
202:
203: /* get the directory */
204: if ((dfp = fopen(fname, "r")) == NULL)
205: return (didnt(NULL));
206: setbuf(dfp, iobuf);
207:
208: /* read and save file names in directory */
209: while (fread(&db, sizeof(db), 1, dfp) == 1) {
210: if (db.d_ino == 0
211: || equals(db.d_name, dot)
212: || equals(db.d_name, dotdot))
213: continue;
214: if ((ntops = save(db.d_name)) == NULL) {
215: fclose(dfp);
216: return (didnt("out of memory"));
217: }
218: if (nbase == NULL)
219: nbase = ntops;
220: }
221: fclose(dfp);
222:
223: /* rescan names, form destinations, and remove */
224: if (nbase != NULL) {
225: for (np = nbase; np <= ntops; ) {
226: if (copy(cp, np, limit)) {
227: toolong(np);
228: rmstat = -1;
229: continue;
230: }
231: switch (remove()) {
232: case -1:
233: rmstat = -1;
234: break;
235: case 0:
236: break;
237: case 1:
238: rmstat = rmstat == -1 ? -1 : 1;
239: break;
240: default:
241: botch("bad return from return");
242: break;
243: }
244: while (*np++);
245: }
246: forget(nbase);
247: }
248:
249: /* Now delete the directory, if it's empty */
250: if (rmstat) {
251: cp[-1] = '\0';
252: return (rmstat);
253: }
254: if (copy(cp, dotdot, limit)) {
255: toolong(dotdot);
256: cp[-1] = '\0';
257: return (-1);
258: }
259: if (access(fname, ADEL) < 0) {
260: lerror(fname);
261: cp[-1] = '\0';
262: return (-1);
263: }
264: if (rmfile()
265: || copy(cp, dot, limit)
266: || rmfile()
267: || (cp[-1] = '\0')
268: || rmfile())
269: botch("directory unlink error");
270: return (rmstat);
271: }
272:
273: /*
274: * Unlink a single file if tflag is reset.
275: */
276: rmfile()
277: {
278: return (tflag ? 0 : unlink(fname));
279: }
280:
281: /*
282: * Ask a question about the current file,
283: * return one if the answer begins with y or Y.
284: */
285: /* VARARGS */
286: query(question) char *question;
287: {
288: register int c;
289: register int answer;
290:
291: fprintf(stderr, "%s%r [y/n] ", cmd, &question);
292: answer = ((c = getchar()) == 'y' || c == 'Y');
293: while (c != EOF && c != '\n')
294: c = getchar();
295: return (answer);
296: }
297:
298: /*
299: * Report that fname concatenated with the argument string is too long.
300: */
301: toolong(cp) char *cp;
302: {
303: if (!fflag)
304: fprintf(stderr, "%s%s%s: too long\n", cmd, fname, cp);
305: }
306:
307: /*
308: * Copy src string to dst observing that no more than lim characters can fit.
309: * Clean up on error.
310: */
311: copy(dst, src, lim) char *dst, *src; int lim;
312: {
313: register char *dp, *sp, *ep;
314:
315: dp = dst;
316: sp = src;
317: ep = dp + lim;
318:
319: while ((dp < ep) && (*dp++ = *sp++))
320: ;
321: if (dp == ep) {
322: *dst = '\0';
323: return (-1);
324: }
325: return (0);
326: }
327:
328: usage()
329: {
330: fprintf(stderr, "Usage: rm [-firtv] file ...\n");
331: exit(1);
332: }
333:
334: /*
335: * Report reason for failure.
336: */
337: didnt(reason) char *reason;
338: {
339: if (fflag)
340: return -1;
341: if (reason == NULL)
342: lerror(fname);
343: else
344: fprintf(stderr, "%s%s: %s\n", cmd, fname, reason);
345: return (report(-1));
346: }
347:
348: /*
349: * Report non-removal/removal and return error code.
350: * Since we come here after each file or directory is done,
351: * exit if an interrupt was detected.
352: */
353: report(err)
354: int err;
355: {
356: if (vflag)
357: fprintf(stderr, "%s%s: %sremoved\n", cmd, fname,
358: err ? "not ":"");
359: if (interrupted)
360: exit(1);
361: return (err);
362: }
363:
364: onintr()
365: {
366: signal(SIGINT, SIG_IGN);
367: signal(SIGHUP, SIG_IGN);
368: ++interrupted;
369: }
370:
371: catch(sig)
372: {
373: if (signal(sig, SIG_IGN) == SIG_DFL)
374: signal(sig, onintr);
375: }
376:
377: /*
378: * Simplified heap.
379: */
380: char *membase = NULL;
381: char *curbase = NULL;
382: char *curtops = NULL;
383:
384: char *
385: save(name) register char *name;
386: {
387: register char *saved;
388: register int ntosave;
389: extern char *sbrk();
390:
391: if (membase == NULL)
392: membase = curbase = curtops = sbrk(0);
393:
394: saved = curbase;
395: ntosave = 14;
396: do {
397: if (saved == curtops) {
398: if (saved != sbrk(01000))
399: return (NULL);
400: curtops += 01000;
401: }
402: } while (ntosave-- && (*saved++ = *name++));
403: if (ntosave < 0)
404: *saved++ = '\0';
405: name = curbase;
406: curbase = saved;
407: return (name);
408: }
409:
410: forget(names) register char *names;
411: {
412: if (names < membase || names >= curtops)
413: botch("memory deallocation");
414: curbase = names;
415: }
416:
417: botch(msg) char *msg;
418: {
419: fprintf(stderr, "%sbotched: %s at %s\n", cmd, msg, fname);
420: exit(1);
421: }
422:
423: lerror(msg) char *msg;
424: {
425: register int err;
426:
427: err = errno; /* save error code for perror */
428: fputs(cmd, stderr); /* command name */
429: errno = err; /* restore error code */
430: perror(msg);
431: }
432:
433: /* end of rm.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.