GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: bin/pax/pax.c Lines: 77 102 75.5 %
Date: 2017-11-07 Branches: 44 83 53.0 %

Line Branch Exec Source
1
/*	$OpenBSD: pax.c,v 1.50 2017/03/11 12:55:47 tb Exp $	*/
2
/*	$NetBSD: pax.c,v 1.5 1996/03/26 23:54:20 mrg Exp $	*/
3
4
/*-
5
 * Copyright (c) 1992 Keith Muller.
6
 * Copyright (c) 1992, 1993
7
 *	The Regents of the University of California.  All rights reserved.
8
 *
9
 * This code is derived from software contributed to Berkeley by
10
 * Keith Muller of the University of California, San Diego.
11
 *
12
 * Redistribution and use in source and binary forms, with or without
13
 * modification, are permitted provided that the following conditions
14
 * are met:
15
 * 1. Redistributions of source code must retain the above copyright
16
 *    notice, this list of conditions and the following disclaimer.
17
 * 2. Redistributions in binary form must reproduce the above copyright
18
 *    notice, this list of conditions and the following disclaimer in the
19
 *    documentation and/or other materials provided with the distribution.
20
 * 3. Neither the name of the University nor the names of its contributors
21
 *    may be used to endorse or promote products derived from this software
22
 *    without specific prior written permission.
23
 *
24
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34
 * SUCH DAMAGE.
35
 */
36
37
#include <sys/types.h>
38
#include <sys/stat.h>
39
#include <sys/resource.h>
40
#include <signal.h>
41
#include <unistd.h>
42
#include <stdlib.h>
43
#include <string.h>
44
#include <errno.h>
45
#include <err.h>
46
#include <fcntl.h>
47
#include <paths.h>
48
#include <stdio.h>
49
50
#include "pax.h"
51
#include "extern.h"
52
static int gen_init(void);
53
54
/*
55
 * PAX main routines, general globals and some simple start up routines
56
 */
57
58
/*
59
 * Variables that can be accessed by any routine within pax
60
 */
61
int	act = DEFOP;		/* read/write/append/copy */
62
FSUB	*frmt = NULL;		/* archive format type */
63
int	cflag;			/* match all EXCEPT pattern/file */
64
int	cwdfd;			/* starting cwd */
65
int	dflag;			/* directory member match only  */
66
int	iflag;			/* interactive file/archive rename */
67
int	kflag;			/* do not overwrite existing files */
68
int	lflag;			/* use hard links when possible */
69
int	nflag;			/* select first archive member match */
70
int	tflag;			/* restore access time after read */
71
int	uflag;			/* ignore older modification time files */
72
int	vflag;			/* produce verbose output */
73
int	Dflag;			/* same as uflag except inode change time */
74
int	Hflag;			/* follow command line symlinks (write only) */
75
int	Lflag;			/* follow symlinks when writing */
76
int	Nflag;			/* only use numeric uid and gid */
77
int	Xflag;			/* archive files with same device id only */
78
int	Yflag;			/* same as Dflag except after name mode */
79
int	Zflag;			/* same as uflag except after name mode */
80
int	zeroflag;		/* use \0 as pathname terminator */
81
int	vfpart;			/* is partial verbose output in progress */
82
int	patime = 1;		/* preserve file access time */
83
int	pmtime = 1;		/* preserve file modification times */
84
int	nodirs;			/* do not create directories as needed */
85
int	pmode;			/* preserve file mode bits */
86
int	pids;			/* preserve file uid/gid */
87
int	rmleadslash = 0;	/* remove leading '/' from pathnames */
88
int	exit_val;		/* exit value */
89
int	docrc;			/* check/create file crc */
90
char	*dirptr;		/* destination dir in a copy */
91
char	*argv0;			/* root of argv[0] */
92
enum op_mode op_mode;		/* what program are we acting as? */
93
sigset_t s_mask;		/* signal mask for cleanup critical sect */
94
FILE	*listf = stderr;	/* file pointer to print file list to */
95
int	listfd = STDERR_FILENO;	/* fd matching listf, for sighandler output */
96
char	*tempfile;		/* tempfile to use for mkstemp(3) */
97
char	*tempbase;		/* basename of tempfile to use for mkstemp(3) */
98
99
/*
100
 *	PAX - Portable Archive Interchange
101
 *
102
 *	A utility to read, write, and write lists of the members of archive
103
 *	files and copy directory hierarchies. A variety of archive formats
104
 *	are supported (some are described in POSIX 1003.1 10.1):
105
 *
106
 *		ustar - 10.1.1 extended tar interchange format
107
 *		cpio  - 10.1.2 extended cpio interchange format
108
 *		tar - old BSD 4.3 tar format
109
 *		binary cpio - old cpio with binary header format
110
 *		sysVR4 cpio -  with and without CRC
111
 *
112
 * This version is a superset of IEEE Std 1003.2b-d3
113
 *
114
 * Summary of Extensions to the IEEE Standard:
115
 *
116
 * 1	READ ENHANCEMENTS
117
 * 1.1	Operations which read archives will continue to operate even when
118
 *	processing archives which may be damaged, truncated, or fail to meet
119
 *	format specs in several different ways. Damaged sections of archives
120
 *	are detected and avoided if possible. Attempts will be made to resync
121
 *	archive read operations even with badly damaged media.
122
 * 1.2	Blocksize requirements are not strictly enforced on archive read.
123
 *	Tapes which have variable sized records can be read without errors.
124
 * 1.3	The user can specify via the non-standard option flag -E if error
125
 *	resync operation should stop on a media error, try a specified number
126
 *	of times to correct, or try to correct forever.
127
 * 1.4	Sparse files (lseek holes) stored on the archive (but stored with blocks
128
 *	of all zeros will be restored with holes appropriate for the target
129
 *	filesystem
130
 * 1.5	The user is notified whenever something is found during archive
131
 *	read operations which violates spec (but the read will continue).
132
 * 1.6	Multiple archive volumes can be read and may span over different
133
 *	archive devices
134
 * 1.7	Rigidly restores all file attributes exactly as they are stored on the
135
 *	archive.
136
 * 1.8	Modification change time ranges can be specified via multiple -T
137
 *	options. These allow a user to select files whose modification time
138
 *	lies within a specific time range.
139
 * 1.9	Files can be selected based on owner (user name or uid) via one or more
140
 *	-U options.
141
 * 1.10	Files can be selected based on group (group name or gid) via one o
142
 *	more -G options.
143
 * 1.11	File modification time can be checked against existing file after
144
 *	name modification (-Z)
145
 *
146
 * 2	WRITE ENHANCEMENTS
147
 * 2.1	Write operation will stop instead of allowing a user to create a flawed
148
 *	flawed archive (due to any problem).
149
 * 2.2	Archives written by pax are forced to strictly conform to both the
150
 *	archive and pax the specific format specifications.
151
 * 2.3	Blocking size and format is rigidly enforced on writes.
152
 * 2.4	Formats which may exhibit header overflow problems (they have fields
153
 *	too small for large file systems, such as inode number storage), use
154
 *	routines designed to repair this problem. These techniques still
155
 *	conform to both pax and format specifications, but no longer truncate
156
 *	these fields. This removes any restrictions on using these archive
157
 *	formats on large file systems.
158
 * 2.5	Multiple archive volumes can be written and may span over different
159
 *	archive devices
160
 * 2.6	A archive volume record limit allows the user to specify the number
161
 *	of bytes stored on an archive volume. When reached the user is
162
 *	prompted for the next archive volume. This is specified with the
163
 *	non-standard -B flag. The limit is rounded up to the next blocksize.
164
 * 2.7	All archive padding during write use zero filled sections. This makes
165
 *	it much easier to pull data out of flawed archive during read
166
 *	operations.
167
 * 2.8	Access time reset with the -t applies to all file nodes (including
168
 *	directories).
169
 * 2.9	Symbolic links can be followed with -L (optional in the spec).
170
 * 2.10	Modification or inode change time ranges can be specified via
171
 *	multiple -T options. These allow a user to select files whose
172
 *	modification or inode change time lies within a specific time range.
173
 * 2.11	Files can be selected based on owner (user name or uid) via one or more
174
 *	-U options.
175
 * 2.12	Files can be selected based on group (group name or gid) via one o
176
 *	more -G options.
177
 * 2.13	Symlinks which appear on the command line can be followed (without
178
 *	following other symlinks; -H flag)
179
 *
180
 * 3	COPY ENHANCEMENTS
181
 * 3.1	Sparse files (lseek holes) can be copied without expanding the holes
182
 *	into zero filled blocks. The file copy is created with holes which are
183
 *	appropriate for the target filesystem
184
 * 3.2	Access time as well as modification time on copied file trees can be
185
 *	preserved with the appropriate -p options.
186
 * 3.3	Access time reset with the -t applies to all file nodes (including
187
 *	directories).
188
 * 3.4	Symbolic links can be followed with -L (optional in the spec).
189
 * 3.5	Modification or inode change time ranges can be specified via
190
 *	multiple -T options. These allow a user to select files whose
191
 *	modification or inode change time lies within a specific time range.
192
 * 3.6	Files can be selected based on owner (user name or uid) via one or more
193
 *	-U options.
194
 * 3.7	Files can be selected based on group (group name or gid) via one o
195
 *	more -G options.
196
 * 3.8	Symlinks which appear on the command line can be followed (without
197
 *	following other symlinks; -H flag)
198
 * 3.9  File inode change time can be checked against existing file before
199
 *	name modification (-D)
200
 * 3.10 File inode change time can be checked against existing file after
201
 *	name modification (-Y)
202
 * 3.11	File modification time can be checked against existing file after
203
 *	name modification (-Z)
204
 *
205
 * 4	GENERAL ENHANCEMENTS
206
 * 4.1	Internal structure is designed to isolate format dependent and
207
 *	independent functions. Formats are selected via a format driver table.
208
 *	This encourages the addition of new archive formats by only having to
209
 *	write those routines which id, read and write the archive header.
210
 */
211
212
/*
213
 * main()
214
 *	parse options, set up and operate as specified by the user.
215
 *	any operational flaw will set exit_val to non-zero
216
 * Return: 0 if ok, 1 otherwise
217
 */
218
219
int
220
main(int argc, char **argv)
221
{
222
	char *tmpdir;
223
	size_t tdlen;
224
225
	/*
226
	 * Keep a reference to cwd, so we can always come back home.
227
	 */
228
562
	cwdfd = open(".", O_RDONLY | O_CLOEXEC);
229
281
	if (cwdfd < 0) {
230
		syswarn(1, errno, "Can't open current working directory.");
231
		return(exit_val);
232
	}
233
234
	/*
235
	 * Where should we put temporary files?
236
	 */
237

281
	if ((tmpdir = getenv("TMPDIR")) == NULL || *tmpdir == '\0')
238
281
		tmpdir = _PATH_TMP;
239
281
	tdlen = strlen(tmpdir);
240

2248
	while (tdlen > 0 && tmpdir[tdlen - 1] == '/')
241
281
		tdlen--;
242
281
	tempfile = malloc(tdlen + 1 + sizeof(_TFILE_BASE));
243
281
	if (tempfile == NULL) {
244
		paxwarn(1, "Cannot allocate memory for temp file name.");
245
		return(exit_val);
246
	}
247
281
	if (tdlen)
248
281
		memcpy(tempfile, tmpdir, tdlen);
249
281
	tempbase = tempfile + tdlen;
250
281
	*tempbase++ = '/';
251
252
	/*
253
	 * parse options, determine operational mode, general init
254
	 */
255
281
	options(argc, argv);
256

562
	if ((gen_init() < 0) || (tty_init() < 0))
257
		return(exit_val);
258
259
	/*
260
	 * pmode needs to restore setugid bits when extracting or copying,
261
	 * so can't pledge at all then.
262
	 */
263

298
	if (pmode == 0 || (act != EXTRACT && act != COPY)) {
264
562
		if (pledge("stdio flock rpath wpath cpath fattr dpath getpw proc exec tape",
265
281
		    NULL) == -1)
266
			err(1, "pledge");
267
268
		/* Copy mode, or no gzip -- don't need to fork/exec. */
269
281
		if (gzip_program == NULL || act == COPY) {
270
450
			if (pledge("stdio flock rpath wpath cpath fattr dpath getpw tape",
271
225
			    NULL) == -1)
272
				err(1, "pledge");
273
		}
274
	}
275
276
	/*
277
	 * select a primary operation mode
278
	 */
279

281
	switch (act) {
280
	case EXTRACT:
281
18
		extract();
282
18
		break;
283
	case ARCHIVE:
284
55
		archive();
285
55
		break;
286
	case APPND:
287
51
		if (gzip_program != NULL)
288
			errx(1, "can not gzip while appending");
289
51
		append();
290
51
		break;
291
	case COPY:
292
4
		copy();
293
4
		break;
294
	default:
295
	case LIST:
296
153
		list();
297
153
		break;
298
	}
299
281
	return(exit_val);
300
281
}
301
302
/*
303
 * sig_cleanup()
304
 *	when interrupted we try to do whatever delayed processing we can.
305
 *	This is not critical, but we really ought to limit our damage when we
306
 *	are aborted by the user.
307
 * Return:
308
 *	never....
309
 */
310
311
void
312
sig_cleanup(int which_sig)
313
{
314
	char errbuf[80];
315
316
	/*
317
	 * restore modes and times for any dirs we may have created
318
	 * or any dirs we may have read.
319
	 */
320
321
	/* paxwarn() uses stdio; fake it as well as we can */
322
	if (which_sig == SIGXCPU)
323
		strlcpy(errbuf, "\nCPU time limit reached, cleaning up.\n",
324
		    sizeof errbuf);
325
	else
326
		strlcpy(errbuf, "\nSignal caught, cleaning up.\n",
327
		    sizeof errbuf);
328
	(void) write(STDERR_FILENO, errbuf, strlen(errbuf));
329
330
	ar_close(1);
331
	sltab_process(1);
332
	proc_dir(1);
333
	if (tflag)
334
		atdir_end();
335
	_exit(1);
336
}
337
338
/*
339
 * setup_sig()
340
 *	set a signal to be caught, but only if it isn't being ignored already
341
 */
342
343
static int
344
setup_sig(int sig, const struct sigaction *n_hand)
345
{
346
2810
	struct sigaction o_hand;
347
348
1405
	if (sigaction(sig, NULL, &o_hand) < 0)
349
		return (-1);
350
351
1405
	if (o_hand.sa_handler == SIG_IGN)
352
		return (0);
353
354
1405
	return (sigaction(sig, n_hand, NULL));
355
1405
}
356
357
/*
358
 * gen_init()
359
 *	general setup routines. Not all are required, but they really help
360
 *	when dealing with a medium to large sized archives.
361
 */
362
363
static int
364
gen_init(void)
365
{
366
562
	struct rlimit reslimit;
367
281
	struct sigaction n_hand;
368
369
	/*
370
	 * Really needed to handle large archives. We can run out of memory for
371
	 * internal tables really fast when we have a whole lot of files...
372
	 */
373
281
	if (getrlimit(RLIMIT_DATA , &reslimit) == 0){
374
281
		reslimit.rlim_cur = reslimit.rlim_max;
375
281
		(void)setrlimit(RLIMIT_DATA , &reslimit);
376
281
	}
377
378
	/*
379
	 * should file size limits be waived? if the os limits us, this is
380
	 * needed if we want to write a large archive
381
	 */
382
281
	if (getrlimit(RLIMIT_FSIZE , &reslimit) == 0){
383
281
		reslimit.rlim_cur = reslimit.rlim_max;
384
281
		(void)setrlimit(RLIMIT_FSIZE , &reslimit);
385
281
	}
386
387
	/*
388
	 * increase the size the stack can grow to
389
	 */
390
281
	if (getrlimit(RLIMIT_STACK , &reslimit) == 0){
391
281
		reslimit.rlim_cur = reslimit.rlim_max;
392
281
		(void)setrlimit(RLIMIT_STACK , &reslimit);
393
281
	}
394
395
	/*
396
	 * not really needed, but doesn't hurt
397
	 */
398
281
	if (getrlimit(RLIMIT_RSS , &reslimit) == 0){
399
281
		reslimit.rlim_cur = reslimit.rlim_max;
400
281
		(void)setrlimit(RLIMIT_RSS , &reslimit);
401
281
	}
402
403
	/*
404
	 * signal handling to reset stored directory times and modes. Since
405
	 * we deal with broken pipes via failed writes we ignore it. We also
406
	 * deal with any file size limit through failed writes. Cpu time
407
	 * limits are caught and a cleanup is forced.
408
	 */
409

843
	if ((sigemptyset(&s_mask) < 0) || (sigaddset(&s_mask, SIGTERM) < 0) ||
410

562
	    (sigaddset(&s_mask,SIGINT) < 0)||(sigaddset(&s_mask,SIGHUP) < 0) ||
411

562
	    (sigaddset(&s_mask,SIGPIPE) < 0)||(sigaddset(&s_mask,SIGQUIT)<0) ||
412
562
	    (sigaddset(&s_mask,SIGXCPU) < 0)||(sigaddset(&s_mask,SIGXFSZ)<0)) {
413
		paxwarn(1, "Unable to set up signal mask");
414
		return(-1);
415
	}
416
417
	/* snag the fd to be used from the signal handler */
418
843
	listfd = fileno(listf);
419
420
281
	memset(&n_hand, 0, sizeof n_hand);
421
281
	n_hand.sa_mask = s_mask;
422
281
	n_hand.sa_flags = 0;
423
281
	n_hand.sa_handler = sig_cleanup;
424
425

562
	if (setup_sig(SIGHUP,  &n_hand) ||
426
281
	    setup_sig(SIGTERM, &n_hand) ||
427
281
	    setup_sig(SIGINT,  &n_hand) ||
428
281
	    setup_sig(SIGQUIT, &n_hand) ||
429
281
	    setup_sig(SIGXCPU, &n_hand))
430
		goto out;
431
432
281
	n_hand.sa_handler = SIG_IGN;
433

562
	if ((sigaction(SIGPIPE, &n_hand, NULL) < 0) ||
434
281
	    (sigaction(SIGXFSZ, &n_hand, NULL) < 0))
435
		goto out;
436
281
	return(0);
437
438
    out:
439
	syswarn(1, errno, "Unable to set up signal handler");
440
	return(-1);
441
281
}