Annotation of src/usr.bin/xinstall/xinstall.c, Revision 1.65
1.65 ! jmc 1: /* $OpenBSD: xinstall.c,v 1.64 2016/05/12 21:43:27 millert Exp $ */
1.2 deraadt 2: /* $NetBSD: xinstall.c,v 1.9 1995/12/20 10:25:17 jonathan Exp $ */
1.1 deraadt 3:
4: /*
5: * Copyright (c) 1987, 1993
6: * The Regents of the University of California. All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
1.34 millert 16: * 3. Neither the name of the University nor the names of its contributors
1.1 deraadt 17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: */
32:
1.58 deraadt 33: #include <sys/param.h> /* MAXBSIZE */
1.1 deraadt 34: #include <sys/wait.h>
35: #include <sys/mman.h>
36: #include <sys/stat.h>
37:
38: #include <ctype.h>
1.4 millert 39: #include <err.h>
1.1 deraadt 40: #include <errno.h>
41: #include <fcntl.h>
42: #include <grp.h>
43: #include <paths.h>
44: #include <pwd.h>
45: #include <stdio.h>
46: #include <stdlib.h>
47: #include <string.h>
48: #include <unistd.h>
1.58 deraadt 49: #include <limits.h>
1.4 millert 50: #include <utime.h>
1.60 jasper 51: #include <libgen.h>
1.1 deraadt 52:
53: #include "pathnames.h"
54:
1.58 deraadt 55: #define MINIMUM(a, b) (((a) < (b)) ? (a) : (b))
56:
1.19 millert 57: #define DIRECTORY 0x01 /* Tell install it's a directory. */
58: #define SETFLAGS 0x02 /* Tell install to set flags. */
1.64 millert 59: #define USEFSYNC 0x04 /* Tell install to use fsync(2). */
1.19 millert 60: #define NOCHANGEBITS (UF_IMMUTABLE | UF_APPEND | SF_IMMUTABLE | SF_APPEND)
61: #define BACKUP_SUFFIX ".old"
62:
1.1 deraadt 63: struct passwd *pp;
64: struct group *gp;
1.60 jasper 65: int dobackup, docompare, dodest, dodir, dopreserve, dostrip, safecopy;
1.1 deraadt 66: int mode = S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
1.58 deraadt 67: char pathbuf[PATH_MAX], tempfile[PATH_MAX];
1.19 millert 68: char *suffix = BACKUP_SUFFIX;
1.1 deraadt 69: uid_t uid;
70: gid_t gid;
71:
1.31 millert 72: void copy(int, char *, int, char *, off_t, int);
1.59 guenther 73: int compare(int, const char *, off_t, int, const char *, off_t);
1.31 millert 74: void install(char *, char *, u_long, u_int);
1.62 jasper 75: void install_dir(char *, int);
1.31 millert 76: void strip(char *);
77: void usage(void);
78: int create_newfile(char *, struct stat *);
79: int create_tempfile(char *, char *, size_t);
80: int file_write(int, char *, size_t, int *, int *, int);
1.33 tedu 81: void file_flush(int, int);
1.1 deraadt 82:
83: int
1.35 deraadt 84: main(int argc, char *argv[])
1.1 deraadt 85: {
86: struct stat from_sb, to_sb;
1.41 otto 87: void *set;
1.23 mickey 88: u_int32_t fset;
1.1 deraadt 89: u_int iflags;
90: int ch, no_target;
91: char *flags, *to_name, *group = NULL, *owner = NULL;
92:
93: iflags = 0;
1.64 millert 94: while ((ch = getopt(argc, argv, "B:bCcDdFf:g:m:o:pSs")) != -1)
1.56 okan 95: switch(ch) {
1.4 millert 96: case 'C':
97: docompare = 1;
98: break;
1.19 millert 99: case 'B':
100: suffix = optarg;
101: /* fall through; -B implies -b */
102: case 'b':
103: dobackup = 1;
104: break;
1.1 deraadt 105: case 'c':
1.4 millert 106: /* For backwards compatibility. */
1.1 deraadt 107: break;
1.64 millert 108: case 'F':
109: iflags |= USEFSYNC;
110: break;
1.1 deraadt 111: case 'f':
112: flags = optarg;
1.23 mickey 113: if (strtofflags(&flags, &fset, NULL))
1.63 millert 114: errx(1, "%s: invalid flag", flags);
1.1 deraadt 115: iflags |= SETFLAGS;
116: break;
117: case 'g':
118: group = optarg;
119: break;
120: case 'm':
121: if (!(set = setmode(optarg)))
1.63 millert 122: errx(1, "%s: invalid file mode", optarg);
1.1 deraadt 123: mode = getmode(set, 0);
1.16 deraadt 124: free(set);
1.1 deraadt 125: break;
126: case 'o':
127: owner = optarg;
128: break;
1.4 millert 129: case 'p':
130: docompare = dopreserve = 1;
131: break;
132: case 'S':
133: safecopy = 1;
134: break;
1.1 deraadt 135: case 's':
136: dostrip = 1;
137: break;
1.60 jasper 138: case 'D':
139: dodest = 1;
140: break;
1.1 deraadt 141: case 'd':
142: dodir = 1;
143: break;
144: case '?':
145: default:
146: usage();
147: }
148: argc -= optind;
149: argv += optind;
150:
1.4 millert 151: /* some options make no sense when creating directories */
152: if ((safecopy || docompare || dostrip) && dodir)
1.1 deraadt 153: usage();
154:
155: /* must have at least two arguments, except when creating directories */
156: if (argc < 2 && !dodir)
157: usage();
158:
1.4 millert 159: /* need to make a temp copy so we can compare stripped version */
160: if (docompare && dostrip)
161: safecopy = 1;
162:
1.1 deraadt 163: /* get group and owner id's */
1.55 deraadt 164: if (group && !(gp = getgrnam(group)) && !isdigit((unsigned char)*group))
1.63 millert 165: errx(1, "unknown group %s", group);
1.4 millert 166: gid = (group) ? ((gp) ? gp->gr_gid : (gid_t)strtoul(group, NULL, 10)) : (gid_t)-1;
1.55 deraadt 167: if (owner && !(pp = getpwnam(owner)) && !isdigit((unsigned char)*owner))
1.63 millert 168: errx(1, "unknown user %s", owner);
1.4 millert 169: uid = (owner) ? ((pp) ? pp->pw_uid : (uid_t)strtoul(owner, NULL, 10)) : (uid_t)-1;
1.1 deraadt 170:
171: if (dodir) {
172: for (; *argv != NULL; ++argv)
1.62 jasper 173: install_dir(*argv, mode);
1.63 millert 174: exit(0);
1.1 deraadt 175: /* NOTREACHED */
176: }
177:
1.60 jasper 178: if (dodest) {
179: char *dest = dirname(argv[argc - 1]);
180: if (dest == NULL)
1.63 millert 181: errx(1, "cannot determine dirname");
1.62 jasper 182: /*
183: * When -D is passed, do not chmod the directory with the mode set for
184: * the target file. If more restrictive permissions are required then
185: * '-d -m' ought to be used instead.
186: */
187: install_dir(dest, 0755);
1.60 jasper 188: }
189:
1.1 deraadt 190: no_target = stat(to_name = argv[argc - 1], &to_sb);
191: if (!no_target && S_ISDIR(to_sb.st_mode)) {
192: for (; *argv != to_name; ++argv)
193: install(*argv, to_name, fset, iflags | DIRECTORY);
1.63 millert 194: exit(0);
1.4 millert 195: /* NOTREACHED */
1.1 deraadt 196: }
197:
198: /* can't do file1 file2 directory/file */
199: if (argc != 2)
1.63 millert 200: errx(1, "Target: %s", argv[argc-1]);
1.1 deraadt 201:
202: if (!no_target) {
203: if (stat(*argv, &from_sb))
1.63 millert 204: err(1, "%s", *argv);
1.1 deraadt 205: if (!S_ISREG(to_sb.st_mode))
1.63 millert 206: errc(1, EFTYPE, "%s", to_name);
1.1 deraadt 207: if (to_sb.st_dev == from_sb.st_dev &&
208: to_sb.st_ino == from_sb.st_ino)
1.63 millert 209: errx(1, "%s and %s are the same file", *argv, to_name);
1.1 deraadt 210: }
211: install(*argv, to_name, fset, iflags);
1.63 millert 212: exit(0);
1.4 millert 213: /* NOTREACHED */
1.1 deraadt 214: }
215:
216: /*
217: * install --
218: * build a path name and install the file
219: */
220: void
1.35 deraadt 221: install(char *from_name, char *to_name, u_long fset, u_int flags)
1.1 deraadt 222: {
223: struct stat from_sb, to_sb;
1.59 guenther 224: struct timespec ts[2];
1.4 millert 225: int devnull, from_fd, to_fd, serrno, files_match = 0;
1.1 deraadt 226: char *p;
227:
1.4 millert 228: (void)memset((void *)&from_sb, 0, sizeof(from_sb));
229: (void)memset((void *)&to_sb, 0, sizeof(to_sb));
230:
1.1 deraadt 231: /* If try to install NULL file to a directory, fails. */
232: if (flags & DIRECTORY || strcmp(from_name, _PATH_DEVNULL)) {
233: if (stat(from_name, &from_sb))
1.63 millert 234: err(1, "%s", from_name);
1.1 deraadt 235: if (!S_ISREG(from_sb.st_mode))
1.63 millert 236: errc(1, EFTYPE, "%s", from_name);
1.1 deraadt 237: /* Build the target path. */
238: if (flags & DIRECTORY) {
239: (void)snprintf(pathbuf, sizeof(pathbuf), "%s/%s",
240: to_name,
1.11 millert 241: (p = strrchr(from_name, '/')) ? ++p : from_name);
1.1 deraadt 242: to_name = pathbuf;
243: }
244: devnull = 0;
245: } else {
246: devnull = 1;
247: }
248:
1.4 millert 249: if (stat(to_name, &to_sb) == 0) {
250: /* Only compare against regular files. */
251: if (docompare && !S_ISREG(to_sb.st_mode)) {
252: docompare = 0;
1.57 guenther 253: warnc(EFTYPE, "%s", to_name);
1.4 millert 254: }
255: } else if (docompare) {
256: /* File does not exist so silently ignore compare flag. */
257: docompare = 0;
258: }
259:
1.52 millert 260: if (!devnull) {
261: if ((from_fd = open(from_name, O_RDONLY, 0)) < 0)
1.63 millert 262: err(1, "%s", from_name);
1.52 millert 263: }
264:
1.4 millert 265: if (safecopy) {
266: to_fd = create_tempfile(to_name, tempfile, sizeof(tempfile));
267: if (to_fd < 0)
1.63 millert 268: err(1, "%s", tempfile);
1.4 millert 269: } else if (docompare && !dostrip) {
270: if ((to_fd = open(to_name, O_RDONLY, 0)) < 0)
1.63 millert 271: err(1, "%s", to_name);
1.4 millert 272: } else {
273: if ((to_fd = create_newfile(to_name, &to_sb)) < 0)
1.63 millert 274: err(1, "%s", to_name);
1.4 millert 275: }
276:
1.1 deraadt 277: if (!devnull) {
1.4 millert 278: if (docompare && !safecopy) {
279: files_match = !(compare(from_fd, from_name,
1.59 guenther 280: from_sb.st_size, to_fd,
281: to_name, to_sb.st_size));
1.4 millert 282:
283: /* Truncate "to" file for copy unless we match */
284: if (!files_match) {
285: (void)close(to_fd);
286: if ((to_fd = create_newfile(to_name, &to_sb)) < 0)
1.63 millert 287: err(1, "%s", to_name);
1.4 millert 288: }
1.1 deraadt 289: }
1.4 millert 290: if (!files_match)
291: copy(from_fd, from_name, to_fd,
1.17 millert 292: safecopy ? tempfile : to_name, from_sb.st_size,
293: ((off_t)from_sb.st_blocks * S_BLKSIZE < from_sb.st_size));
1.1 deraadt 294: }
1.2 deraadt 295:
296: if (dostrip) {
1.4 millert 297: strip(safecopy ? tempfile : to_name);
1.2 deraadt 298:
299: /*
300: * Re-open our fd on the target, in case we used a strip
301: * that does not work in-place -- like gnu binutils strip.
302: */
303: close(to_fd);
1.4 millert 304: if ((to_fd = open(safecopy ? tempfile : to_name, O_RDONLY,
305: 0)) < 0)
1.63 millert 306: err(1, "stripping %s", to_name);
1.4 millert 307: }
308:
309: /*
310: * Compare the (possibly stripped) temp file to the target.
311: */
312: if (safecopy && docompare) {
313: int temp_fd = to_fd;
314: struct stat temp_sb;
315:
316: /* Re-open to_fd using the real target name. */
317: if ((to_fd = open(to_name, O_RDONLY, 0)) < 0)
1.63 millert 318: err(1, "%s", to_name);
1.4 millert 319:
320: if (fstat(temp_fd, &temp_sb)) {
321: serrno = errno;
322: (void)unlink(tempfile);
1.63 millert 323: errc(1, serrno, "%s", tempfile);
1.4 millert 324: }
325:
1.59 guenther 326: if (compare(temp_fd, tempfile, temp_sb.st_size, to_fd,
327: to_name, to_sb.st_size) == 0) {
1.4 millert 328: /*
329: * If target has more than one link we need to
330: * replace it in order to snap the extra links.
331: * Need to preserve target file times, though.
332: */
333: if (to_sb.st_nlink != 1) {
1.59 guenther 334: ts[0] = to_sb.st_atim;
335: ts[1] = to_sb.st_mtim;
336: futimens(temp_fd, ts);
1.4 millert 337: } else {
338: files_match = 1;
339: (void)unlink(tempfile);
340: }
341: }
1.48 phessler 342: (void)close(to_fd);
343: to_fd = temp_fd;
1.4 millert 344: }
345:
346: /*
1.30 millert 347: * Preserve the timestamp of the source file if necessary.
1.4 millert 348: */
349: if (dopreserve && !files_match) {
1.59 guenther 350: ts[0] = from_sb.st_atim;
351: ts[1] = from_sb.st_mtim;
352: futimens(to_fd, ts);
1.2 deraadt 353: }
354:
1.1 deraadt 355: /*
356: * Set owner, group, mode for target; do the chown first,
357: * chown may lose the setuid bits.
358: */
1.48 phessler 359: if ((gid != (gid_t)-1 || uid != (uid_t)-1) &&
360: fchown(to_fd, uid, gid)) {
1.1 deraadt 361: serrno = errno;
1.48 phessler 362: (void)unlink(safecopy ? tempfile : to_name);
1.63 millert 363: errx(1, "%s: chown/chgrp: %s",
1.48 phessler 364: safecopy ? tempfile : to_name, strerror(serrno));
1.1 deraadt 365: }
366: if (fchmod(to_fd, mode)) {
367: serrno = errno;
1.48 phessler 368: (void)unlink(safecopy ? tempfile : to_name);
1.63 millert 369: errx(1, "%s: chmod: %s", safecopy ? tempfile : to_name,
1.48 phessler 370: strerror(serrno));
1.1 deraadt 371: }
372:
373: /*
374: * If provided a set of flags, set them, otherwise, preserve the
375: * flags, except for the dump flag.
376: */
377: if (fchflags(to_fd,
378: flags & SETFLAGS ? fset : from_sb.st_flags & ~UF_NODUMP)) {
1.12 millert 379: if (errno != EOPNOTSUPP || (from_sb.st_flags & ~UF_NODUMP) != 0)
1.61 jasper 380: warnx("%s: chflags: %s",
1.48 phessler 381: safecopy ? tempfile :to_name, strerror(errno));
1.1 deraadt 382: }
383:
1.64 millert 384: if (flags & USEFSYNC)
385: fsync(to_fd);
1.1 deraadt 386: (void)close(to_fd);
1.18 millert 387: if (!devnull)
388: (void)close(from_fd);
1.48 phessler 389:
390: /*
391: * Move the new file into place if doing a safe copy
392: * and the files are different (or just not compared).
393: */
394: if (safecopy && !files_match) {
395: /* Try to turn off the immutable bits. */
396: if (to_sb.st_flags & (NOCHANGEBITS))
397: (void)chflags(to_name, to_sb.st_flags & ~(NOCHANGEBITS));
398: if (dobackup) {
1.58 deraadt 399: char backup[PATH_MAX];
400: (void)snprintf(backup, PATH_MAX, "%s%s", to_name,
1.48 phessler 401: suffix);
402: /* It is ok for the target file not to exist. */
403: if (rename(to_name, backup) < 0 && errno != ENOENT) {
404: serrno = errno;
405: unlink(tempfile);
1.63 millert 406: errx(1, "rename: %s to %s: %s", to_name,
1.48 phessler 407: backup, strerror(serrno));
408: }
409: }
410: if (rename(tempfile, to_name) < 0 ) {
411: serrno = errno;
412: unlink(tempfile);
1.63 millert 413: errx(1, "rename: %s to %s: %s", tempfile,
1.48 phessler 414: to_name, strerror(serrno));
415: }
416: }
1.1 deraadt 417: }
418:
419: /*
420: * copy --
421: * copy from one file to another
422: */
423: void
1.35 deraadt 424: copy(int from_fd, char *from_name, int to_fd, char *to_name, off_t size,
425: int sparse)
1.1 deraadt 426: {
1.29 mpech 427: ssize_t nr, nw;
1.1 deraadt 428: int serrno;
429: char *p, buf[MAXBSIZE];
430:
1.51 millert 431: if (size == 0)
432: return;
433:
1.7 millert 434: /* Rewind file descriptors. */
435: if (lseek(from_fd, (off_t)0, SEEK_SET) == (off_t)-1)
1.63 millert 436: err(1, "lseek: %s", from_name);
1.7 millert 437: if (lseek(to_fd, (off_t)0, SEEK_SET) == (off_t)-1)
1.63 millert 438: err(1, "lseek: %s", to_name);
1.7 millert 439:
1.1 deraadt 440: /*
441: * Mmap and write if less than 8M (the limit is so we don't totally
442: * trash memory on big files. This is really a minor hack, but it
1.17 millert 443: * wins some CPU back. Sparse files need special treatment.
1.1 deraadt 444: */
1.51 millert 445: if (!sparse && size <= 8 * 1048576) {
1.50 espie 446: size_t siz;
1.17 millert 447:
1.19 millert 448: if ((p = mmap(NULL, (size_t)size, PROT_READ, MAP_PRIVATE,
1.38 grange 449: from_fd, (off_t)0)) == MAP_FAILED) {
1.6 millert 450: serrno = errno;
451: (void)unlink(to_name);
1.63 millert 452: errc(1, serrno, "%s", from_name);
1.6 millert 453: }
1.50 espie 454: madvise(p, size, MADV_SEQUENTIAL);
1.3 deraadt 455: siz = (size_t)size;
1.6 millert 456: if ((nw = write(to_fd, p, siz)) != siz) {
457: serrno = errno;
458: (void)unlink(to_name);
1.63 millert 459: errx(1, "%s: %s",
1.6 millert 460: to_name, strerror(nw > 0 ? EIO : serrno));
461: }
1.4 millert 462: (void) munmap(p, (size_t)size);
1.1 deraadt 463: } else {
1.17 millert 464: int sz, rem, isem = 1;
465: struct stat sb;
466:
467: /*
468: * Pass the blocksize of the file being written to the write
469: * routine. if the size is zero, use the default S_BLKSIZE.
470: */
471: if (fstat(to_fd, &sb) != 0 || sb.st_blksize == 0)
472: sz = S_BLKSIZE;
473: else
474: sz = sb.st_blksize;
1.20 millert 475: rem = sz;
1.17 millert 476:
477: while ((nr = read(from_fd, buf, sizeof(buf))) > 0) {
478: if (sparse)
479: nw = file_write(to_fd, buf, nr, &rem, &isem, sz);
480: else
481: nw = write(to_fd, buf, nr);
482: if (nw != nr) {
1.1 deraadt 483: serrno = errno;
484: (void)unlink(to_name);
1.63 millert 485: errx(1, "%s: %s",
1.1 deraadt 486: to_name, strerror(nw > 0 ? EIO : serrno));
487: }
1.17 millert 488: }
1.33 tedu 489: if (sparse)
490: file_flush(to_fd, isem);
1.1 deraadt 491: if (nr != 0) {
492: serrno = errno;
493: (void)unlink(to_name);
1.63 millert 494: errc(1, serrno, "%s", from_name);
1.1 deraadt 495: }
496: }
497: }
498:
499: /*
1.4 millert 500: * compare --
501: * compare two files; non-zero means files differ
502: */
503: int
1.59 guenther 504: compare(int from_fd, const char *from_name, off_t from_len, int to_fd,
505: const char *to_name, off_t to_len)
1.4 millert 506: {
507: caddr_t p1, p2;
1.59 guenther 508: size_t length;
509: off_t from_off, to_off, remainder;
1.4 millert 510: int dfound;
511:
1.50 espie 512: if (from_len == 0 && from_len == to_len)
513: return (0);
514:
1.4 millert 515: if (from_len != to_len)
1.50 espie 516: return (1);
1.4 millert 517:
518: /*
519: * Compare the two files being careful not to mmap
520: * more than 8M at a time.
521: */
1.21 millert 522: from_off = to_off = (off_t)0;
1.4 millert 523: remainder = from_len;
524: do {
1.58 deraadt 525: length = MINIMUM(remainder, 8 * 1048576);
1.4 millert 526: remainder -= length;
527:
1.22 mickey 528: if ((p1 = mmap(NULL, length, PROT_READ, MAP_PRIVATE,
1.38 grange 529: from_fd, from_off)) == MAP_FAILED)
1.63 millert 530: err(1, "%s", from_name);
1.22 mickey 531: if ((p2 = mmap(NULL, length, PROT_READ, MAP_PRIVATE,
1.38 grange 532: to_fd, to_off)) == MAP_FAILED)
1.63 millert 533: err(1, "%s", to_name);
1.39 mickey 534: if (length) {
535: madvise(p1, length, MADV_SEQUENTIAL);
536: madvise(p2, length, MADV_SEQUENTIAL);
537: }
1.4 millert 538:
539: dfound = memcmp(p1, p2, length);
540:
541: (void) munmap(p1, length);
542: (void) munmap(p2, length);
1.21 millert 543:
544: from_off += length;
545: to_off += length;
1.4 millert 546:
1.7 millert 547: } while (!dfound && remainder > 0);
1.4 millert 548:
549: return(dfound);
550: }
551:
552: /*
1.1 deraadt 553: * strip --
554: * use strip(1) to strip the target file
555: */
556: void
1.35 deraadt 557: strip(char *to_name)
1.1 deraadt 558: {
559: int serrno, status;
1.26 millert 560: char * volatile path_strip;
1.18 millert 561:
1.13 millert 562: if (issetugid() || (path_strip = getenv("STRIP")) == NULL)
563: path_strip = _PATH_STRIP;
1.1 deraadt 564:
565: switch (vfork()) {
566: case -1:
567: serrno = errno;
568: (void)unlink(to_name);
1.63 millert 569: errc(1, serrno, "forks");
1.1 deraadt 570: case 0:
1.44 moritz 571: execl(path_strip, "strip", "--", to_name, (char *)NULL);
1.13 millert 572: warn("%s", path_strip);
1.63 millert 573: _exit(1);
1.1 deraadt 574: default:
1.14 millert 575: if (wait(&status) == -1 || !WIFEXITED(status))
1.1 deraadt 576: (void)unlink(to_name);
577: }
578: }
579:
580: /*
581: * install_dir --
1.42 jsg 582: * build directory hierarchy
1.1 deraadt 583: */
584: void
1.62 jasper 585: install_dir(char *path, int mode)
1.1 deraadt 586: {
1.29 mpech 587: char *p;
1.8 imp 588: struct stat sb;
589: int ch;
590:
591: for (p = path;; ++p)
592: if (!*p || (p != path && *p == '/')) {
593: ch = *p;
594: *p = '\0';
1.54 naddy 595: if (mkdir(path, 0777)) {
596: int mkdir_errno = errno;
597: if (stat(path, &sb)) {
598: /* Not there; use mkdir()s errno */
1.63 millert 599: errc(1, mkdir_errno, "%s",
1.57 guenther 600: path);
1.54 naddy 601: /* NOTREACHED */
602: }
603: if (!S_ISDIR(sb.st_mode)) {
604: /* Is there, but isn't a directory */
1.63 millert 605: errc(1, ENOTDIR, "%s", path);
1.1 deraadt 606: /* NOTREACHED */
1.8 imp 607: }
608: }
609: if (!(*p = ch))
1.1 deraadt 610: break;
1.8 imp 611: }
1.1 deraadt 612:
1.4 millert 613: if (((gid != (gid_t)-1 || uid != (uid_t)-1) && chown(path, uid, gid)) ||
1.8 imp 614: chmod(path, mode)) {
615: warn("%s", path);
616: }
1.1 deraadt 617: }
618:
619: /*
620: * usage --
621: * print a usage message and die
622: */
623: void
1.35 deraadt 624: usage(void)
1.1 deraadt 625: {
626: (void)fprintf(stderr, "\
1.65 ! jmc 627: usage: install [-bCcDdFpSs] [-B suffix] [-f flags] [-g group] [-m mode] [-o owner]\n source ... target ...\n");
1.63 millert 628: exit(1);
1.4 millert 629: /* NOTREACHED */
630: }
631:
632: /*
633: * create_tempfile --
634: * create a temporary file based on path and open it
635: */
636: int
1.35 deraadt 637: create_tempfile(char *path, char *temp, size_t tsize)
1.4 millert 638: {
639: char *p;
640:
1.43 millert 641: strlcpy(temp, path, tsize);
642: if ((p = strrchr(temp, '/')) != NULL)
1.4 millert 643: p++;
644: else
645: p = temp;
1.43 millert 646: *p = '\0';
647: strlcat(p, "INS@XXXXXXXXXX", tsize);
1.4 millert 648:
649: return(mkstemp(temp));
650: }
651:
652: /*
653: * create_newfile --
1.30 millert 654: * create a new file, overwriting an existing one if necessary
1.4 millert 655: */
656: int
1.35 deraadt 657: create_newfile(char *path, struct stat *sbp)
1.4 millert 658: {
1.58 deraadt 659: char backup[PATH_MAX];
1.19 millert 660:
1.4 millert 661: /*
662: * Unlink now... avoid ETXTBSY errors later. Try and turn
663: * off the append/immutable bits -- if we fail, go ahead,
664: * it might work.
665: */
666: if (sbp->st_flags & (NOCHANGEBITS))
667: (void)chflags(path, sbp->st_flags & ~(NOCHANGEBITS));
668:
1.19 millert 669: if (dobackup) {
1.58 deraadt 670: (void)snprintf(backup, PATH_MAX, "%s%s", path, suffix);
1.28 heko 671: /* It is ok for the target file not to exist. */
672: if (rename(path, backup) < 0 && errno != ENOENT)
1.63 millert 673: err(1, "rename: %s to %s (errno %d)", path, backup, errno);
1.53 miod 674: } else {
675: if (unlink(path) < 0 && errno != ENOENT)
1.63 millert 676: err(1, "%s", path);
1.53 miod 677: }
1.4 millert 678:
1.52 millert 679: return(open(path, O_CREAT | O_RDWR | O_EXCL, S_IRUSR | S_IWUSR));
1.17 millert 680: }
681:
682: /*
683: * file_write()
684: * Write/copy a file (during copy or archive extract). This routine knows
685: * how to copy files with lseek holes in it. (Which are read as file
686: * blocks containing all 0's but do not have any file blocks associated
687: * with the data). Typical examples of these are files created by dbm
688: * variants (.pag files). While the file size of these files are huge, the
689: * actual storage is quite small (the files are sparse). The problem is
690: * the holes read as all zeros so are probably stored on the archive that
691: * way (there is no way to determine if the file block is really a hole,
692: * we only know that a file block of all zero's can be a hole).
693: * At this writing, no major archive format knows how to archive files
694: * with holes. However, on extraction (or during copy, -rw) we have to
695: * deal with these files. Without detecting the holes, the files can
696: * consume a lot of file space if just written to disk. This replacement
697: * for write when passed the basic allocation size of a file system block,
698: * uses lseek whenever it detects the input data is all 0 within that
699: * file block. In more detail, the strategy is as follows:
700: * While the input is all zero keep doing an lseek. Keep track of when we
1.45 krw 701: * pass over file block boundaries. Only write when we hit a non zero
1.17 millert 702: * input. once we have written a file block, we continue to write it to
703: * the end (we stop looking at the input). When we reach the start of the
704: * next file block, start checking for zero blocks again. Working on file
1.45 krw 705: * block boundaries significantly reduces the overhead when copying files
1.17 millert 706: * that are NOT very sparse. This overhead (when compared to a write) is
707: * almost below the measurement resolution on many systems. Without it,
708: * files with holes cannot be safely copied. It does has a side effect as
709: * it can put holes into files that did not have them before, but that is
710: * not a problem since the file contents are unchanged (in fact it saves
711: * file space). (Except on paging files for diskless clients. But since we
712: * cannot determine one of those file from here, we ignore them). If this
713: * ever ends up on a system where CTG files are supported and the holes
714: * are not desired, just do a conditional test in those routines that
715: * call file_write() and have it call write() instead. BEFORE CLOSING THE
716: * FILE, make sure to call file_flush() when the last write finishes with
717: * an empty block. A lot of file systems will not create an lseek hole at
718: * the end. In this case we drop a single 0 at the end to force the
719: * trailing 0's in the file.
720: * ---Parameters---
721: * rem: how many bytes left in this file system block
722: * isempt: have we written to the file block yet (is it empty)
723: * sz: basic file block allocation size
724: * cnt: number of bytes on this write
725: * str: buffer to write
726: * Return:
727: * number of bytes written, -1 on write (or lseek) error.
728: */
729:
730: int
1.35 deraadt 731: file_write(int fd, char *str, size_t cnt, int *rem, int *isempt, int sz)
1.17 millert 732: {
1.29 mpech 733: char *pt;
734: char *end;
735: size_t wcnt;
736: char *st = str;
1.17 millert 737:
738: /*
739: * while we have data to process
740: */
741: while (cnt) {
742: if (!*rem) {
743: /*
744: * We are now at the start of file system block again
745: * (or what we think one is...). start looking for
746: * empty blocks again
747: */
748: *isempt = 1;
749: *rem = sz;
750: }
751:
752: /*
753: * only examine up to the end of the current file block or
754: * remaining characters to write, whatever is smaller
755: */
1.58 deraadt 756: wcnt = MINIMUM(cnt, *rem);
1.17 millert 757: cnt -= wcnt;
758: *rem -= wcnt;
759: if (*isempt) {
760: /*
761: * have not written to this block yet, so we keep
762: * looking for zero's
763: */
764: pt = st;
765: end = st + wcnt;
766:
767: /*
768: * look for a zero filled buffer
769: */
770: while ((pt < end) && (*pt == '\0'))
771: ++pt;
772:
773: if (pt == end) {
774: /*
775: * skip, buf is empty so far
776: */
777: if (lseek(fd, (off_t)wcnt, SEEK_CUR) < 0) {
778: warn("lseek");
779: return(-1);
780: }
781: st = pt;
782: continue;
783: }
784: /*
785: * drat, the buf is not zero filled
786: */
787: *isempt = 0;
788: }
789:
790: /*
791: * have non-zero data in this file system block, have to write
792: */
793: if (write(fd, st, wcnt) != wcnt) {
794: warn("write");
795: return(-1);
796: }
797: st += wcnt;
798: }
799: return(st - str);
1.33 tedu 800: }
801:
802: /*
803: * file_flush()
804: * when the last file block in a file is zero, many file systems will not
805: * let us create a hole at the end. To get the last block with zeros, we
806: * write the last BYTE with a zero (back up one byte and write a zero).
807: */
808: void
809: file_flush(int fd, int isempt)
810: {
811: static char blnk[] = "\0";
812:
813: /*
814: * silly test, but make sure we are only called when the last block is
815: * filled with all zeros.
816: */
817: if (!isempt)
818: return;
819:
820: /*
821: * move back one byte and write a zero
822: */
823: if (lseek(fd, (off_t)-1, SEEK_CUR) < 0) {
824: warn("Failed seek on file");
825: return;
826: }
827:
828: if (write(fd, blnk, 1) < 0)
829: warn("Failed write to file");
830: return;
1.1 deraadt 831: }