Remove not needed void casts.
[dragonfly.git] / bin / pax / pax.c
1 /*-
2  * Copyright (c) 1992 Keith Muller.
3  * Copyright (c) 1992, 1993
4  *      The Regents of the University of California.  All rights reserved.
5  *
6  * This code is derived from software contributed to Berkeley by
7  * Keith Muller of the University of California, San Diego.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgement:
19  *      This product includes software developed by the University of
20  *      California, Berkeley and its contributors.
21  * 4. Neither the name of the University nor the names of its contributors
22  *    may be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  *
37  * @(#) Copyright (c) 1992, 1993 The Regents of the University of California.  All rights reserved.
38  * @(#)pax.c    8.2 (Berkeley) 4/18/94
39  * $FreeBSD: src/bin/pax/pax.c,v 1.13.2.4 2002/11/07 15:29:53 imp Exp $
40  * $DragonFly: src/bin/pax/pax.c,v 1.5 2004/11/07 20:54:51 eirikn Exp $
41  */
42
43 #include <sys/types.h>
44 #include <sys/stat.h>
45 #include <sys/time.h>
46 #include <sys/resource.h>
47 #include <err.h>
48 #include <errno.h>
49 #include <fcntl.h>
50 #include <locale.h>
51 #include <paths.h>
52 #include <signal.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <string.h>
56 #include <unistd.h>
57 #include "pax.h"
58 #include "extern.h"
59 static int gen_init (void);
60
61 /*
62  * PAX main routines, general globals and some simple start up routines
63  */
64
65 /*
66  * Variables that can be accessed by any routine within pax
67  */
68 int     act = DEFOP;            /* read/write/append/copy */
69 FSUB    *frmt = NULL;           /* archive format type */
70 int     cflag;                  /* match all EXCEPT pattern/file */
71 int     cwdfd;                  /* starting cwd */
72 int     dflag;                  /* directory member match only  */
73 int     iflag;                  /* interactive file/archive rename */
74 int     kflag;                  /* do not overwrite existing files */
75 int     lflag;                  /* use hard links when possible */
76 int     nflag;                  /* select first archive member match */
77 int     tflag;                  /* restore access time after read */
78 int     uflag;                  /* ignore older modification time files */
79 int     vflag;                  /* produce verbose output */
80 int     Dflag;                  /* same as uflag except inode change time */
81 int     Hflag;                  /* follow command line symlinks (write only) */
82 int     Lflag;                  /* follow symlinks when writing */
83 int     Xflag;                  /* archive files with same device id only */
84 int     Yflag;                  /* same as Dflg except after name mode */
85 int     Zflag;                  /* same as uflg except after name mode */
86 int     vfpart;                 /* is partial verbose output in progress */
87 int     patime = 1;             /* preserve file access time */
88 int     pmtime = 1;             /* preserve file modification times */
89 int     nodirs;                 /* do not create directories as needed */
90 int     pmode;                  /* preserve file mode bits */
91 int     pids;                   /* preserve file uid/gid */
92 int     rmleadslash = 0;        /* remove leading '/' from pathnames */
93 int     exit_val;               /* exit value */
94 int     docrc;                  /* check/create file crc */
95 char    *dirptr;                /* destination dir in a copy */
96 char    *argv0;                 /* root of argv[0] */
97 sigset_t s_mask;                /* signal mask for cleanup critical sect */
98 FILE    *listf;                 /* file pointer to print file list to */
99 char    *tempfile;              /* tempfile to use for mkstemp(3) */
100 char    *tempbase;              /* basename of tempfile to use for mkstemp(3) */
101
102 /*
103  *      PAX - Portable Archive Interchange
104  *
105  *      A utility to read, write, and write lists of the members of archive
106  *      files and copy directory hierarchies. A variety of archive formats
107  *      are supported (some are described in POSIX 1003.1 10.1):
108  *
109  *              ustar - 10.1.1 extended tar interchange format
110  *              cpio  - 10.1.2 extended cpio interchange format
111  *              tar - old BSD 4.3 tar format
112  *              binary cpio - old cpio with binary header format
113  *              sysVR4 cpio -  with and without CRC
114  *
115  * This version is a superset of IEEE Std 1003.2b-d3
116  *
117  * Summary of Extensions to the IEEE Standard:
118  *
119  * 1    READ ENHANCEMENTS
120  * 1.1  Operations which read archives will continue to operate even when
121  *      processing archives which may be damaged, truncated, or fail to meet
122  *      format specs in several different ways. Damaged sections of archives
123  *      are detected and avoided if possible. Attempts will be made to resync
124  *      archive read operations even with badly damaged media.
125  * 1.2  Blocksize requirements are not strictly enforced on archive read.
126  *      Tapes which have variable sized records can be read without errors.
127  * 1.3  The user can specify via the non-standard option flag -E if error
128  *      resync operation should stop on a media error, try a specified number
129  *      of times to correct, or try to correct forever.
130  * 1.4  Sparse files (lseek holes) stored on the archive (but stored with blocks
131  *      of all zeros will be restored with holes appropriate for the target
132  *      filesystem
133  * 1.5  The user is notified whenever something is found during archive
134  *      read operations which violates spec (but the read will continue).
135  * 1.6  Multiple archive volumes can be read and may span over different
136  *      archive devices
137  * 1.7  Rigidly restores all file attributes exactly as they are stored on the
138  *      archive.
139  * 1.8  Modification change time ranges can be specified via multiple -T
140  *      options. These allow a user to select files whose modification time
141  *      lies within a specific time range.
142  * 1.9  Files can be selected based on owner (user name or uid) via one or more
143  *      -U options.
144  * 1.10 Files can be selected based on group (group name or gid) via one o
145  *      more -G options.
146  * 1.11 File modification time can be checked against existing file after
147  *      name modification (-Z)
148  *
149  * 2    WRITE ENHANCEMENTS
150  * 2.1  Write operation will stop instead of allowing a user to create a flawed
151  *      flawed archive (due to any problem).
152  * 2.2  Archives written by pax are forced to strictly conform to both the
153  *      archive and pax the specific format specifications.
154  * 2.3  Blocking size and format is rigidly enforced on writes.
155  * 2.4  Formats which may exhibit header overflow problems (they have fields
156  *      too small for large file systems, such as inode number storage), use
157  *      routines designed to repair this problem. These techniques still
158  *      conform to both pax and format specifications, but no longer truncate
159  *      these fields. This removes any restrictions on using these archive
160  *      formats on large file systems.
161  * 2.5  Multiple archive volumes can be written and may span over different
162  *      archive devices
163  * 2.6  A archive volume record limit allows the user to specify the number
164  *      of bytes stored on an archive volume. When reached the user is
165  *      prompted for the next archive volume. This is specified with the
166  *      non-standard -B flag. The limit is rounded up to the next blocksize.
167  * 2.7  All archive padding during write use zero filled sections. This makes
168  *      it much easier to pull data out of flawed archive during read
169  *      operations.
170  * 2.8  Access time reset with the -t applies to all file nodes (including
171  *      directories).
172  * 2.9  Symbolic links can be followed with -L (optional in the spec).
173  * 2.10 Modification or inode change time ranges can be specified via
174  *      multiple -T options. These allow a user to select files whose
175  *      modification or inode change time lies within a specific time range.
176  * 2.11 Files can be selected based on owner (user name or uid) via one or more
177  *      -U options.
178  * 2.12 Files can be selected based on group (group name or gid) via one o
179  *      more -G options.
180  * 2.13 Symlinks which appear on the command line can be followed (without
181  *      following other symlinks; -H flag)
182  *
183  * 3    COPY ENHANCEMENTS
184  * 3.1  Sparse files (lseek holes) can be copied without expanding the holes
185  *      into zero filled blocks. The file copy is created with holes which are
186  *      appropriate for the target filesystem
187  * 3.2  Access time as well as modification time on copied file trees can be
188  *      preserved with the appropriate -p options.
189  * 3.3  Access time reset with the -t applies to all file nodes (including
190  *      directories).
191  * 3.4  Symbolic links can be followed with -L (optional in the spec).
192  * 3.5  Modification or inode change time ranges can be specified via
193  *      multiple -T options. These allow a user to select files whose
194  *      modification or inode change time lies within a specific time range.
195  * 3.6  Files can be selected based on owner (user name or uid) via one or more
196  *      -U options.
197  * 3.7  Files can be selected based on group (group name or gid) via one o
198  *      more -G options.
199  * 3.8  Symlinks which appear on the command line can be followed (without
200  *      following other symlinks; -H flag)
201  * 3.9  File inode change time can be checked against existing file before
202  *      name modification (-D)
203  * 3.10 File inode change time can be checked against existing file after
204  *      name modification (-Y)
205  * 3.11 File modification time can be checked against existing file after
206  *      name modification (-Z)
207  *
208  * 4    GENERAL ENHANCEMENTS
209  * 4.1  Internal structure is designed to isolate format dependent and
210  *      independent functions. Formats are selected via a format driver table.
211  *      This encourages the addition of new archive formats by only having to
212  *      write those routines which id, read and write the archive header.
213  */
214
215 /*
216  * main()
217  *      parse options, set up and operate as specified by the user.
218  *      any operational flaw will set exit_val to non-zero
219  * Return: 0 if ok, 1 otherwise
220  */
221
222 int
223 main(int argc, char **argv)
224 {
225         char *tmpdir;
226         size_t tdlen;
227
228         setlocale(LC_ALL, "");
229         listf = stderr;
230         /*
231          * Keep a reference to cwd, so we can always come back home.
232          */
233         cwdfd = open(".", O_RDONLY);
234         if (cwdfd < 0) {
235                 syswarn(0, errno, "Can't open current working directory.");
236                 return(exit_val);
237         }
238
239         /*
240          * Where should we put temporary files?
241          */
242         if ((tmpdir = getenv("TMPDIR")) == NULL || *tmpdir == '\0')
243                 tmpdir = _PATH_TMP;
244         tdlen = strlen(tmpdir);
245         while(tdlen > 0 && tmpdir[tdlen - 1] == '/')
246                 tdlen--;
247         tempfile = malloc(tdlen + 1 + sizeof(_TFILE_BASE));
248         if (tempfile == NULL) {
249                 paxwarn(1, "Cannot allocate memory for temp file name.");
250                 return(exit_val);
251         }
252         if (tdlen)
253                 memcpy(tempfile, tmpdir, tdlen);
254         tempbase = tempfile + tdlen;
255         *tempbase++ = '/';
256
257         /*
258          * parse options, determine operational mode, general init
259          */
260         options(argc, argv);
261         if ((gen_init() < 0) || (tty_init() < 0))
262                 return(exit_val);
263
264         /*
265          * select a primary operation mode
266          */
267         switch(act) {
268         case EXTRACT:
269                 extract();
270                 break;
271         case ARCHIVE:
272                 archive();
273                 break;
274         case APPND:
275                 if (gzip_program != NULL)
276                         err(1, "can not gzip while appending");
277                 append();
278                 break;
279         case COPY:
280                 copy();
281                 break;
282         default:
283         case LIST:
284                 list();
285                 break;
286         }
287         return(exit_val);
288 }
289
290 /*
291  * sig_cleanup()
292  *      when interrupted we try to do whatever delayed processing we can.
293  *      This is not critical, but we really ought to limit our damage when we
294  *      are aborted by the user.
295  * Return:
296  *      never....
297  */
298
299 void
300 sig_cleanup(int which_sig)
301 {
302         /*
303          * restore modes and times for any dirs we may have created
304          * or any dirs we may have read. Set vflag and vfpart so the user
305          * will clearly see the message on a line by itself.
306          */
307         vflag = vfpart = 1;
308         if (which_sig == SIGXCPU)
309                 paxwarn(0, "Cpu time limit reached, cleaning up.");
310         else
311                 paxwarn(0, "Signal caught, cleaning up.");
312
313         ar_close();
314         proc_dir();
315         if (tflag)
316                 atdir_end();
317         exit(1);
318 }
319
320 /*
321  * gen_init()
322  *      general setup routines. Not all are required, but they really help
323  *      when dealing with a medium to large sized archives.
324  */
325
326 static int
327 gen_init(void)
328 {
329         struct rlimit reslimit;
330         struct sigaction n_hand;
331         struct sigaction o_hand;
332
333         /*
334          * Really needed to handle large archives. We can run out of memory for
335          * internal tables really fast when we have a whole lot of files...
336          */
337         if (getrlimit(RLIMIT_DATA , &reslimit) == 0){
338                 reslimit.rlim_cur = reslimit.rlim_max;
339                 setrlimit(RLIMIT_DATA , &reslimit);
340         }
341
342         /*
343          * should file size limits be waived? if the os limits us, this is
344          * needed if we want to write a large archive
345          */
346         if (getrlimit(RLIMIT_FSIZE , &reslimit) == 0){
347                 reslimit.rlim_cur = reslimit.rlim_max;
348                 setrlimit(RLIMIT_FSIZE , &reslimit);
349         }
350
351         /*
352          * increase the size the stack can grow to
353          */
354         if (getrlimit(RLIMIT_STACK , &reslimit) == 0){
355                 reslimit.rlim_cur = reslimit.rlim_max;
356                 setrlimit(RLIMIT_STACK , &reslimit);
357         }
358
359         /*
360          * not really needed, but doesn't hurt
361          */
362         if (getrlimit(RLIMIT_RSS , &reslimit) == 0){
363                 reslimit.rlim_cur = reslimit.rlim_max;
364                 setrlimit(RLIMIT_RSS , &reslimit);
365         }
366
367         /*
368          * signal handling to reset stored directory times and modes. Since
369          * we deal with broken pipes via failed writes we ignore it. We also
370          * deal with any file size limit thorugh failed writes. Cpu time
371          * limits are caught and a cleanup is forced.
372          */
373         if ((sigemptyset(&s_mask) < 0) || (sigaddset(&s_mask, SIGTERM) < 0) ||
374             (sigaddset(&s_mask,SIGINT) < 0)||(sigaddset(&s_mask,SIGHUP) < 0) ||
375             (sigaddset(&s_mask,SIGPIPE) < 0)||(sigaddset(&s_mask,SIGQUIT)<0) ||
376             (sigaddset(&s_mask,SIGXCPU) < 0)||(sigaddset(&s_mask,SIGXFSZ)<0)) {
377                 paxwarn(1, "Unable to set up signal mask");
378                 return(-1);
379         }
380         memset(&n_hand, 0, sizeof n_hand);
381         n_hand.sa_mask = s_mask;
382         n_hand.sa_flags = 0;
383         n_hand.sa_handler = sig_cleanup;
384
385         if ((sigaction(SIGHUP, &n_hand, &o_hand) < 0) &&
386             (o_hand.sa_handler == SIG_IGN) &&
387             (sigaction(SIGHUP, &o_hand, &o_hand) < 0))
388                 goto out;
389
390         if ((sigaction(SIGTERM, &n_hand, &o_hand) < 0) &&
391             (o_hand.sa_handler == SIG_IGN) &&
392             (sigaction(SIGTERM, &o_hand, &o_hand) < 0))
393                 goto out;
394
395         if ((sigaction(SIGINT, &n_hand, &o_hand) < 0) &&
396             (o_hand.sa_handler == SIG_IGN) &&
397             (sigaction(SIGINT, &o_hand, &o_hand) < 0))
398                 goto out;
399
400         if ((sigaction(SIGQUIT, &n_hand, &o_hand) < 0) &&
401             (o_hand.sa_handler == SIG_IGN) &&
402             (sigaction(SIGQUIT, &o_hand, &o_hand) < 0))
403                 goto out;
404
405         if ((sigaction(SIGXCPU, &n_hand, &o_hand) < 0) &&
406             (o_hand.sa_handler == SIG_IGN) &&
407             (sigaction(SIGXCPU, &o_hand, &o_hand) < 0))
408                 goto out;
409
410         n_hand.sa_handler = SIG_IGN;
411         if ((sigaction(SIGPIPE, &n_hand, &o_hand) < 0) ||
412             (sigaction(SIGXFSZ, &n_hand, &o_hand) < 0))
413                 goto out;
414         return(0);
415
416     out:
417         syswarn(1, errno, "Unable to set up signal handler");
418         return(-1);
419 }