![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mv.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 mv.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 root 1: /*
2: * cmd/mv.c
3: * Move (rename) files.
4: * Usage: mv file1 file2
5: * mv file ... directory
6: * Define SLOW for block at a time copying (not recommended).
7: */
8:
9: #include <stdio.h>
10: #include <stdlib.h>
11: #include <sys/stat.h>
12: #include <errno.h>
13: #include <access.h>
14: #include <signal.h>
15: #include <sys/dir.h>
16: #include <string.h>
17:
18: #define NOTREACHED return
19:
20: /* Global. */
21: #ifndef SLOW
22: char buf[50*BUFSIZ];
23: #else
24: char buf[BUFSIZ];
25: #endif
26:
27: char *usage = "\
28: Usage: mv [-f] file1 file2\n\
29: mv [-f] file ... directory\n\
30: ";
31: char *nowrite = "unwritable: %s";
32: char *nolink = "link %s %s failed";
33: char *nounlink = "unlink %s failed";
34: char *cmd = "mv: "; /* for error routines */
35: int myuid;
36: int newid;
37: char *child;
38: struct stat sb1, sb2, sb3;
39: int estat;
40: int fflag;
41: int interrupted;
42:
43: /* External. */
44: long lseek();
45:
46: /* Forward. */
47: int mv();
48: void cp();
49: int iszero();
50: int equals();
51: char *concat();
52: char *getparent();
53: char *getchild();
54: void warn();
55: void nomemory();
56: void onintr();
57: void catch();
58: void fatal();
59:
60: main(argc, argv) int argc; char *argv[];
61: {
62: register int i;
63:
64: if (argc>1 && *argv[1]=='-')
65: if (argv[1][1] == 'f' && argv[1][2] == '\0') {
66: fflag = 1;
67: argc--;
68: argv++;
69: } else {
70: fputs(usage, stderr);
71: exit(EINVAL);
72: NOTREACHED;
73: }
74:
75: catch(SIGINT);
76: catch(SIGHUP);
77: signal(SIGQUIT, SIG_IGN);
78:
79: myuid = getuid();
80:
81: if (--argc >= 2
82: && stat(argv[argc], &sb2) >= 0
83: && (sb2.st_mode&S_IFMT) == S_IFDIR)
84: for (i = 1; i < argc && !interrupted; i += 1) {
85: child = getchild(argv[i]);
86: mv(argv[i], concat(0, argv[argc], child));
87: }
88: else if (argc == 2) {
89: child = getchild(argv[1]);
90: mv(argv[1], argv[2]);
91: } else {
92: fputs(usage, stderr);
93: exit(EINVAL);
94: NOTREACHED;
95: }
96: exit(interrupted ? EINTR : estat);
97: }
98:
99: /*
100: * move f1 to f2 if at all possible.
101: */
102: int
103: mv(f1, f2) char *f1, *f2;
104: {
105: int isdir, isxdev, nocopy;
106: char *p2, *lp2;
107:
108: /* Check existence, format, delete permission on source */
109: if (stat(f1, &sb1) < 0)
110: return (warn(ENOENT, f1));
111: nocopy = (sb1.st_mode&S_IFMT) != S_IFREG;
112: isdir = (sb1.st_mode&S_IFMT) == S_IFDIR;
113: newid = (sb1.st_uid != myuid);
114: if (access(getparent(f1), ADEL) < 0)
115: return (warn(EACCES, f1));
116:
117: /* Check existence, format, create permission on parent of dest */
118: if (stat(p2 = getparent(f2), &sb2) < 0)
119: return (warn(ENOENT, p2));
120: if ((sb2.st_mode&S_IFMT) != S_IFDIR)
121: return (warn(ENOTDIR, p2));
122: if (access(p2, ADEL) < 0)
123: return (warn(EACCES, p2));
124:
125: /* Check for cross device mv's */
126: isxdev = sb1.st_dev != sb2.st_dev;
127: if (isxdev && nocopy)
128: return (warn(EXDEV, "%s to %s", f1, f2));
129:
130: /* Check for legal directory moves */
131: if (isdir) {
132: /* Can't mv . or .. */
133: if (equals(".", child) || equals("..", child))
134: return (warn(-1, "rename %s forbidden", f1));
135: /* Can't mv directory to child of itself */
136: for (lp2 = p2; ; ) {
137: /* If dev and ino of source file appear in the path
138: * from dest parent to root, then the dest
139: * will be a child of the source.
140: */
141: if (sb1.st_dev==sb2.st_dev && sb1.st_ino==sb2.st_ino)
142: return (warn(-1, "%s parent of %s", f1, f2));
143: sb3 = sb2;
144: lp2 = concat(1, lp2, "..");
145: if (stat(lp2, &sb2) < 0)
146: return (warn(errno, "%s", lp2));
147: if (sb2.st_dev==sb3.st_dev && sb2.st_ino==sb3.st_ino)
148: break;
149: }
150: }
151:
152: /* Check for existence, format, and writability of dest */
153: if (stat(f2, &sb2) >= 0) {
154: if ((sb2.st_mode&S_IFMT) == S_IFDIR)
155: return (warn(EISDIR, f2));
156: if (!fflag && access(f2, AWRITE) < 0)
157: return (warn(-1, nowrite, f2));
158:
159: /* Check for identity of source and dest */
160: if (sb1.st_dev == sb2.st_dev && sb1.st_ino == sb2.st_ino)
161: return (warn(-1, "%s and %s are identical", f1, f2));
162:
163: if (unlink(f2)) {
164: fatal(errno, nounlink, f2);
165: NOTREACHED;
166: }
167: }
168:
169: /* Do the mv, either cp or ln/rm */
170: if (isxdev)
171: cp(f1, f2, sb1.st_mode, sb1.st_uid, sb1.st_gid);
172: else {
173: if (link(f1, f2))
174: return (warn(errno, nolink, f1, f2));
175: if (isdir) {
176: if (unlink(lp2 = concat(1, f2, ".."))) {
177: fatal(errno, nounlink, lp2);
178: NOTREACHED;
179: }
180: if (link(p2, lp2)) {
181: fatal(errno, nolink, p2, lp2);
182: NOTREACHED;
183: }
184: }
185: }
186: if (unlink(f1)) {
187: fatal(errno, nounlink, f1);
188: NOTREACHED;
189: }
190: }
191:
192: /*
193: * Copy f1 to f2.
194: * The mode and ownership must be maintained.
195: */
196: void
197: cp(f1, f2, mode, uid, gid) char *f1, *f2; int mode, uid, gid;
198: {
199: register int fd1, fd2;
200: register int i, n;
201: register fsize_t size;
202: register char *bp;
203:
204: if ((fd1 = open(f1, 0)) < 0) {
205: fatal(errno, "open %s failed", f1);
206: NOTREACHED;
207: }
208: if ((fd2 = creat(f2, 0)) < 0) {
209: fatal(errno, "create %s failed", f2);
210: NOTREACHED;
211: }
212: if (newid)
213: mode &= 0777;
214: chmod(f2, mode&07777);
215: chown(f2, uid, gid);
216: size = sb1.st_size;
217: while ((n = read(fd1, buf, sizeof buf)) != 0) {
218: if (n < 0) {
219: fatal(errno, "read %s failed", f1);
220: NOTREACHED;
221: }
222: for (bp = buf; n > 0; n -= i, bp += i) {
223: i = (n > BUFSIZ) ? BUFSIZ : n;
224: size -= i;
225: if (i == BUFSIZ && iszero(bp) && size > 0 ) {
226: if (lseek(fd2, (long)BUFSIZ, 1) < 0L) {
227: fatal(errno, "seek %s failed", f2);
228: NOTREACHED;
229: }
230: } else if (write(fd2, bp, i) != i) {
231: fatal(errno, "write %s failed", f2);
232: NOTREACHED;
233: }
234: }
235: }
236: close(fd1);
237: close(fd2);
238: }
239:
240: /*
241: * Check for zeroes in a buffer of size BLKSIZ.
242: */
243: int
244: iszero(bufp) char *bufp;
245: {
246: register int i;
247: register char *bp;
248:
249: i = BUFSIZ;
250: bp = bufp;
251: do if (*bp++) return (0); while (--i);
252: return (1);
253: }
254:
255: /*
256: * Check two path names for equality knowing that p2 could be '/' terminated.
257: */
258: int
259: equals(p1, p2) register char *p1, *p2;
260: {
261: while (*p1++ == *p2)
262: if (*p2++ == '\0')
263: return (1);
264: if (*p2 == '/' && *--p1 == '\0')
265: return (1);
266: return (0);
267: }
268:
269: /*
270: * Concatenate s1 and s2 with a '/' between them.
271: */
272: char *
273: concat(l, s1, s2) int l; register char *s1, *s2;
274: {
275: register char *s3;
276: static char *tmp[2];
277: int n;
278:
279: n = strlen(s1) + strlen(s2) + 2;
280: if ((s3 = malloc(n)) == NULL) {
281: nomemory();
282: NOTREACHED;
283: }
284: strcpy(s3, s1);
285: strcat(s3, "/");
286: strcat(s3, s2);
287: if (tmp[l] != NULL)
288: free(tmp[l]);
289: tmp[l] = s3;
290: return (s3);
291: }
292:
293: void
294: warn(err, arg1) int err; char *arg1;
295: {
296: fprintf(stderr, "%s%r", cmd, &arg1);
297: if (err > 0 && err < sys_nerr)
298: fprintf(stderr, " %s", sys_errlist[err]);
299: fputs("\n", stderr);
300: estat = err;
301: }
302:
303: /*
304: * return name of parent
305: */
306: char *
307: getparent(dir) char *dir;
308: {
309: register i;
310: register char *p;
311: static char *par;
312:
313: if (par)
314: free( par);
315: i = strlen( dir);
316: par = malloc( i+1);
317: if (par == NULL) {
318: nomemory( );
319: NOTREACHED;
320: }
321: strcpy( par, dir);
322:
323: for (p=par+i; p>par; )
324: if (*--p != '/')
325: break;
326: for (++p; *--p!='/'; )
327: if (p == par) {
328: *p = '.';
329: break;
330: }
331: *++p = '\0';
332: return (par);
333: }
334:
335: /*
336: * return rightmost component of pathname
337: */
338: char *
339: getchild(dir) register char *dir;
340: {
341: register i;
342: register char *p;
343: static char ch[DIRSIZ+1];
344:
345: i = strlen( dir);
346: if (i == 0) {
347: fatal( -1, "NULL?");
348: NOTREACHED;
349: }
350: for (p=dir+i; *--p=='/'; )
351: if (p == dir) {
352: fatal( -1, "don't be silly");
353: NOTREACHED;
354: }
355: while (p > dir)
356: if (*--p == '/') {
357: ++p;
358: break;
359: }
360: return (strncpy( ch, p, DIRSIZ));
361: }
362:
363: void
364: nomemory( )
365: {
366: fatal( ENOMEM, "out of mem");
367: NOTREACHED;
368: }
369:
370: void
371: onintr( )
372: {
373: signal( SIGINT, SIG_IGN);
374: signal( SIGHUP, SIG_IGN);
375: ++interrupted;
376: }
377:
378: void
379: catch( sig) int sig;
380: {
381: if( signal( sig, SIG_IGN) == SIG_DFL)
382: signal( sig, onintr);
383: }
384:
385: void
386: fatal(err, arg1) unsigned int err; char *arg1;
387: {
388: fputs(cmd, stderr);
389: if (err < sys_nerr) {
390: fputs(sys_errlist[err], stderr);
391: fputs(": ", stderr);
392: }
393: fprintf(stderr, "%r\n", &arg1);
394: exit(err);
395: NOTREACHED;
396: }
397:
398: /* end of mv.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.