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