1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2012 Milan Jurik. All rights reserved. 24 * Copyright 2015 Joyent, Inc. 25 */ 26 27 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 28 /* All Rights Reserved */ 29 30 /* Copyright (c) 1987, 1988 Microsoft Corporation */ 31 /* All Rights Reserved */ 32 33 /* 34 * Portions of this source code were derived from Berkeley 4.3 BSD 35 * under license from the Regents of the University of California. 36 */ 37 38 #include <unistd.h> 39 #include <sys/types.h> 40 #include <sys/param.h> 41 #include <sys/stat.h> 42 #include <sys/mkdev.h> 43 #include <sys/wait.h> 44 #include <dirent.h> 45 #include <errno.h> 46 #include <stdio.h> 47 #include <signal.h> 48 #include <ctype.h> 49 #include <locale.h> 50 #include <nl_types.h> 51 #include <langinfo.h> 52 #include <pwd.h> 53 #include <grp.h> 54 #include <fcntl.h> 55 #include <string.h> 56 #include <malloc.h> 57 #include <time.h> 58 #include <utime.h> 59 #include <stdlib.h> 60 #include <stdarg.h> 61 #include <widec.h> 62 #include <sys/mtio.h> 63 #include <sys/acl.h> 64 #include <strings.h> 65 #include <deflt.h> 66 #include <limits.h> 67 #include <iconv.h> 68 #include <assert.h> 69 #include <libgen.h> 70 #include <libintl.h> 71 #include <aclutils.h> 72 #include <libnvpair.h> 73 #include <archives.h> 74 75 #if defined(__SunOS_5_6) || defined(__SunOS_5_7) 76 extern int defcntl(); 77 #endif 78 #if defined(_PC_SATTR_ENABLED) 79 #include <attr.h> 80 #include <libcmdutils.h> 81 #endif 82 83 /* Trusted Extensions */ 84 #include <zone.h> 85 #include <tsol/label.h> 86 #include <sys/tsol/label_macro.h> 87 88 #include "getresponse.h" 89 /* 90 * Source compatibility 91 */ 92 93 /* 94 * These constants come from archives.h and sys/fcntl.h 95 * and were introduced by the extended attributes project 96 * in Solaris 9. 97 */ 98 #if !defined(O_XATTR) 99 #define AT_SYMLINK_NOFOLLOW 0x1000 100 #define AT_REMOVEDIR 0x1 101 #define AT_FDCWD 0xffd19553 102 #define _XATTR_HDRTYPE 'E' 103 static int attropen(); 104 static int fstatat(); 105 static int renameat(); 106 static int unlinkat(); 107 static int openat(); 108 static int fchownat(); 109 static int futimesat(); 110 #endif 111 112 /* 113 * Compiling with -D_XPG4_2 gets this but produces other problems, so 114 * instead of including sys/time.h and compiling with -D_XPG4_2, I'm 115 * explicitly doing the declaration here. 116 */ 117 int utimes(const char *path, const struct timeval timeval_ptr[]); 118 119 #ifndef MINSIZE 120 #define MINSIZE 250 121 #endif 122 #define DEF_FILE "/etc/default/tar" 123 124 #define min(a, b) ((a) < (b) ? (a) : (b)) 125 #define max(a, b) ((a) > (b) ? (a) : (b)) 126 127 #define TBLOCK 512 /* tape block size--should be universal */ 128 129 #ifdef BSIZE 130 #define SYS_BLOCK BSIZE /* from sys/param.h: secondary block size */ 131 #else /* BSIZE */ 132 #define SYS_BLOCK 512 /* default if no BSIZE in param.h */ 133 #endif /* BSIZE */ 134 135 #define NBLOCK 20 136 #define NAMSIZ 100 137 #define PRESIZ 155 138 #define MAXNAM 256 139 #define MODEMASK 0777777 /* file creation mode mask */ 140 #define POSIXMODES 07777 /* mask for POSIX mode bits */ 141 #define MAXEXT 9 /* reasonable max # extents for a file */ 142 #define EXTMIN 50 /* min blks left on floppy to split a file */ 143 144 /* max value dblock.dbuf.efsize can store */ 145 #define TAR_EFSIZE_MAX 0777777777 146 147 /* 148 * Symbols which specify the values at which the use of the 'E' function 149 * modifier is required to properly store a file. 150 * 151 * TAR_OFFSET_MAX - the largest file size we can archive 152 * OCTAL7CHAR - the limit for ustar gid, uid, dev 153 */ 154 155 #ifdef XHDR_DEBUG 156 /* tiny values which force the creation of extended header entries */ 157 #define TAR_OFFSET_MAX 9 158 #define OCTAL7CHAR 2 159 #else 160 /* normal values */ 161 #define TAR_OFFSET_MAX 077777777777ULL 162 #define OCTAL7CHAR 07777777 163 #endif 164 165 #define TBLOCKS(bytes) (((bytes) + TBLOCK - 1) / TBLOCK) 166 #define K(tblocks) ((tblocks+1)/2) /* tblocks to Kbytes for printing */ 167 168 #define MAXLEV (PATH_MAX / 2) 169 #define LEV0 1 170 #define SYMLINK_LEV0 0 171 172 #define TRUE 1 173 #define FALSE 0 174 175 #define XATTR_FILE 1 176 #define NORMAL_FILE 0 177 178 #define PUT_AS_LINK 1 179 #define PUT_NOTAS_LINK 0 180 181 #ifndef VIEW_READONLY 182 #define VIEW_READONLY "SUNWattr_ro" 183 #endif 184 185 #ifndef VIEW_READWRITE 186 #define VIEW_READWRITE "SUNWattr_rw" 187 #endif 188 189 #if _FILE_OFFSET_BITS == 64 190 #define FMT_off_t "lld" 191 #define FMT_off_t_o "llo" 192 #define FMT_blkcnt_t "lld" 193 #else 194 #define FMT_off_t "ld" 195 #define FMT_off_t_o "lo" 196 #define FMT_blkcnt_t "ld" 197 #endif 198 199 /* ACL support */ 200 201 static 202 struct sec_attr { 203 char attr_type; 204 char attr_len[7]; 205 char attr_info[1]; 206 } *attr; 207 208 #if defined(O_XATTR) 209 typedef enum { 210 ATTR_OK, 211 ATTR_SKIP, 212 ATTR_CHDIR_ERR, 213 ATTR_OPEN_ERR, 214 ATTR_XATTR_ERR, 215 ATTR_SATTR_ERR 216 } attr_status_t; 217 #endif 218 219 #if defined(O_XATTR) 220 typedef enum { 221 ARC_CREATE, 222 ARC_RESTORE 223 } arc_action_t; 224 #endif 225 226 typedef struct attr_data { 227 char *attr_parent; 228 char *attr_path; 229 int attr_parentfd; 230 int attr_rw_sysattr; 231 } attr_data_t; 232 233 /* 234 * 235 * Tar has been changed to support extended attributes. 236 * 237 * As part of this change tar now uses the new *at() syscalls 238 * such as openat, fchownat(), unlinkat()... 239 * 240 * This was done so that attributes can be handled with as few code changes 241 * as possible. 242 * 243 * What this means is that tar now opens the directory that a file or directory 244 * resides in and then performs *at() functions to manipulate the entry. 245 * 246 * For example a new file is now created like this: 247 * 248 * dfd = open(<some dir path>) 249 * fd = openat(dfd, <name>,....); 250 * 251 * or in the case of an extended attribute 252 * 253 * dfd = attropen(<pathname>, ".", ....) 254 * 255 * Once we have a directory file descriptor all of the *at() functions can 256 * be applied to it. 257 * 258 * unlinkat(dfd, <component name>,...) 259 * fchownat(dfd, <component name>,..) 260 * 261 * This works for both normal namespace files and extended attribute file 262 * 263 */ 264 265 /* 266 * 267 * Extended attribute Format 268 * 269 * Extended attributes are stored in two pieces. 270 * 1. An attribute header which has information about 271 * what file the attribute is for and what the attribute 272 * is named. 273 * 2. The attribute record itself. Stored as a normal file type 274 * of entry. 275 * Both the header and attribute record have special modes/typeflags 276 * associated with them. 277 * 278 * The names of the header in the archive look like: 279 * /dev/null/attr.hdr 280 * 281 * The name of the attribute looks like: 282 * /dev/null/attr 283 * 284 * This is done so that an archiver that doesn't understand these formats 285 * can just dispose of the attribute records. 286 * 287 * The format is composed of a fixed size header followed 288 * by a variable sized xattr_buf. If the attribute is a hard link 289 * to another attribute then another xattr_buf section is included 290 * for the link. 291 * 292 * The xattr_buf is used to define the necessary "pathing" steps 293 * to get to the extended attribute. This is necessary to support 294 * a fully recursive attribute model where an attribute may itself 295 * have an attribute. 296 * 297 * The basic layout looks like this. 298 * 299 * -------------------------------- 300 * | | 301 * | xattr_hdr | 302 * | | 303 * -------------------------------- 304 * -------------------------------- 305 * | | 306 * | xattr_buf | 307 * | | 308 * -------------------------------- 309 * -------------------------------- 310 * | | 311 * | (optional link info) | 312 * | | 313 * -------------------------------- 314 * -------------------------------- 315 * | | 316 * | attribute itself | 317 * | stored as normal tar | 318 * | or cpio data with | 319 * | special mode or | 320 * | typeflag | 321 * | | 322 * -------------------------------- 323 * 324 */ 325 326 /* 327 * xattrhead is a pointer to the xattr_hdr 328 * 329 * xattrp is a pointer to the xattr_buf structure 330 * which contains the "pathing" steps to get to attributes 331 * 332 * xattr_linkp is a pointer to another xattr_buf structure that is 333 * only used when an attribute is actually linked to another attribute 334 * 335 */ 336 337 static struct xattr_hdr *xattrhead; 338 static struct xattr_buf *xattrp; 339 static struct xattr_buf *xattr_linkp; /* pointer to link info, if any */ 340 static char *xattrapath; /* attribute name */ 341 static char *xattr_linkaname; /* attribute attribute is linked to */ 342 static char Hiddendir; /* are we processing hidden xattr dir */ 343 static char xattrbadhead; 344 345 /* Was statically allocated tbuf[NBLOCK] */ 346 static 347 union hblock { 348 char dummy[TBLOCK]; 349 struct header { 350 char name[NAMSIZ]; /* If non-null prefix, path is */ 351 /* <prefix>/<name>; otherwise */ 352 /* <name> */ 353 char mode[8]; 354 char uid[8]; 355 char gid[8]; 356 char size[12]; /* size of this extent if file split */ 357 char mtime[12]; 358 char chksum[8]; 359 char typeflag; 360 char linkname[NAMSIZ]; 361 char magic[6]; 362 char version[2]; 363 char uname[32]; 364 char gname[32]; 365 char devmajor[8]; 366 char devminor[8]; 367 char prefix[PRESIZ]; /* Together with "name", the path of */ 368 /* the file: <prefix>/<name> */ 369 char extno; /* extent #, null if not split */ 370 char extotal; /* total extents */ 371 char efsize[10]; /* size of entire file */ 372 } dbuf; 373 } dblock, *tbuf, xhdr_buf; 374 375 static 376 struct xtar_hdr { 377 uid_t x_uid, /* Uid of file */ 378 x_gid; /* Gid of file */ 379 major_t x_devmajor; /* Device major node */ 380 minor_t x_devminor; /* Device minor node */ 381 off_t x_filesz; /* Length of file */ 382 char *x_uname, /* Pointer to name of user */ 383 *x_gname, /* Pointer to gid of user */ 384 *x_linkpath, /* Path for a hard/symbolic link */ 385 *x_path; /* Path of file */ 386 timestruc_t x_mtime; /* Seconds and nanoseconds */ 387 } Xtarhdr; 388 389 static 390 struct gen_hdr { 391 ulong_t g_mode; /* Mode of file */ 392 uid_t g_uid, /* Uid of file */ 393 g_gid; /* Gid of file */ 394 off_t g_filesz; /* Length of file */ 395 time_t g_mtime; /* Modification time */ 396 uint_t g_cksum; /* Checksum of file */ 397 ulong_t g_devmajor, /* File system of file */ 398 g_devminor; /* Major/minor of special files */ 399 } Gen; 400 401 static 402 struct linkbuf { 403 ino_t inum; 404 dev_t devnum; 405 int count; 406 char pathname[MAXNAM+1]; /* added 1 for last NULL */ 407 char attrname[MAXNAM+1]; 408 struct linkbuf *nextp; 409 } *ihead; 410 411 /* see comments before build_table() */ 412 #define TABLE_SIZE 512 413 typedef struct file_list { 414 char *name; /* Name of file to {in,ex}clude */ 415 struct file_list *next; /* Linked list */ 416 } file_list_t; 417 static file_list_t *exclude_tbl[TABLE_SIZE], 418 *include_tbl[TABLE_SIZE]; 419 420 static int append_secattr(char **, int *, int, char *, char); 421 static void write_ancillary(union hblock *, char *, int, char); 422 423 static void add_file_to_table(file_list_t *table[], char *str); 424 static void assert_string(char *s, char *msg); 425 static int istape(int fd, int type); 426 static void backtape(void); 427 static void build_table(file_list_t *table[], char *file); 428 static int check_prefix(char **namep, char **dirp, char **compp); 429 static void closevol(void); 430 static void copy(void *dst, void *src); 431 static int convtoreg(off_t); 432 static void delete_target(int fd, char *comp, char *namep); 433 static void doDirTimes(char *name, timestruc_t modTime); 434 static void done(int n); 435 static void dorep(char *argv[]); 436 static void dotable(char *argv[]); 437 static void doxtract(char *argv[]); 438 static int tar_chdir(const char *path); 439 static int is_directory(char *name); 440 static int has_dot_dot(char *name); 441 static int is_absolute(char *name); 442 static char *make_relative_name(char *name, char **stripped_prefix); 443 static void fatal(char *format, ...); 444 static void vperror(int exit_status, char *fmt, ...); 445 static void flushtape(void); 446 static void getdir(void); 447 static void *getmem(size_t); 448 static void longt(struct stat *st, char aclchar); 449 static void load_info_from_xtarhdr(u_longlong_t flag, struct xtar_hdr *xhdrp); 450 static int makeDir(char *name); 451 static void mterr(char *operation, int i, int exitcode); 452 static void newvol(void); 453 static void passtape(void); 454 static void putempty(blkcnt_t n); 455 static int putfile(char *longname, char *shortname, char *parent, 456 attr_data_t *attrinfo, int filetype, int lev, int symlink_lev); 457 static void readtape(char *buffer); 458 static void seekdisk(blkcnt_t blocks); 459 static void setPathTimes(int dirfd, char *path, timestruc_t modTime); 460 static void setbytes_to_skip(struct stat *st, int err); 461 static void splitfile(char *longname, int ifd, char *name, 462 char *prefix, int filetype); 463 static void tomodes(struct stat *sp); 464 static void usage(void); 465 static int xblocks(int issysattr, off_t bytes, int ofile); 466 static int xsfile(int issysattr, int ofd); 467 static void resugname(int dirfd, char *name, int symflag); 468 static int bcheck(char *bstr); 469 static int checkdir(char *name); 470 static int checksum(union hblock *dblockp); 471 #ifdef EUC 472 static int checksum_signed(union hblock *dblockp); 473 #endif /* EUC */ 474 static int checkupdate(char *arg); 475 static int checkw(char c, char *name); 476 static int cmp(char *b, char *s, int n); 477 static int defset(char *arch); 478 static boolean_t endtape(void); 479 static int is_in_table(file_list_t *table[], char *str); 480 static int notsame(void); 481 static int is_prefix(char *s1, char *s2); 482 static int response(void); 483 static int build_dblock(const char *, const char *, const char, 484 const int filetype, const struct stat *, const dev_t, const char *); 485 static unsigned int hash(char *str); 486 487 static blkcnt_t kcheck(char *kstr); 488 static off_t bsrch(char *s, int n, off_t l, off_t h); 489 static void onintr(int sig); 490 static void onquit(int sig); 491 static void onhup(int sig); 492 static uid_t getuidbyname(char *); 493 static gid_t getgidbyname(char *); 494 static char *getname(gid_t); 495 static char *getgroup(gid_t); 496 static int checkf(char *name, int mode, int howmuch); 497 static int writetbuf(char *buffer, int n); 498 static int wantit(char *argv[], char **namep, char **dirp, char **comp, 499 attr_data_t **attrinfo); 500 static void append_ext_attr(char *shortname, char **secinfo, int *len); 501 static int get_xdata(void); 502 static void gen_num(const char *keyword, const u_longlong_t number); 503 static void gen_date(const char *keyword, const timestruc_t time_value); 504 static void gen_string(const char *keyword, const char *value); 505 static void get_xtime(char *value, timestruc_t *xtime); 506 static int chk_path_build(char *name, char *longname, char *linkname, 507 char *prefix, char type, int filetype); 508 static int gen_utf8_names(const char *filename); 509 static int utf8_local(char *option, char **Xhdr_ptrptr, char *target, 510 const char *src, int max_val); 511 static int local_utf8(char **Xhdr_ptrptr, char *target, const char *src, 512 iconv_t iconv_cd, int xhdrflg, int max_val); 513 static int c_utf8(char *target, const char *source); 514 static int getstat(int dirfd, char *longname, char *shortname, 515 char *attrparent); 516 static void xattrs_put(char *, char *, char *, char *); 517 static void prepare_xattr(char **, char *, char *, 518 char, struct linkbuf *, int *); 519 static int put_link(char *name, char *longname, char *component, 520 char *longattrname, char *prefix, int filetype, char typeflag); 521 static int put_extra_attributes(char *longname, char *shortname, 522 char *longattrname, char *prefix, int filetype, char typeflag); 523 static int put_xattr_hdr(char *longname, char *shortname, char *longattrname, 524 char *prefix, int typeflag, int filetype, struct linkbuf *lp); 525 static int read_xattr_hdr(attr_data_t **attrinfo); 526 527 /* Trusted Extensions */ 528 #define AUTO_ZONE "/zone" 529 530 static void extract_attr(char **file_ptr, struct sec_attr *); 531 static int check_ext_attr(char *filename); 532 static void rebuild_comp_path(char *str, char **namep); 533 static int rebuild_lk_comp_path(char *str, char **namep); 534 535 static void get_parent(char *path, char *dir); 536 static char *get_component(char *path); 537 static int retry_open_attr(int pdirfd, int cwd, char *dirp, char *pattr, 538 char *name, int oflag, mode_t mode); 539 static char *skipslashes(char *string, char *start); 540 static void chop_endslashes(char *path); 541 static pid_t compress_file(void); 542 static void compress_back(void); 543 static void decompress_file(void); 544 static pid_t uncompress_file(void); 545 static void *compress_malloc(size_t); 546 static void check_compression(void); 547 static char *bz_suffix(void); 548 static char *gz_suffix(void); 549 static char *xz_suffix(void); 550 static char *add_suffix(); 551 static void wait_pid(pid_t); 552 static void verify_compress_opt(const char *t); 553 static void detect_compress(void); 554 static void dlog(const char *, ...); 555 static boolean_t should_enable_debug(void); 556 557 static struct stat stbuf; 558 559 static char *myname; 560 static char *xtract_chdir = NULL; 561 static int checkflag = 0; 562 static int Xflag, Fflag, iflag, hflag, Bflag, Iflag; 563 static int rflag, xflag, vflag, tflag, mt, cflag, mflag, pflag; 564 static int uflag; 565 static int errflag; 566 static int oflag; 567 static int bflag, Aflag; 568 static int Pflag; /* POSIX conformant archive */ 569 static int Eflag; /* Allow files greater than 8GB */ 570 static int atflag; /* traverse extended attributes */ 571 static int saflag; /* traverse extended sys attributes */ 572 static int Dflag; /* Data change flag */ 573 static int jflag; /* flag to use 'bzip2' */ 574 static int zflag; /* flag to use 'gzip' */ 575 static int Zflag; /* flag to use 'compress' */ 576 static int Jflag; /* flag to use 'xz' */ 577 static int aflag; /* flag to use autocompression */ 578 579 /* Trusted Extensions */ 580 static int Tflag; /* Trusted Extensions attr flags */ 581 static int dir_flag; /* for attribute extract */ 582 static int mld_flag; /* for attribute extract */ 583 static char *orig_namep; /* original namep - unadorned */ 584 static int rpath_flag; /* MLD real path is rebuilt */ 585 static char real_path[MAXPATHLEN]; /* MLD real path */ 586 static int lk_rpath_flag; /* linked to real path is rebuilt */ 587 static char lk_real_path[MAXPATHLEN]; /* linked real path */ 588 static bslabel_t bs_label; /* for attribute extract */ 589 static bslabel_t admin_low; 590 static bslabel_t admin_high; 591 static int ignored_aprivs = 0; 592 static int ignored_fprivs = 0; 593 static int ignored_fattrs = 0; 594 595 static int term, chksum, wflag, 596 first = TRUE, defaults_used = FALSE, linkerrok; 597 static blkcnt_t recno; 598 static int freemem = 1; 599 static int nblock = NBLOCK; 600 static int Errflg = 0; 601 static int exitflag = 0; 602 603 static dev_t mt_dev; /* device containing output file */ 604 static ino_t mt_ino; /* inode number of output file */ 605 static int mt_devtype; /* dev type of archive, from stat structure */ 606 607 static int update = 1; /* for `open' call */ 608 609 static off_t low; 610 static off_t high; 611 612 static FILE *tfile; 613 static FILE *vfile = stdout; 614 static char *tmpdir; 615 static char *tmp_suffix = "/tarXXXXXX"; 616 static char *tname; 617 static char archive[] = "archive0="; 618 static char *Xfile; 619 static char *usefile; 620 static char tfname[1024]; 621 622 static int mulvol; /* multi-volume option selected */ 623 static blkcnt_t blocklim; /* number of blocks to accept per volume */ 624 static blkcnt_t tapepos; /* current block number to be written */ 625 static int NotTape; /* true if tape is a disk */ 626 static int dumping; /* true if writing a tape or other archive */ 627 static int extno; /* number of extent: starts at 1 */ 628 static int extotal; /* total extents in this file */ 629 static off_t extsize; /* size of current extent during extraction */ 630 static ushort_t Oumask = 0; /* old umask value */ 631 static boolean_t is_posix; /* true if archive is POSIX-conformant */ 632 static const char *magic_type = "ustar"; 633 static size_t xrec_size = 8 * PATH_MAX; /* extended rec initial size */ 634 static char *xrec_ptr; 635 static off_t xrec_offset = 0; 636 static int Xhdrflag; 637 static int charset_type = 0; 638 639 static u_longlong_t xhdr_flgs; /* Bits set determine which items */ 640 /* need to be in extended header. */ 641 static pid_t comp_pid = 0; 642 643 static boolean_t debug_output = B_FALSE; 644 645 #define _X_DEVMAJOR 0x1 646 #define _X_DEVMINOR 0x2 647 #define _X_GID 0x4 648 #define _X_GNAME 0x8 649 #define _X_LINKPATH 0x10 650 #define _X_PATH 0x20 651 #define _X_SIZE 0x40 652 #define _X_UID 0x80 653 #define _X_UNAME 0x100 654 #define _X_ATIME 0x200 655 #define _X_CTIME 0x400 656 #define _X_MTIME 0x800 657 #define _X_XHDR 0x1000 /* Bit flag that determines whether 'X' */ 658 /* typeflag was followed by 'A' or non 'A' */ 659 /* typeflag. */ 660 #define _X_LAST 0x40000000 661 662 #define PID_MAX_DIGITS (10 * sizeof (pid_t) / 4) 663 #define TIME_MAX_DIGITS (10 * sizeof (time_t) / 4) 664 #define LONG_MAX_DIGITS (10 * sizeof (long) / 4) 665 #define ULONGLONG_MAX_DIGITS (10 * sizeof (u_longlong_t) / 4) 666 /* 667 * UTF_8 encoding requires more space than the current codeset equivalent. 668 * Currently a factor of 2-3 would suffice, but it is possible for a factor 669 * of 6 to be needed in the future, so for saftey, we use that here. 670 */ 671 #define UTF_8_FACTOR 6 672 673 static u_longlong_t xhdr_count = 0; 674 static char xhdr_dirname[PRESIZ + 1]; 675 static char pidchars[PID_MAX_DIGITS + 1]; 676 static char *tchar = ""; /* null linkpath */ 677 678 static char local_path[UTF_8_FACTOR * PATH_MAX + 1]; 679 static char local_linkpath[UTF_8_FACTOR * PATH_MAX + 1]; 680 static char local_gname[UTF_8_FACTOR * _POSIX_NAME_MAX + 1]; 681 static char local_uname[UTF_8_FACTOR * _POSIX_NAME_MAX + 1]; 682 683 /* 684 * The following mechanism is provided to allow us to debug tar in complicated 685 * situations, like when it is part of a pipe. The idea is that you compile 686 * with -DWAITAROUND defined, and then add the 'D' function modifier to the 687 * target tar invocation, eg. "tar cDf tarfile file". If stderr is available, 688 * it will tell you to which pid to attach the debugger; otherwise, use ps to 689 * find it. Attach to the process from the debugger, and, *PRESTO*, you are 690 * there! 691 * 692 * Simply assign "waitaround = 0" once you attach to the process, and then 693 * proceed from there as usual. 694 */ 695 696 #ifdef WAITAROUND 697 int waitaround = 0; /* wait for rendezvous with the debugger */ 698 #endif 699 700 #define BZIP "/usr/bin/bzip2" 701 #define GZIP "/usr/bin/gzip" 702 #define COMPRESS "/usr/bin/compress" 703 #define XZ "/usr/bin/xz" 704 #define BZCAT "/usr/bin/bzcat" 705 #define GZCAT "/usr/bin/gzcat" 706 #define ZCAT "/usr/bin/zcat" 707 #define XZCAT "/usr/bin/xzcat" 708 #define GSUF 8 /* number of valid 'gzip' sufixes */ 709 #define BSUF 4 /* number of valid 'bzip2' sufixes */ 710 #define XSUF 1 /* number of valid 'xz' suffixes */ 711 712 static char *compress_opt; /* compression type */ 713 714 static char *gsuffix[] = {".gz", "-gz", ".z", "-z", "_z", ".Z", 715 ".tgz", ".taz"}; 716 static char *bsuffix[] = {".bz2", ".bz", ".tbz2", ".tbz"}; 717 static char *xsuffix[] = {".xz"}; 718 static char *suffix; 719 720 721 int 722 main(int argc, char *argv[]) 723 { 724 char *cp; 725 char *tmpdirp; 726 pid_t thispid; 727 728 (void) setlocale(LC_ALL, ""); 729 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 730 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ 731 #endif 732 (void) textdomain(TEXT_DOMAIN); 733 if (argc < 2) 734 usage(); 735 736 debug_output = should_enable_debug(); 737 738 tfile = NULL; 739 if ((myname = strdup(argv[0])) == NULL) { 740 (void) fprintf(stderr, gettext( 741 "tar: cannot allocate program name\n")); 742 exit(1); 743 } 744 745 if (init_yes() < 0) { 746 (void) fprintf(stderr, gettext(ERR_MSG_INIT_YES), 747 strerror(errno)); 748 exit(2); 749 } 750 751 /* 752 * For XPG4 compatibility, we must be able to accept the "--" 753 * argument normally recognized by getopt; it is used to delimit 754 * the end opt the options section, and so can only appear in 755 * the position of the first argument. We simply skip it. 756 */ 757 758 if (strcmp(argv[1], "--") == 0) { 759 argv++; 760 argc--; 761 if (argc < 3) 762 usage(); 763 } 764 765 argv[argc] = NULL; 766 argv++; 767 768 /* 769 * Set up default values. 770 * Search the operand string looking for the first digit or an 'f'. 771 * If you find a digit, use the 'archive#' entry in DEF_FILE. 772 * If 'f' is given, bypass looking in DEF_FILE altogether. 773 * If no digit or 'f' is given, still look in DEF_FILE but use '0'. 774 */ 775 if ((usefile = getenv("TAPE")) == (char *)NULL) { 776 for (cp = *argv; *cp; ++cp) 777 if (isdigit(*cp) || *cp == 'f') 778 break; 779 if (*cp != 'f') { 780 archive[7] = (*cp)? *cp: '0'; 781 if (!(defaults_used = defset(archive))) { 782 usefile = NULL; 783 nblock = 1; 784 blocklim = 0; 785 NotTape = 0; 786 } 787 } 788 } 789 790 for (cp = *argv++; *cp; cp++) 791 switch (*cp) { 792 #ifdef WAITAROUND 793 case 'D': 794 /* rendezvous with the debugger */ 795 waitaround = 1; 796 break; 797 #endif 798 case 'f': 799 assert_string(*argv, gettext( 800 "tar: tarfile must be specified with 'f' " 801 "function modifier\n")); 802 usefile = *argv++; 803 break; 804 case 'F': 805 Fflag++; 806 break; 807 case 'c': 808 cflag++; 809 rflag++; 810 update = 1; 811 break; 812 #if defined(O_XATTR) 813 case '@': 814 atflag++; 815 break; 816 #endif /* O_XATTR */ 817 #if defined(_PC_SATTR_ENABLED) 818 case '/': 819 saflag++; 820 break; 821 #endif /* _PC_SATTR_ENABLED */ 822 case 'u': 823 uflag++; /* moved code after signals caught */ 824 rflag++; 825 update = 2; 826 break; 827 case 'r': 828 rflag++; 829 update = 2; 830 break; 831 case 'v': 832 vflag++; 833 break; 834 case 'w': 835 wflag++; 836 break; 837 case 'x': 838 xflag++; 839 break; 840 case 'X': 841 assert_string(*argv, gettext( 842 "tar: exclude file must be specified with 'X' " 843 "function modifier\n")); 844 Xflag = 1; 845 Xfile = *argv++; 846 build_table(exclude_tbl, Xfile); 847 break; 848 case 't': 849 tflag++; 850 break; 851 case 'm': 852 mflag++; 853 break; 854 case 'p': 855 pflag++; 856 break; 857 case 'D': 858 Dflag++; 859 break; 860 case '-': 861 /* ignore this silently */ 862 break; 863 case '0': /* numeric entries used only for defaults */ 864 case '1': 865 case '2': 866 case '3': 867 case '4': 868 case '5': 869 case '6': 870 case '7': 871 break; 872 case 'b': 873 assert_string(*argv, gettext( 874 "tar: blocking factor must be specified " 875 "with 'b' function modifier\n")); 876 bflag++; 877 nblock = bcheck(*argv++); 878 break; 879 case 'n': /* not a magtape (instead of 'k') */ 880 NotTape++; /* assume non-magtape */ 881 break; 882 case 'l': 883 linkerrok++; 884 break; 885 case 'e': 886 errflag++; 887 case 'o': 888 oflag++; 889 break; 890 case 'h': 891 hflag++; 892 break; 893 case 'i': 894 iflag++; 895 break; 896 case 'B': 897 Bflag++; 898 break; 899 case 'P': 900 Pflag++; 901 break; 902 case 'E': 903 Eflag++; 904 Pflag++; /* Only POSIX archive made */ 905 break; 906 case 'T': 907 Tflag++; /* Handle Trusted Extensions attrs */ 908 pflag++; /* also set flag for ACL */ 909 break; 910 case 'j': /* compession "bzip2" */ 911 jflag = 1; 912 break; 913 case 'z': /* compression "gzip" */ 914 zflag = 1; 915 break; 916 case 'Z': /* compression "compress" */ 917 Zflag = 1; 918 break; 919 case 'J': /* compression "xz" */ 920 Jflag = 1; 921 break; 922 case 'a': 923 aflag = 1; /* autocompression */ 924 break; 925 default: 926 (void) fprintf(stderr, gettext( 927 "tar: %c: unknown function modifier\n"), *cp); 928 usage(); 929 } 930 931 if (!rflag && !xflag && !tflag) 932 usage(); 933 if ((rflag && xflag) || (xflag && tflag) || (rflag && tflag)) { 934 (void) fprintf(stderr, gettext( 935 "tar: specify only one of [ctxru].\n")); 936 usage(); 937 } 938 if (cflag) { 939 if ((jflag + zflag + Zflag + Jflag + aflag) > 1) { 940 (void) fprintf(stderr, gettext( 941 "tar: specify only one of [ajJzZ] to " 942 "create a compressed file.\n")); 943 usage(); 944 } 945 } 946 /* Trusted Extensions attribute handling */ 947 if (Tflag && ((getzoneid() != GLOBAL_ZONEID) || 948 !is_system_labeled())) { 949 (void) fprintf(stderr, gettext( 950 "tar: the 'T' option is only available with " 951 "Trusted Extensions\nand must be run from " 952 "the global zone.\n")); 953 usage(); 954 } 955 if (cflag && *argv == NULL) 956 fatal(gettext("Missing filenames")); 957 if (usefile == NULL) 958 fatal(gettext("device argument required")); 959 960 /* alloc a buffer of the right size */ 961 if ((tbuf = (union hblock *) 962 calloc(sizeof (union hblock) * nblock, sizeof (char))) == 963 (union hblock *)NULL) { 964 (void) fprintf(stderr, gettext( 965 "tar: cannot allocate physio buffer\n")); 966 exit(1); 967 } 968 969 if ((xrec_ptr = malloc(xrec_size)) == NULL) { 970 (void) fprintf(stderr, gettext( 971 "tar: cannot allocate extended header buffer\n")); 972 exit(1); 973 } 974 975 #ifdef WAITAROUND 976 if (waitaround) { 977 (void) fprintf(stderr, gettext("Rendezvous with tar on pid" 978 " %d\n"), getpid()); 979 980 while (waitaround) { 981 (void) sleep(10); 982 } 983 } 984 #endif 985 986 thispid = getpid(); 987 (void) sprintf(pidchars, "%ld", thispid); 988 thispid = strlen(pidchars); 989 990 if ((tmpdirp = getenv("TMPDIR")) == (char *)NULL) 991 (void) strcpy(xhdr_dirname, "/tmp"); 992 else { 993 /* 994 * Make sure that dir is no longer than what can 995 * fit in the prefix part of the header. 996 */ 997 if (strlen(tmpdirp) > (size_t)(PRESIZ - thispid - 12)) { 998 (void) strcpy(xhdr_dirname, "/tmp"); 999 if ((vflag > 0) && (Eflag > 0)) 1000 (void) fprintf(stderr, gettext( 1001 "Ignoring TMPDIR\n")); 1002 } else 1003 (void) strcpy(xhdr_dirname, tmpdirp); 1004 } 1005 (void) strcat(xhdr_dirname, "/PaxHeaders."); 1006 (void) strcat(xhdr_dirname, pidchars); 1007 1008 if (rflag) { 1009 if (cflag && usefile != NULL) { 1010 /* Set the compression type */ 1011 if (aflag) 1012 detect_compress(); 1013 1014 if (jflag) { 1015 compress_opt = compress_malloc(strlen(BZIP) 1016 + 1); 1017 (void) strcpy(compress_opt, BZIP); 1018 } else if (zflag) { 1019 compress_opt = compress_malloc(strlen(GZIP) 1020 + 1); 1021 (void) strcpy(compress_opt, GZIP); 1022 } else if (Zflag) { 1023 compress_opt = 1024 compress_malloc(strlen(COMPRESS) + 1); 1025 (void) strcpy(compress_opt, COMPRESS); 1026 } else if (Jflag) { 1027 compress_opt = compress_malloc(strlen(XZ) + 1); 1028 (void) strcpy(compress_opt, XZ); 1029 } 1030 } else { 1031 /* 1032 * Decompress if the file is compressed for 1033 * an update or replace. 1034 */ 1035 if (strcmp(usefile, "-") != 0) { 1036 check_compression(); 1037 if (compress_opt != NULL) { 1038 decompress_file(); 1039 } 1040 } 1041 } 1042 1043 if (cflag && tfile != NULL) 1044 usage(); 1045 if (signal(SIGINT, SIG_IGN) != SIG_IGN) 1046 (void) signal(SIGINT, onintr); 1047 if (signal(SIGHUP, SIG_IGN) != SIG_IGN) 1048 (void) signal(SIGHUP, onhup); 1049 if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) 1050 (void) signal(SIGQUIT, onquit); 1051 if (uflag) { 1052 int tnum; 1053 struct stat sbuf; 1054 1055 tmpdir = getenv("TMPDIR"); 1056 /* 1057 * If the name is invalid or this isn't a directory, 1058 * or the directory is not writable, then reset to 1059 * a default temporary directory. 1060 */ 1061 if (tmpdir == NULL || *tmpdir == '\0' || 1062 (strlen(tmpdir) + strlen(tmp_suffix)) > PATH_MAX) { 1063 tmpdir = "/tmp"; 1064 } else if (stat(tmpdir, &sbuf) < 0 || 1065 (sbuf.st_mode & S_IFMT) != S_IFDIR || 1066 (sbuf.st_mode & S_IWRITE) == 0) { 1067 tmpdir = "/tmp"; 1068 } 1069 1070 if ((tname = calloc(1, strlen(tmpdir) + 1071 strlen(tmp_suffix) + 1)) == NULL) { 1072 vperror(1, gettext("tar: out of memory, " 1073 "cannot create temporary file\n")); 1074 } 1075 (void) strcpy(tname, tmpdir); 1076 (void) strcat(tname, tmp_suffix); 1077 1078 if ((tnum = mkstemp(tname)) == -1) 1079 vperror(1, "%s", tname); 1080 if ((tfile = fdopen(tnum, "w")) == NULL) 1081 vperror(1, "%s", tname); 1082 } 1083 if (strcmp(usefile, "-") == 0) { 1084 if (cflag == 0) 1085 fatal(gettext( 1086 "can only create standard output archives.")); 1087 vfile = stderr; 1088 mt = dup(1); 1089 ++bflag; 1090 } else { 1091 if (cflag) 1092 mt = open(usefile, 1093 O_RDWR|O_CREAT|O_TRUNC, 0666); 1094 else 1095 mt = open(usefile, O_RDWR); 1096 1097 if (mt < 0) { 1098 if (cflag == 0 || (mt = creat(usefile, 0666)) 1099 < 0) 1100 vperror(1, "%s", usefile); 1101 } 1102 } 1103 /* Get inode and device number of output file */ 1104 (void) fstat(mt, &stbuf); 1105 mt_ino = stbuf.st_ino; 1106 mt_dev = stbuf.st_dev; 1107 mt_devtype = stbuf.st_mode & S_IFMT; 1108 NotTape = !istape(mt, mt_devtype); 1109 1110 if (rflag && !cflag && (mt_devtype == S_IFIFO)) 1111 fatal(gettext("cannot append to pipe or FIFO.")); 1112 1113 if (Aflag && vflag) 1114 (void) printf( 1115 gettext("Suppressing absolute pathnames\n")); 1116 if (cflag && compress_opt != NULL) 1117 comp_pid = compress_file(); 1118 dorep(argv); 1119 if (rflag && !cflag && (compress_opt != NULL)) 1120 compress_back(); 1121 } else if (xflag || tflag) { 1122 /* 1123 * for each argument, check to see if there is a "-I file" pair. 1124 * if so, move the 3rd argument into "-I"'s place, build_table() 1125 * using "file"'s name and increment argc one (the second 1126 * increment appears in the for loop) which removes the two 1127 * args "-I" and "file" from the argument vector. 1128 */ 1129 for (argc = 0; argv[argc]; argc++) { 1130 if (strcmp(argv[argc], "-I") == 0) { 1131 if (!argv[argc+1]) { 1132 (void) fprintf(stderr, gettext( 1133 "tar: missing argument for -I flag\n")); 1134 done(2); 1135 } else { 1136 Iflag = 1; 1137 argv[argc] = argv[argc+2]; 1138 build_table(include_tbl, argv[++argc]); 1139 } 1140 } else if (strcmp(argv[argc], "-C") == 0) { 1141 if (!argv[argc+1]) { 1142 (void) fprintf(stderr, gettext("tar: " 1143 "missing argument for -C flag\n")); 1144 done(2); 1145 } else if (xtract_chdir != NULL) { 1146 (void) fprintf(stderr, gettext("tar: " 1147 "extract should have only one -C " 1148 "flag\n")); 1149 done(2); 1150 } else { 1151 argv[argc] = argv[argc+2]; 1152 xtract_chdir = argv[++argc]; 1153 } 1154 } 1155 } 1156 if (strcmp(usefile, "-") == 0) { 1157 mt = dup(0); 1158 ++bflag; 1159 /* try to recover from short reads when reading stdin */ 1160 ++Bflag; 1161 } else if ((mt = open(usefile, 0)) < 0) 1162 vperror(1, "%s", usefile); 1163 1164 /* Decompress if the file is compressed */ 1165 1166 if (strcmp(usefile, "-") != 0) { 1167 check_compression(); 1168 if (compress_opt != NULL) 1169 comp_pid = uncompress_file(); 1170 } 1171 if (xflag) { 1172 if (xtract_chdir != NULL) { 1173 if (tar_chdir(xtract_chdir) < 0) { 1174 vperror(1, gettext("can't change " 1175 "directories to %s"), xtract_chdir); 1176 } 1177 } 1178 if (Aflag && vflag) 1179 (void) printf(gettext( 1180 "Suppressing absolute pathnames.\n")); 1181 1182 doxtract(argv); 1183 } else if (tflag) 1184 dotable(argv); 1185 } 1186 else 1187 usage(); 1188 1189 done(Errflg); 1190 1191 /* Not reached: keep compiler quiet */ 1192 return (1); 1193 } 1194 1195 static boolean_t 1196 should_enable_debug(void) 1197 { 1198 const char *val; 1199 const char *truth[] = { 1200 "true", 1201 "1", 1202 "yes", 1203 "y", 1204 "please", 1205 NULL 1206 }; 1207 unsigned int i; 1208 1209 if ((val = getenv("DEBUG_TAR")) == NULL) { 1210 return (B_FALSE); 1211 } 1212 1213 for (i = 0; truth[i] != NULL; i++) { 1214 if (strcmp(val, truth[i]) == 0) { 1215 return (B_TRUE); 1216 } 1217 } 1218 1219 return (B_FALSE); 1220 } 1221 1222 /*PRINTFLIKE1*/ 1223 static void 1224 dlog(const char *format, ...) 1225 { 1226 va_list ap; 1227 1228 if (!debug_output) { 1229 return; 1230 } 1231 1232 va_start(ap, format); 1233 (void) fprintf(stderr, "tar: DEBUG: "); 1234 (void) vfprintf(stderr, format, ap); 1235 va_end(ap); 1236 } 1237 1238 static void 1239 usage(void) 1240 { 1241 (void) fprintf(stderr, gettext( 1242 #if defined(O_XATTR) 1243 #if defined(_PC_SATTR_ENABLED) 1244 "Usage: tar {c|r|t|u|x}[BDeEFhilmnopPTvw@/[0-7]][bf][X...] " 1245 #else 1246 "Usage: tar {c|r|t|u|x}[BDeEFhilmnopPTvw@[0-7]][bf][X...] " 1247 #endif /* _PC_SATTR_ENABLED */ 1248 #else 1249 "Usage: tar {c|r|t|u|x}[BDeEFhilmnopPTvw[0-7]][bf][X...] " 1250 #endif /* O_XATTR */ 1251 "[j|J|z|Z] " 1252 "[blocksize] [tarfile] [size] [exclude-file...] " 1253 "{file | -I include-file | -C directory file}...\n")); 1254 done(1); 1255 } 1256 1257 /* 1258 * dorep - do "replacements" 1259 * 1260 * Dorep is responsible for creating ('c'), appending ('r') 1261 * and updating ('u'); 1262 */ 1263 1264 static void 1265 dorep(char *argv[]) 1266 { 1267 char *cp, *cp2, *p; 1268 char wdir[PATH_MAX+2], tempdir[PATH_MAX+2], *parent; 1269 char file[PATH_MAX*2], origdir[PATH_MAX+1]; 1270 FILE *fp = (FILE *)NULL; 1271 int archtype; 1272 int ret; 1273 1274 1275 if (!cflag) { 1276 xhdr_flgs = 0; 1277 getdir(); /* read header for next file */ 1278 if (Xhdrflag > 0) { 1279 if (!Eflag) 1280 fatal(gettext("Archive contains extended" 1281 " header. -E flag required.\n")); 1282 ret = get_xdata(); /* Get extended header items */ 1283 /* and regular header */ 1284 } else { 1285 if (Eflag) 1286 fatal(gettext("Archive contains no extended" 1287 " header. -E flag not allowed.\n")); 1288 } 1289 while (!endtape()) { /* changed from a do while */ 1290 setbytes_to_skip(&stbuf, ret); 1291 passtape(); /* skip the file data */ 1292 if (term) 1293 done(Errflg); /* received signal to stop */ 1294 xhdr_flgs = 0; 1295 getdir(); 1296 if (Xhdrflag > 0) 1297 ret = get_xdata(); 1298 } 1299 if (ret == 0) { 1300 if ((dblock.dbuf.typeflag != 'A') && 1301 (xhdr_flgs != 0)) { 1302 load_info_from_xtarhdr(xhdr_flgs, 1303 &Xtarhdr); 1304 xhdr_flgs |= _X_XHDR; 1305 } 1306 } 1307 backtape(); /* was called by endtape */ 1308 if (tfile != NULL) { 1309 /* 1310 * Buffer size is calculated to be the size of the 1311 * tmpdir string, plus 6 times the size of the tname 1312 * string, plus a value that is known to be greater 1313 * than the command pipeline string. 1314 */ 1315 int buflen = strlen(tmpdir) + (6 * strlen(tname)) + 100; 1316 char *buf; 1317 1318 if ((buf = (char *)calloc(1, buflen)) == NULL) { 1319 vperror(1, gettext("tar: out of memory, " 1320 "cannot create sort command file\n")); 1321 } 1322 1323 (void) snprintf(buf, buflen, "env 'TMPDIR=%s' " 1324 "sort +0 -1 +1nr %s -o %s; awk '$1 " 1325 "!= prev {print; prev=$1}' %s >%sX;mv %sX %s", 1326 tmpdir, tname, tname, tname, tname, tname, tname); 1327 (void) fflush(tfile); 1328 (void) system(buf); 1329 free(buf); 1330 (void) freopen(tname, "r", tfile); 1331 (void) fstat(fileno(tfile), &stbuf); 1332 high = stbuf.st_size; 1333 } 1334 } 1335 1336 dumping = 1; 1337 if (mulvol) { /* SP-1 */ 1338 if (nblock && (blocklim%nblock) != 0) 1339 fatal(gettext( 1340 "Volume size not a multiple of block size.")); 1341 blocklim -= 2; /* for trailer records */ 1342 if (vflag) 1343 (void) fprintf(vfile, gettext("Volume ends at %" 1344 FMT_blkcnt_t "K, blocking factor = %dK\n"), 1345 K((blocklim - 1)), K(nblock)); 1346 } 1347 1348 /* 1349 * Save the original directory before it gets 1350 * changed. 1351 */ 1352 if (getcwd(origdir, (PATH_MAX+1)) == NULL) { 1353 vperror(0, gettext("A parent directory cannot be read")); 1354 exit(1); 1355 } 1356 1357 (void) strcpy(wdir, origdir); 1358 1359 while ((*argv || fp) && !term) { 1360 if (fp || (strcmp(*argv, "-I") == 0)) { 1361 if (fp == NULL) { 1362 if (*++argv == NULL) 1363 fatal(gettext( 1364 "missing file name for -I flag.")); 1365 else if ((fp = fopen(*argv++, "r")) == NULL) 1366 vperror(0, "%s", argv[-1]); 1367 continue; 1368 } else if ((fgets(file, PATH_MAX-1, fp)) == NULL) { 1369 (void) fclose(fp); 1370 fp = NULL; 1371 continue; 1372 } else { 1373 cp = cp2 = file; 1374 if ((p = strchr(cp2, '\n'))) 1375 *p = 0; 1376 } 1377 } else if ((strcmp(*argv, "-C") == 0) && argv[1]) { 1378 if (tar_chdir(*++argv) < 0) 1379 vperror(0, gettext( 1380 "can't change directories to %s"), *argv); 1381 else 1382 (void) getcwd(wdir, (sizeof (wdir))); 1383 argv++; 1384 continue; 1385 } else 1386 cp = cp2 = strcpy(file, *argv++); 1387 1388 /* 1389 * point cp2 to the last '/' in file, but not 1390 * to a trailing '/' 1391 */ 1392 for (; *cp; cp++) { 1393 if (*cp == '/') { 1394 while (*(cp+1) == '/') { 1395 ++cp; 1396 } 1397 if (*(cp+1) != '\0') { 1398 /* not trailing slash */ 1399 cp2 = cp; 1400 } 1401 } 1402 } 1403 if (cp2 != file) { 1404 *cp2 = '\0'; 1405 if (tar_chdir(file) < 0) { 1406 vperror(0, gettext( 1407 "can't change directories to %s"), file); 1408 continue; 1409 } 1410 *cp2 = '/'; 1411 cp2++; 1412 } 1413 1414 parent = getcwd(tempdir, (sizeof (tempdir))); 1415 1416 archtype = putfile(file, cp2, parent, NULL, NORMAL_FILE, 1417 LEV0, SYMLINK_LEV0); 1418 1419 #if defined(O_XATTR) 1420 if (!exitflag) { 1421 if ((atflag || saflag) && 1422 (archtype == PUT_NOTAS_LINK)) { 1423 xattrs_put(file, cp2, parent, NULL); 1424 } 1425 } 1426 #endif 1427 1428 if (tar_chdir(origdir) < 0) 1429 vperror(0, gettext("cannot change back?: %s"), origdir); 1430 1431 if (exitflag) { 1432 /* 1433 * If e function modifier has been specified 1434 * write the files (that are listed before the 1435 * file causing the error) to tape. exitflag is 1436 * used because only some of the error conditions 1437 * in putfile() recognize the e function modifier. 1438 */ 1439 break; 1440 } 1441 } 1442 1443 putempty((blkcnt_t)2); 1444 flushtape(); 1445 closevol(); /* SP-1 */ 1446 if (linkerrok == 1) 1447 for (; ihead != NULL; ihead = ihead->nextp) { 1448 if (ihead->count == 0) 1449 continue; 1450 (void) fprintf(stderr, gettext( 1451 "tar: missing links to %s\n"), ihead->pathname); 1452 if (errflag) 1453 done(1); 1454 else 1455 Errflg = 1; 1456 } 1457 } 1458 1459 1460 /* 1461 * endtape - check for tape at end 1462 * 1463 * endtape checks the entry in dblock.dbuf to see if its the 1464 * special EOT entry. Endtape is usually called after getdir(). 1465 * 1466 * endtape used to call backtape; it no longer does, he who 1467 * wants it backed up must call backtape himself 1468 * RETURNS: 0 if not EOT, tape position unaffected 1469 * 1 if EOT, tape position unaffected 1470 */ 1471 1472 static boolean_t 1473 endtape(void) 1474 { 1475 if (dblock.dbuf.name[0] != '\0') { 1476 /* 1477 * The name field is populated. 1478 */ 1479 return (B_FALSE); 1480 } 1481 1482 if (is_posix && dblock.dbuf.prefix[0] != '\0') { 1483 /* 1484 * This is a ustar/POSIX archive, and although the name 1485 * field is empty the prefix field is not. 1486 */ 1487 return (B_FALSE); 1488 } 1489 1490 dlog("endtape(): found null header; EOT\n"); 1491 return (B_TRUE); 1492 } 1493 1494 /* 1495 * getdir - get directory entry from tar tape 1496 * 1497 * getdir reads the next tarblock off the tape and cracks 1498 * it as a directory. The checksum must match properly. 1499 * 1500 * If tfile is non-null getdir writes the file name and mod date 1501 * to tfile. 1502 */ 1503 1504 static void 1505 getdir(void) 1506 { 1507 struct stat *sp; 1508 #ifdef EUC 1509 static int warn_chksum_sign = 0; 1510 #endif /* EUC */ 1511 1512 top: 1513 readtape((char *)&dblock); 1514 if (dblock.dbuf.name[0] == '\0') 1515 return; 1516 sp = &stbuf; 1517 (void) sscanf(dblock.dbuf.mode, "%8lo", &Gen.g_mode); 1518 (void) sscanf(dblock.dbuf.uid, "%8lo", (ulong_t *)&Gen.g_uid); 1519 (void) sscanf(dblock.dbuf.gid, "%8lo", (ulong_t *)&Gen.g_gid); 1520 (void) sscanf(dblock.dbuf.size, "%12" FMT_off_t_o, &Gen.g_filesz); 1521 (void) sscanf(dblock.dbuf.mtime, "%12lo", (ulong_t *)&Gen.g_mtime); 1522 (void) sscanf(dblock.dbuf.chksum, "%8o", &Gen.g_cksum); 1523 (void) sscanf(dblock.dbuf.devmajor, "%8lo", &Gen.g_devmajor); 1524 (void) sscanf(dblock.dbuf.devminor, "%8lo", &Gen.g_devminor); 1525 1526 is_posix = (strcmp(dblock.dbuf.magic, magic_type) == 0); 1527 1528 sp->st_mode = Gen.g_mode; 1529 if (is_posix && (sp->st_mode & S_IFMT) == 0) { 1530 switch (dblock.dbuf.typeflag) { 1531 case '0': 1532 case 0: 1533 case _XATTR_HDRTYPE: 1534 sp->st_mode |= S_IFREG; 1535 break; 1536 case '1': /* hard link */ 1537 break; 1538 case '2': 1539 sp->st_mode |= S_IFLNK; 1540 break; 1541 case '3': 1542 sp->st_mode |= S_IFCHR; 1543 break; 1544 case '4': 1545 sp->st_mode |= S_IFBLK; 1546 break; 1547 case '5': 1548 sp->st_mode |= S_IFDIR; 1549 break; 1550 case '6': 1551 sp->st_mode |= S_IFIFO; 1552 break; 1553 default: 1554 if (convtoreg(Gen.g_filesz)) 1555 sp->st_mode |= S_IFREG; 1556 break; 1557 } 1558 } 1559 1560 if ((dblock.dbuf.typeflag == 'X') || (dblock.dbuf.typeflag == 'L')) { 1561 Xhdrflag = 1; /* Currently processing extended header */ 1562 } else { 1563 Xhdrflag = 0; 1564 } 1565 1566 sp->st_uid = Gen.g_uid; 1567 sp->st_gid = Gen.g_gid; 1568 sp->st_size = Gen.g_filesz; 1569 sp->st_mtime = Gen.g_mtime; 1570 chksum = Gen.g_cksum; 1571 1572 if (dblock.dbuf.extno != '\0') { /* split file? */ 1573 extno = dblock.dbuf.extno; 1574 extsize = Gen.g_filesz; 1575 extotal = dblock.dbuf.extotal; 1576 } else { 1577 extno = 0; /* tell others file not split */ 1578 extsize = 0; 1579 extotal = 0; 1580 } 1581 1582 #ifdef EUC 1583 if (chksum != checksum(&dblock)) { 1584 if (chksum != checksum_signed(&dblock)) { 1585 (void) fprintf(stderr, gettext( 1586 "tar: directory checksum error\n")); 1587 if (iflag) { 1588 Errflg = 2; 1589 goto top; 1590 } 1591 done(2); 1592 } else { 1593 if (! warn_chksum_sign) { 1594 warn_chksum_sign = 1; 1595 (void) fprintf(stderr, gettext( 1596 "tar: warning: tar file made with signed checksum\n")); 1597 } 1598 } 1599 } 1600 #else 1601 if (chksum != checksum(&dblock)) { 1602 (void) fprintf(stderr, gettext( 1603 "tar: directory checksum error\n")); 1604 if (iflag) { 1605 Errflg = 2; 1606 goto top; 1607 } 1608 done(2); 1609 } 1610 #endif /* EUC */ 1611 if (tfile != NULL && Xhdrflag == 0) { 1612 /* 1613 * If an extended header is present, then time is available 1614 * in nanoseconds in the extended header data, so set it. 1615 * Otherwise, give an invalid value so that checkupdate will 1616 * not test beyond seconds. 1617 */ 1618 if ((xhdr_flgs & _X_MTIME)) 1619 sp->st_mtim.tv_nsec = Xtarhdr.x_mtime.tv_nsec; 1620 else 1621 sp->st_mtim.tv_nsec = -1; 1622 1623 if (xhdr_flgs & _X_PATH) 1624 (void) fprintf(tfile, "%s %10ld.%9.9ld\n", 1625 Xtarhdr.x_path, sp->st_mtim.tv_sec, 1626 sp->st_mtim.tv_nsec); 1627 else 1628 (void) fprintf(tfile, "%.*s %10ld.%9.9ld\n", 1629 NAMSIZ, dblock.dbuf.name, sp->st_mtim.tv_sec, 1630 sp->st_mtim.tv_nsec); 1631 } 1632 1633 #if defined(O_XATTR) 1634 Hiddendir = 0; 1635 if (xattrp && dblock.dbuf.typeflag == _XATTR_HDRTYPE) { 1636 if (xattrbadhead) { 1637 free(xattrhead); 1638 xattrp = NULL; 1639 xattr_linkp = NULL; 1640 xattrhead = NULL; 1641 } else { 1642 char *aname = basename(xattrapath); 1643 size_t xindex = aname - xattrapath; 1644 1645 if (xattrapath[xindex] == '.' && 1646 xattrapath[xindex + 1] == '\0' && 1647 xattrp->h_typeflag == '5') { 1648 Hiddendir = 1; 1649 sp->st_mode = 1650 (S_IFDIR | (sp->st_mode & POSIXMODES)); 1651 } 1652 dblock.dbuf.typeflag = xattrp->h_typeflag; 1653 } 1654 } 1655 #endif 1656 } 1657 1658 1659 /* 1660 * passtape - skip over a file on the tape 1661 * 1662 * passtape skips over the next data file on the tape. 1663 * The tape directory entry must be in dblock.dbuf. This 1664 * routine just eats the number of blocks computed from the 1665 * directory size entry; the tape must be (logically) positioned 1666 * right after the directory info. 1667 */ 1668 1669 static void 1670 passtape(void) 1671 { 1672 blkcnt_t blocks; 1673 char buf[TBLOCK]; 1674 1675 /* 1676 * Print some debugging information about the directory entry 1677 * we are skipping over: 1678 */ 1679 dlog("passtape: typeflag \"%c\"\n", dblock.dbuf.typeflag); 1680 if (dblock.dbuf.name[0] != '\0') { 1681 dlog("passtape: name \"%s\"\n", dblock.dbuf.name); 1682 } 1683 if (is_posix && dblock.dbuf.prefix[0] != '\0') { 1684 dlog("passtape: prefix \"%s\"\n", dblock.dbuf.prefix); 1685 } 1686 1687 /* 1688 * Types link(1), sym-link(2), char special(3), blk special(4), 1689 * directory(5), and FIFO(6) do not have data blocks associated 1690 * with them so just skip reading the data block. 1691 */ 1692 if (dblock.dbuf.typeflag == '1' || dblock.dbuf.typeflag == '2' || 1693 dblock.dbuf.typeflag == '3' || dblock.dbuf.typeflag == '4' || 1694 dblock.dbuf.typeflag == '5' || dblock.dbuf.typeflag == '6') 1695 return; 1696 blocks = TBLOCKS(stbuf.st_size); 1697 1698 dlog("passtape: block count %" FMT_blkcnt_t "\n", blocks); 1699 1700 /* if operating on disk, seek instead of reading */ 1701 if (NotTape) 1702 seekdisk(blocks); 1703 else 1704 while (blocks-- > 0) 1705 readtape(buf); 1706 } 1707 1708 #if defined(O_XATTR) 1709 static int 1710 is_sysattr(char *name) 1711 { 1712 return ((strcmp(name, VIEW_READONLY) == 0) || 1713 (strcmp(name, VIEW_READWRITE) == 0)); 1714 } 1715 #endif 1716 1717 #if defined(O_XATTR) 1718 /* 1719 * Verify the attribute, attrname, is an attribute we want to restore. 1720 * Never restore read-only system attribute files. Only restore read-write 1721 * system attributes files when -/ was specified, and only traverse into 1722 * the 2nd level attribute directory containing only system attributes if 1723 * -@ was specified. This keeps us from archiving 1724 * <attribute name>/<read-write system attribute file> 1725 * when -/ was specified without -@. 1726 * 1727 * attrname - attribute file name 1728 * attrparent - attribute's parent name within the base file's attribute 1729 * directory hierarchy 1730 */ 1731 static attr_status_t 1732 verify_attr(char *attrname, char *attrparent, int arc_rwsysattr, 1733 int *rw_sysattr) 1734 { 1735 #if defined(_PC_SATTR_ENABLED) 1736 int attr_supported; 1737 1738 /* Never restore read-only system attribute files */ 1739 if ((attr_supported = sysattr_type(attrname)) == _RO_SATTR) { 1740 *rw_sysattr = 0; 1741 return (ATTR_SKIP); 1742 } else { 1743 *rw_sysattr = (attr_supported == _RW_SATTR); 1744 } 1745 #else 1746 /* 1747 * Only need to check if this attribute is an extended system 1748 * attribute. 1749 */ 1750 if (*rw_sysattr = is_sysattr(attrname)) { 1751 return (ATTR_SKIP); 1752 } else { 1753 return (ATTR_OK); 1754 } 1755 #endif /* _PC_SATTR_ENABLED */ 1756 1757 /* 1758 * If the extended system attribute file is specified with the 1759 * arc_rwsysattr flag, as being transient (default extended 1760 * attributes), then don't archive it. 1761 */ 1762 if (*rw_sysattr && !arc_rwsysattr) { 1763 return (ATTR_SKIP); 1764 } 1765 1766 /* 1767 * Only restore read-write system attribute files 1768 * when -/ was specified. Only restore extended 1769 * attributes when -@ was specified. 1770 */ 1771 if (atflag) { 1772 if (!saflag) { 1773 /* 1774 * Only archive/restore the hidden directory "." if 1775 * we're processing the top level hidden attribute 1776 * directory. We don't want to process the 1777 * hidden attribute directory of the attribute 1778 * directory that contains only extended system 1779 * attributes. 1780 */ 1781 if (*rw_sysattr || (Hiddendir && 1782 (attrparent != NULL))) { 1783 return (ATTR_SKIP); 1784 } 1785 } 1786 } else if (saflag) { 1787 /* 1788 * Only archive/restore read-write extended system attribute 1789 * files of the base file. 1790 */ 1791 if (!*rw_sysattr || (attrparent != NULL)) { 1792 return (ATTR_SKIP); 1793 } 1794 } else { 1795 return (ATTR_SKIP); 1796 } 1797 1798 return (ATTR_OK); 1799 } 1800 #endif 1801 1802 static void 1803 free_children(file_list_t *children) 1804 { 1805 file_list_t *child = children; 1806 file_list_t *cptr; 1807 1808 while (child != NULL) { 1809 cptr = child->next; 1810 if (child->name != NULL) { 1811 free(child->name); 1812 } 1813 child = cptr; 1814 } 1815 } 1816 1817 static int 1818 putfile(char *longname, char *shortname, char *parent, attr_data_t *attrinfo, 1819 int filetype, int lev, int symlink_lev) 1820 { 1821 int infile = -1; /* deliberately invalid */ 1822 blkcnt_t blocks; 1823 char buf[PATH_MAX + 2]; /* Add trailing slash and null */ 1824 char *bigbuf; 1825 int maxread; 1826 int hint; /* amount to write to get "in sync" */ 1827 char filetmp[PATH_MAX + 1]; 1828 char *cp; 1829 char *name; 1830 char *attrparent = NULL; 1831 char *longattrname = NULL; 1832 file_list_t *child = NULL; 1833 file_list_t *child_end = NULL; 1834 file_list_t *cptr; 1835 struct dirent *dp; 1836 DIR *dirp; 1837 int i; 1838 int split; 1839 int dirfd = -1; 1840 int rc = PUT_NOTAS_LINK; 1841 int archtype = 0; 1842 int rw_sysattr = 0; 1843 char newparent[PATH_MAX + MAXNAMLEN + 1]; 1844 char *prefix = ""; 1845 char *tmpbuf; 1846 char goodbuf[PRESIZ + 2]; 1847 char junkbuf[MAXNAM+1]; 1848 char *lastslash; 1849 int j; 1850 struct stat sbuf; 1851 int readlink_max; 1852 1853 (void) memset(goodbuf, '\0', sizeof (goodbuf)); 1854 (void) memset(junkbuf, '\0', sizeof (junkbuf)); 1855 1856 xhdr_flgs = 0; 1857 1858 if (filetype == XATTR_FILE) { 1859 attrparent = attrinfo->attr_parent; 1860 longattrname = attrinfo->attr_path; 1861 dirfd = attrinfo->attr_parentfd; 1862 rw_sysattr = attrinfo->attr_rw_sysattr; 1863 } else { 1864 dirfd = open(".", O_RDONLY); 1865 } 1866 1867 if (dirfd == -1) { 1868 (void) fprintf(stderr, gettext( 1869 "tar: unable to open%sdirectory %s%s%s%s\n"), 1870 (filetype == XATTR_FILE) ? gettext(" attribute ") : " ", 1871 (attrparent == NULL) ? "" : gettext("of attribute "), 1872 (attrparent == NULL) ? "" : attrparent, 1873 (attrparent == NULL) ? "" : gettext(" of "), 1874 (filetype == XATTR_FILE) ? longname : parent); 1875 goto out; 1876 } 1877 1878 if (lev > MAXLEV) { 1879 (void) fprintf(stderr, 1880 gettext("tar: directory nesting too deep, %s not dumped\n"), 1881 longname); 1882 goto out; 1883 } 1884 1885 if (getstat(dirfd, longname, shortname, attrparent)) 1886 goto out; 1887 1888 if (hflag) { 1889 /* 1890 * Catch nesting where a file is a symlink to its directory. 1891 */ 1892 j = fstatat(dirfd, shortname, &sbuf, AT_SYMLINK_NOFOLLOW); 1893 if (S_ISLNK(sbuf.st_mode)) { 1894 if (symlink_lev++ >= MAXSYMLINKS) { 1895 (void) fprintf(stderr, gettext( 1896 "tar: %s: Number of symbolic links " 1897 "encountered during path name traversal " 1898 "exceeds MAXSYMLINKS\n"), longname); 1899 Errflg = 1; 1900 goto out; 1901 } 1902 } 1903 } 1904 1905 /* 1906 * Check if the input file is the same as the tar file we 1907 * are creating 1908 */ 1909 if ((mt_ino == stbuf.st_ino) && (mt_dev == stbuf.st_dev)) { 1910 (void) fprintf(stderr, gettext( 1911 "tar: %s%s%s%s%s same as archive file\n"), 1912 rw_sysattr ? gettext("system ") : "", 1913 (longattrname == NULL) ? "" : gettext("attribute "), 1914 (longattrname == NULL) ? "" : longattrname, 1915 (longattrname == NULL) ? "" : gettext(" of "), 1916 longname); 1917 Errflg = 1; 1918 goto out; 1919 } 1920 /* 1921 * Check size limit - we can't archive files that 1922 * exceed TAR_OFFSET_MAX bytes because of header 1923 * limitations. Exclude file types that set 1924 * st_size to zero below because they take no 1925 * archive space to represent contents. 1926 */ 1927 if ((stbuf.st_size > (off_t)TAR_OFFSET_MAX) && 1928 !S_ISDIR(stbuf.st_mode) && 1929 !S_ISCHR(stbuf.st_mode) && 1930 !S_ISBLK(stbuf.st_mode) && 1931 (Eflag == 0)) { 1932 (void) fprintf(stderr, gettext( 1933 "tar: %s%s%s%s%s too large to archive. " 1934 "Use E function modifier.\n"), 1935 rw_sysattr ? gettext("system ") : "", 1936 (longattrname == NULL) ? "" : gettext("attribute "), 1937 (longattrname == NULL) ? "" : longattrname, 1938 (longattrname == NULL) ? "" : gettext(" of "), 1939 longname); 1940 if (errflag) 1941 exitflag = 1; 1942 Errflg = 1; 1943 goto out; 1944 } 1945 1946 if (tfile != NULL && checkupdate(longname) == 0) { 1947 goto out; 1948 } 1949 if (checkw('r', longname) == 0) { 1950 goto out; 1951 } 1952 1953 if (Fflag && 1954 checkf(longname, (stbuf.st_mode & S_IFMT) == S_IFDIR, Fflag) == 0) 1955 goto out; 1956 1957 if (Xflag) { 1958 if (is_in_table(exclude_tbl, longname)) { 1959 if (vflag) { 1960 (void) fprintf(vfile, gettext( 1961 "a %s excluded\n"), longname); 1962 } 1963 goto out; 1964 } 1965 } 1966 1967 /* 1968 * If the length of the fullname is greater than MAXNAM, 1969 * print out a message and return (unless extended headers are used, 1970 * in which case fullname is limited to PATH_MAX). 1971 */ 1972 1973 if ((((split = (int)strlen(longname)) > MAXNAM) && (Eflag == 0)) || 1974 (split > PATH_MAX)) { 1975 (void) fprintf(stderr, gettext( 1976 "tar: %s: file name too long\n"), longname); 1977 if (errflag) 1978 exitflag = 1; 1979 Errflg = 1; 1980 goto out; 1981 } 1982 1983 /* 1984 * We split the fullname into prefix and name components if any one 1985 * of three conditions holds: 1986 * -- the length of the fullname exceeds NAMSIZ, 1987 * -- the length of the fullname equals NAMSIZ, and the shortname 1988 * is less than NAMSIZ, (splitting in this case preserves 1989 * compatibility with 5.6 and 5.5.1 tar), or 1990 * -- the length of the fullname equals NAMSIZ, the file is a 1991 * directory and we are not in POSIX-conformant mode (where 1992 * trailing slashes are removed from directories). 1993 */ 1994 if ((split > NAMSIZ) || 1995 (split == NAMSIZ && strlen(shortname) < NAMSIZ) || 1996 (split == NAMSIZ && S_ISDIR(stbuf.st_mode) && !Pflag)) { 1997 /* 1998 * Since path is limited to PRESIZ characters, look for the 1999 * last slash within PRESIZ + 1 characters only. 2000 */ 2001 (void) strncpy(&goodbuf[0], longname, min(split, PRESIZ + 1)); 2002 tmpbuf = goodbuf; 2003 lastslash = strrchr(tmpbuf, '/'); 2004 if (lastslash == NULL) { 2005 i = split; /* Length of name */ 2006 j = 0; /* Length of prefix */ 2007 goodbuf[0] = '\0'; 2008 } else { 2009 *lastslash = '\0'; /* Terminate the prefix */ 2010 j = strlen(tmpbuf); 2011 i = split - j - 1; 2012 } 2013 /* 2014 * If the filename is greater than NAMSIZ we can't 2015 * archive the file unless we are using extended headers. 2016 */ 2017 if ((i > NAMSIZ) || (i == NAMSIZ && S_ISDIR(stbuf.st_mode) && 2018 !Pflag)) { 2019 /* Determine which (filename or path) is too long. */ 2020 lastslash = strrchr(longname, '/'); 2021 if (lastslash != NULL) 2022 i = strlen(lastslash + 1); 2023 if (Eflag > 0) { 2024 xhdr_flgs |= _X_PATH; 2025 Xtarhdr.x_path = longname; 2026 if (i <= NAMSIZ) 2027 (void) strcpy(junkbuf, lastslash + 1); 2028 else 2029 (void) sprintf(junkbuf, "%llu", 2030 xhdr_count + 1); 2031 if (split - i - 1 > PRESIZ) 2032 (void) strcpy(goodbuf, xhdr_dirname); 2033 } else { 2034 if ((i > NAMSIZ) || (i == NAMSIZ && 2035 S_ISDIR(stbuf.st_mode) && !Pflag)) 2036 (void) fprintf(stderr, gettext( 2037 "tar: %s: filename is greater than " 2038 "%d\n"), lastslash == NULL ? 2039 longname : lastslash + 1, NAMSIZ); 2040 else 2041 (void) fprintf(stderr, gettext( 2042 "tar: %s: prefix is greater than %d" 2043 "\n"), longname, PRESIZ); 2044 if (errflag) 2045 exitflag = 1; 2046 Errflg = 1; 2047 goto out; 2048 } 2049 } else 2050 (void) strncpy(&junkbuf[0], longname + j + 1, 2051 strlen(longname + j + 1)); 2052 name = junkbuf; 2053 prefix = goodbuf; 2054 } else { 2055 name = longname; 2056 } 2057 if (Aflag) { 2058 if ((prefix != NULL) && (*prefix != '\0')) 2059 while (*prefix == '/') 2060 ++prefix; 2061 else 2062 while (*name == '/') 2063 ++name; 2064 } 2065 2066 switch (stbuf.st_mode & S_IFMT) { 2067 case S_IFDIR: 2068 stbuf.st_size = (off_t)0; 2069 blocks = TBLOCKS(stbuf.st_size); 2070 2071 if (filetype != XATTR_FILE && Hiddendir == 0) { 2072 i = 0; 2073 cp = buf; 2074 while ((*cp++ = longname[i++])) 2075 ; 2076 *--cp = '/'; 2077 *++cp = 0; 2078 } 2079 if (!oflag) { 2080 tomodes(&stbuf); 2081 if (build_dblock(name, tchar, '5', filetype, 2082 &stbuf, stbuf.st_dev, prefix) != 0) { 2083 goto out; 2084 } 2085 if (!Pflag) { 2086 /* 2087 * Old archives require a slash at the end 2088 * of a directory name. 2089 * 2090 * XXX 2091 * If directory name is too long, will 2092 * slash overfill field? 2093 */ 2094 if (strlen(name) > (unsigned)NAMSIZ-1) { 2095 (void) fprintf(stderr, gettext( 2096 "tar: %s: filename is greater " 2097 "than %d\n"), name, NAMSIZ); 2098 if (errflag) 2099 exitflag = 1; 2100 Errflg = 1; 2101 goto out; 2102 } else { 2103 if (strlen(name) == (NAMSIZ - 1)) { 2104 (void) memcpy(dblock.dbuf.name, 2105 name, NAMSIZ); 2106 dblock.dbuf.name[NAMSIZ-1] 2107 = '/'; 2108 } else 2109 (void) sprintf(dblock.dbuf.name, 2110 "%s/", name); 2111 2112 /* 2113 * need to recalculate checksum 2114 * because the name changed. 2115 */ 2116 (void) sprintf(dblock.dbuf.chksum, 2117 "%07o", checksum(&dblock)); 2118 } 2119 } 2120 2121 if (put_extra_attributes(longname, shortname, 2122 longattrname, prefix, filetype, '5') != 0) 2123 goto out; 2124 2125 #if defined(O_XATTR) 2126 /* 2127 * Reset header typeflag when archiving directory, since 2128 * build_dblock changed it on us. 2129 */ 2130 if (filetype == XATTR_FILE) { 2131 dblock.dbuf.typeflag = _XATTR_HDRTYPE; 2132 } else { 2133 dblock.dbuf.typeflag = '5'; 2134 } 2135 #else 2136 dblock.dbuf.typeflag = '5'; 2137 #endif 2138 2139 (void) sprintf(dblock.dbuf.chksum, "%07o", 2140 checksum(&dblock)); 2141 2142 (void) writetbuf((char *)&dblock, 1); 2143 } 2144 if (vflag) { 2145 if (NotTape) { 2146 dlog("seek = %" FMT_blkcnt_t "K\n", K(tapepos)); 2147 } 2148 if (filetype == XATTR_FILE && Hiddendir) { 2149 (void) fprintf(vfile, 2150 gettext("a %s attribute %s "), 2151 longname, longattrname); 2152 2153 } else { 2154 (void) fprintf(vfile, "a %s/ ", longname); 2155 } 2156 if (NotTape) { 2157 (void) fprintf(vfile, "%" FMT_blkcnt_t "K\n", 2158 K(blocks)); 2159 } else { 2160 (void) fprintf(vfile, gettext("%" FMT_blkcnt_t 2161 " tape blocks\n"), blocks); 2162 } 2163 } 2164 2165 /* 2166 * If hidden dir then break now since xattrs_put() will do 2167 * the iterating of the directory. 2168 * 2169 * At the moment, there can only be system attributes on 2170 * attributes. There can be no attributes on attributes or 2171 * directories within the attributes hidden directory hierarchy. 2172 */ 2173 if (filetype == XATTR_FILE) 2174 break; 2175 2176 if (*shortname != '/') 2177 (void) sprintf(newparent, "%s/%s", parent, shortname); 2178 else 2179 (void) sprintf(newparent, "%s", shortname); 2180 2181 if (tar_chdir(shortname) < 0) { 2182 vperror(0, "%s", newparent); 2183 goto out; 2184 } 2185 2186 if ((dirp = opendir(".")) == NULL) { 2187 vperror(0, gettext( 2188 "can't open directory %s"), longname); 2189 if (tar_chdir(parent) < 0) 2190 vperror(0, gettext("cannot change back?: %s"), 2191 parent); 2192 goto out; 2193 } 2194 2195 /* 2196 * Create a list of files (children) in this directory to avoid 2197 * having to perform telldir()/seekdir(). 2198 */ 2199 while ((dp = readdir(dirp)) != NULL && !term) { 2200 if ((strcmp(".", dp->d_name) == 0) || 2201 (strcmp("..", dp->d_name) == 0)) 2202 continue; 2203 if (((cptr = (file_list_t *)calloc(sizeof (char), 2204 sizeof (file_list_t))) == NULL) || 2205 ((cptr->name = strdup(dp->d_name)) == NULL)) { 2206 vperror(1, gettext( 2207 "Insufficient memory for directory " 2208 "list entry %s/%s\n"), 2209 newparent, dp->d_name); 2210 } 2211 2212 /* Add the file to the list */ 2213 if (child == NULL) { 2214 child = cptr; 2215 } else { 2216 child_end->next = cptr; 2217 } 2218 child_end = cptr; 2219 } 2220 (void) closedir(dirp); 2221 2222 /* 2223 * Archive each of the files in the current directory. 2224 * If a file is a directory, putfile() is called 2225 * recursively to archive the file hierarchy of the 2226 * directory before archiving the next file in the 2227 * current directory. 2228 */ 2229 while ((child != NULL) && !term) { 2230 (void) strcpy(cp, child->name); 2231 archtype = putfile(buf, cp, newparent, NULL, 2232 NORMAL_FILE, lev + 1, symlink_lev); 2233 2234 if (!exitflag) { 2235 if ((atflag || saflag) && 2236 (archtype == PUT_NOTAS_LINK)) { 2237 xattrs_put(buf, cp, newparent, NULL); 2238 } 2239 } 2240 if (exitflag) 2241 break; 2242 2243 /* Free each child as we are done processing it. */ 2244 cptr = child; 2245 child = child->next; 2246 free(cptr->name); 2247 free(cptr); 2248 } 2249 if ((child != NULL) && !term) { 2250 free_children(child); 2251 } 2252 2253 if (tar_chdir(parent) < 0) { 2254 vperror(0, gettext("cannot change back?: %s"), parent); 2255 } 2256 2257 break; 2258 2259 case S_IFLNK: 2260 readlink_max = NAMSIZ; 2261 if (stbuf.st_size > NAMSIZ) { 2262 if (Eflag > 0) { 2263 xhdr_flgs |= _X_LINKPATH; 2264 readlink_max = PATH_MAX; 2265 } else { 2266 (void) fprintf(stderr, gettext( 2267 "tar: %s: symbolic link too long\n"), 2268 longname); 2269 if (errflag) 2270 exitflag = 1; 2271 Errflg = 1; 2272 goto out; 2273 } 2274 } 2275 /* 2276 * Sym-links need header size of zero since you 2277 * don't store any data for this type. 2278 */ 2279 stbuf.st_size = (off_t)0; 2280 tomodes(&stbuf); 2281 i = readlink(shortname, filetmp, readlink_max); 2282 if (i < 0) { 2283 vperror(0, gettext( 2284 "can't read symbolic link %s"), longname); 2285 goto out; 2286 } else { 2287 filetmp[i] = 0; 2288 } 2289 if (vflag) 2290 (void) fprintf(vfile, gettext( 2291 "a %s symbolic link to %s\n"), 2292 longname, filetmp); 2293 if (xhdr_flgs & _X_LINKPATH) { 2294 Xtarhdr.x_linkpath = filetmp; 2295 if (build_dblock(name, tchar, '2', filetype, &stbuf, 2296 stbuf.st_dev, prefix) != 0) 2297 goto out; 2298 } else 2299 if (build_dblock(name, filetmp, '2', filetype, &stbuf, 2300 stbuf.st_dev, prefix) != 0) 2301 goto out; 2302 (void) writetbuf((char *)&dblock, 1); 2303 /* 2304 * No acls for symlinks: mode is always 777 2305 * dont call write ancillary 2306 */ 2307 rc = PUT_AS_LINK; 2308 break; 2309 case S_IFREG: 2310 if ((infile = openat(dirfd, shortname, 0)) < 0) { 2311 vperror(0, gettext("unable to open %s%s%s%s"), longname, 2312 rw_sysattr ? gettext(" system") : "", 2313 (filetype == XATTR_FILE) ? 2314 gettext(" attribute ") : "", 2315 (filetype == XATTR_FILE) ? (longattrname == NULL) ? 2316 shortname : longattrname : ""); 2317 goto out; 2318 } 2319 2320 blocks = TBLOCKS(stbuf.st_size); 2321 2322 if (put_link(name, longname, shortname, longattrname, 2323 prefix, filetype, '1') == 0) { 2324 (void) close(infile); 2325 rc = PUT_AS_LINK; 2326 goto out; 2327 } 2328 2329 tomodes(&stbuf); 2330 2331 /* correctly handle end of volume */ 2332 while (mulvol && tapepos + blocks + 1 > blocklim) { 2333 /* split if floppy has some room and file is large */ 2334 if (((blocklim - tapepos) >= EXTMIN) && 2335 ((blocks + 1) >= blocklim/10)) { 2336 splitfile(longname, infile, 2337 name, prefix, filetype); 2338 (void) close(dirfd); 2339 (void) close(infile); 2340 goto out; 2341 } 2342 newvol(); /* not worth it--just get new volume */ 2343 } 2344 dlog("putfile: %s wants %" FMT_blkcnt_t " blocks\n", longname, 2345 blocks); 2346 if (build_dblock(name, tchar, '0', filetype, 2347 &stbuf, stbuf.st_dev, prefix) != 0) { 2348 goto out; 2349 } 2350 if (vflag) { 2351 if (NotTape) { 2352 dlog("seek = %" FMT_blkcnt_t "K\n", K(tapepos)); 2353 } 2354 (void) fprintf(vfile, "a %s%s%s%s ", longname, 2355 rw_sysattr ? gettext(" system") : "", 2356 (filetype == XATTR_FILE) ? gettext( 2357 " attribute ") : "", 2358 (filetype == XATTR_FILE) ? 2359 longattrname : ""); 2360 if (NotTape) 2361 (void) fprintf(vfile, "%" FMT_blkcnt_t "K\n", 2362 K(blocks)); 2363 else 2364 (void) fprintf(vfile, 2365 gettext("%" FMT_blkcnt_t " tape blocks\n"), 2366 blocks); 2367 } 2368 2369 if (put_extra_attributes(longname, shortname, longattrname, 2370 prefix, filetype, '0') != 0) 2371 goto out; 2372 2373 /* 2374 * No need to reset typeflag for extended attribute here, since 2375 * put_extra_attributes already set it and we haven't called 2376 * build_dblock(). 2377 */ 2378 (void) sprintf(dblock.dbuf.chksum, "%07o", checksum(&dblock)); 2379 hint = writetbuf((char *)&dblock, 1); 2380 maxread = max(min(stbuf.st_blksize, stbuf.st_size), 2381 (nblock * TBLOCK)); 2382 if ((bigbuf = calloc((unsigned)maxread, sizeof (char))) == 0) { 2383 maxread = TBLOCK; 2384 bigbuf = buf; 2385 } 2386 2387 while (((i = (int) 2388 read(infile, bigbuf, min((hint*TBLOCK), maxread))) > 0) && 2389 blocks) { 2390 blkcnt_t nblks; 2391 2392 nblks = ((i-1)/TBLOCK)+1; 2393 if (nblks > blocks) 2394 nblks = blocks; 2395 hint = writetbuf(bigbuf, nblks); 2396 blocks -= nblks; 2397 } 2398 (void) close(infile); 2399 if (bigbuf != buf) 2400 free(bigbuf); 2401 if (i < 0) 2402 vperror(0, gettext("Read error on %s"), longname); 2403 else if (blocks != 0 || i != 0) { 2404 (void) fprintf(stderr, gettext( 2405 "tar: %s: file changed size\n"), longname); 2406 if (errflag) { 2407 exitflag = 1; 2408 Errflg = 1; 2409 } else if (!Dflag) { 2410 Errflg = 1; 2411 } 2412 } 2413 putempty(blocks); 2414 break; 2415 case S_IFIFO: 2416 blocks = TBLOCKS(stbuf.st_size); 2417 stbuf.st_size = (off_t)0; 2418 2419 if (put_link(name, longname, shortname, longattrname, 2420 prefix, filetype, '6') == 0) { 2421 rc = PUT_AS_LINK; 2422 goto out; 2423 } 2424 tomodes(&stbuf); 2425 2426 while (mulvol && tapepos + blocks + 1 > blocklim) { 2427 if (((blocklim - tapepos) >= EXTMIN) && 2428 ((blocks + 1) >= blocklim/10)) { 2429 splitfile(longname, infile, name, 2430 prefix, filetype); 2431 (void) close(dirfd); 2432 (void) close(infile); 2433 goto out; 2434 } 2435 newvol(); 2436 } 2437 dlog("putfile: %s wants %" FMT_blkcnt_t " blocks\n", longname, 2438 blocks); 2439 if (vflag) { 2440 if (NotTape) { 2441 dlog("seek = %" FMT_blkcnt_t "K\n", K(tapepos)); 2442 2443 (void) fprintf(vfile, gettext("a %s %" 2444 FMT_blkcnt_t "K\n "), longname, K(blocks)); 2445 } else { 2446 (void) fprintf(vfile, gettext( 2447 "a %s %" FMT_blkcnt_t " tape blocks\n"), 2448 longname, blocks); 2449 } 2450 } 2451 if (build_dblock(name, tchar, '6', filetype, 2452 &stbuf, stbuf.st_dev, prefix) != 0) 2453 goto out; 2454 2455 if (put_extra_attributes(longname, shortname, longattrname, 2456 prefix, filetype, '6') != 0) 2457 goto out; 2458 2459 (void) sprintf(dblock.dbuf.chksum, "%07o", checksum(&dblock)); 2460 dblock.dbuf.typeflag = '6'; 2461 2462 (void) writetbuf((char *)&dblock, 1); 2463 break; 2464 case S_IFCHR: 2465 stbuf.st_size = (off_t)0; 2466 blocks = TBLOCKS(stbuf.st_size); 2467 if (put_link(name, longname, shortname, longattrname, 2468 prefix, filetype, '3') == 0) { 2469 rc = PUT_AS_LINK; 2470 goto out; 2471 } 2472 tomodes(&stbuf); 2473 2474 while (mulvol && tapepos + blocks + 1 > blocklim) { 2475 if (((blocklim - tapepos) >= EXTMIN) && 2476 ((blocks + 1) >= blocklim/10)) { 2477 splitfile(longname, infile, name, 2478 prefix, filetype); 2479 (void) close(dirfd); 2480 goto out; 2481 } 2482 newvol(); 2483 } 2484 dlog("putfile: %s wants %" FMT_blkcnt_t " blocks\n", longname, 2485 blocks); 2486 if (vflag) { 2487 if (NotTape) { 2488 dlog("seek = %" FMT_blkcnt_t "K\t", K(tapepos)); 2489 2490 (void) fprintf(vfile, gettext("a %s %" 2491 FMT_blkcnt_t "K\n"), longname, K(blocks)); 2492 } else { 2493 (void) fprintf(vfile, gettext("a %s %" 2494 FMT_blkcnt_t " tape blocks\n"), longname, 2495 blocks); 2496 } 2497 } 2498 if (build_dblock(name, tchar, '3', 2499 filetype, &stbuf, stbuf.st_rdev, prefix) != 0) 2500 goto out; 2501 2502 if (put_extra_attributes(longname, shortname, longattrname, 2503 prefix, filetype, '3') != 0) 2504 goto out; 2505 2506 (void) sprintf(dblock.dbuf.chksum, "%07o", checksum(&dblock)); 2507 dblock.dbuf.typeflag = '3'; 2508 2509 (void) writetbuf((char *)&dblock, 1); 2510 break; 2511 case S_IFBLK: 2512 stbuf.st_size = (off_t)0; 2513 blocks = TBLOCKS(stbuf.st_size); 2514 if (put_link(name, longname, shortname, longattrname, 2515 prefix, filetype, '4') == 0) { 2516 rc = PUT_AS_LINK; 2517 goto out; 2518 } 2519 tomodes(&stbuf); 2520 2521 while (mulvol && tapepos + blocks + 1 > blocklim) { 2522 if (((blocklim - tapepos) >= EXTMIN) && 2523 ((blocks + 1) >= blocklim/10)) { 2524 splitfile(longname, infile, 2525 name, prefix, filetype); 2526 (void) close(dirfd); 2527 goto out; 2528 } 2529 newvol(); 2530 } 2531 dlog("putfile: %s wants %" FMT_blkcnt_t " blocks\n", longname, 2532 blocks); 2533 if (vflag) { 2534 if (NotTape) { 2535 dlog("seek = %" FMT_blkcnt_t "K\n", K(tapepos)); 2536 } 2537 2538 (void) fprintf(vfile, "a %s ", longname); 2539 if (NotTape) 2540 (void) fprintf(vfile, "%" FMT_blkcnt_t "K\n", 2541 K(blocks)); 2542 else 2543 (void) fprintf(vfile, gettext("%" 2544 FMT_blkcnt_t " tape blocks\n"), blocks); 2545 } 2546 if (build_dblock(name, tchar, '4', 2547 filetype, &stbuf, stbuf.st_rdev, prefix) != 0) 2548 goto out; 2549 2550 if (put_extra_attributes(longname, shortname, longattrname, 2551 prefix, filetype, '4') != 0) 2552 goto out; 2553 2554 (void) sprintf(dblock.dbuf.chksum, "%07o", checksum(&dblock)); 2555 dblock.dbuf.typeflag = '4'; 2556 2557 (void) writetbuf((char *)&dblock, 1); 2558 break; 2559 default: 2560 (void) fprintf(stderr, gettext( 2561 "tar: %s is not a file. Not dumped\n"), longname); 2562 if (errflag) 2563 exitflag = 1; 2564 Errflg = 1; 2565 goto out; 2566 } 2567 2568 out: 2569 if ((dirfd != -1) && (filetype != XATTR_FILE)) { 2570 (void) close(dirfd); 2571 } 2572 return (rc); 2573 } 2574 2575 2576 /* 2577 * splitfile dump a large file across volumes 2578 * 2579 * splitfile(longname, fd); 2580 * char *longname; full name of file 2581 * int ifd; input file descriptor 2582 * 2583 * NOTE: only called by putfile() to dump a large file. 2584 */ 2585 2586 static void 2587 splitfile(char *longname, int ifd, char *name, char *prefix, int filetype) 2588 { 2589 blkcnt_t blocks; 2590 off_t bytes, s; 2591 char buf[TBLOCK]; 2592 int i, extents; 2593 2594 blocks = TBLOCKS(stbuf.st_size); /* blocks file needs */ 2595 2596 /* 2597 * # extents = 2598 * size of file after using up rest of this floppy 2599 * blocks - (blocklim - tapepos) + 1 (for header) 2600 * plus roundup value before divide by blocklim-1 2601 * + (blocklim - 1) - 1 2602 * all divided by blocklim-1 (one block for each header). 2603 * this gives 2604 * (blocks - blocklim + tapepos + 1 + blocklim - 2)/(blocklim-1) 2605 * which reduces to the expression used. 2606 * one is added to account for this first extent. 2607 * 2608 * When one is dealing with extremely large archives, one may want 2609 * to allow for a large number of extents. This code should be 2610 * revisited to determine if extents should be changed to something 2611 * larger than an int. 2612 */ 2613 extents = (int)((blocks + tapepos - 1ULL)/(blocklim - 1ULL) + 1); 2614 2615 if (extents < 2 || extents > MAXEXT) { /* let's be reasonable */ 2616 (void) fprintf(stderr, gettext( 2617 "tar: %s needs unusual number of volumes to split\n" 2618 "tar: %s not dumped\n"), longname, longname); 2619 return; 2620 } 2621 if (build_dblock(name, tchar, '0', filetype, 2622 &stbuf, stbuf.st_dev, prefix) != 0) 2623 return; 2624 2625 dblock.dbuf.extotal = extents; 2626 bytes = stbuf.st_size; 2627 2628 /* 2629 * The value contained in dblock.dbuf.efsize was formerly used when the 2630 * v flag was specified in conjunction with the t flag. Although it is 2631 * no longer used, older versions of tar will expect the former 2632 * behaviour, so we must continue to write it to the archive. 2633 * 2634 * Since dblock.dbuf.efsize is 10 chars in size, the maximum value it 2635 * can store is TAR_EFSIZE_MAX. If bytes exceeds that value, simply 2636 * store 0. 2637 */ 2638 if (bytes <= TAR_EFSIZE_MAX) 2639 (void) sprintf(dblock.dbuf.efsize, "%9" FMT_off_t_o, bytes); 2640 else 2641 (void) sprintf(dblock.dbuf.efsize, "%9" FMT_off_t_o, (off_t)0); 2642 2643 (void) fprintf(stderr, gettext( 2644 "tar: large file %s needs %d extents.\n" 2645 "tar: current device seek position = %" FMT_blkcnt_t "K\n"), 2646 longname, extents, K(tapepos)); 2647 2648 s = (off_t)(blocklim - tapepos - 1) * TBLOCK; 2649 for (i = 1; i <= extents; i++) { 2650 if (i > 1) { 2651 newvol(); 2652 if (i == extents) 2653 s = bytes; /* last ext. gets true bytes */ 2654 else 2655 s = (off_t)(blocklim - 1)*TBLOCK; /* all */ 2656 } 2657 bytes -= s; 2658 blocks = TBLOCKS(s); 2659 2660 (void) sprintf(dblock.dbuf.size, "%011" FMT_off_t_o, s); 2661 dblock.dbuf.extno = i; 2662 (void) sprintf(dblock.dbuf.chksum, "%07o", checksum(&dblock)); 2663 (void) writetbuf((char *)&dblock, 1); 2664 2665 if (vflag) 2666 (void) fprintf(vfile, 2667 gettext("+++ a %s %" FMT_blkcnt_t 2668 "K [extent #%d of %d]\n"), 2669 longname, K(blocks), i, extents); 2670 while (blocks && read(ifd, buf, TBLOCK) > 0) { 2671 blocks--; 2672 (void) writetbuf(buf, 1); 2673 } 2674 if (blocks != 0) { 2675 (void) fprintf(stderr, gettext( 2676 "tar: %s: file changed size\n"), longname); 2677 (void) fprintf(stderr, gettext( 2678 "tar: aborting split file %s\n"), longname); 2679 (void) close(ifd); 2680 return; 2681 } 2682 } 2683 (void) close(ifd); 2684 if (vflag) 2685 (void) fprintf(vfile, gettext("a %s %" FMT_off_t "K (in %d " 2686 "extents)\n"), longname, K(TBLOCKS(stbuf.st_size)), 2687 extents); 2688 } 2689 2690 /* 2691 * convtoreg - determines whether the file should be converted to a 2692 * regular file when extracted 2693 * 2694 * Returns 1 when file size > 0 and typeflag is not recognized 2695 * Otherwise returns 0 2696 */ 2697 static int 2698 convtoreg(off_t size) 2699 { 2700 if ((size > 0) && (dblock.dbuf.typeflag != '0') && 2701 (dblock.dbuf.typeflag != NULL) && (dblock.dbuf.typeflag != '1') && 2702 (dblock.dbuf.typeflag != '2') && (dblock.dbuf.typeflag != '3') && 2703 (dblock.dbuf.typeflag != '4') && (dblock.dbuf.typeflag != '5') && 2704 (dblock.dbuf.typeflag != '6') && (dblock.dbuf.typeflag != 'A') && 2705 (dblock.dbuf.typeflag != 'L') && 2706 (dblock.dbuf.typeflag != _XATTR_HDRTYPE) && 2707 (dblock.dbuf.typeflag != 'X')) { 2708 return (1); 2709 } 2710 return (0); 2711 } 2712 2713 #if defined(O_XATTR) 2714 static int 2715 save_cwd(void) 2716 { 2717 return (open(".", O_RDONLY)); 2718 } 2719 #endif 2720 2721 #if defined(O_XATTR) 2722 static void 2723 rest_cwd(int *cwd) 2724 { 2725 if (*cwd != -1) { 2726 if (fchdir(*cwd) < 0) { 2727 vperror(0, gettext( 2728 "Cannot fchdir to attribute directory")); 2729 exit(1); 2730 } 2731 (void) close(*cwd); 2732 *cwd = -1; 2733 } 2734 } 2735 #endif 2736 2737 /* 2738 * Verify the underlying file system supports the attribute type. 2739 * Only archive extended attribute files when '-@' was specified. 2740 * Only archive system extended attribute files if '-/' was specified. 2741 */ 2742 #if defined(O_XATTR) 2743 static attr_status_t 2744 verify_attr_support(char *filename, int attrflg, arc_action_t actflag, 2745 int *ext_attrflg) 2746 { 2747 /* 2748 * Verify extended attributes are supported/exist. We only 2749 * need to check if we are processing a base file, not an 2750 * extended attribute. 2751 */ 2752 if (attrflg) { 2753 *ext_attrflg = (pathconf(filename, (actflag == ARC_CREATE) ? 2754 _PC_XATTR_EXISTS : _PC_XATTR_ENABLED) == 1); 2755 } 2756 2757 if (atflag) { 2758 if (!*ext_attrflg) { 2759 #if defined(_PC_SATTR_ENABLED) 2760 if (saflag) { 2761 /* Verify system attributes are supported */ 2762 if (sysattr_support(filename, 2763 (actflag == ARC_CREATE) ? _PC_SATTR_EXISTS : 2764 _PC_SATTR_ENABLED) != 1) { 2765 return (ATTR_SATTR_ERR); 2766 } 2767 } else 2768 return (ATTR_XATTR_ERR); 2769 #else 2770 return (ATTR_XATTR_ERR); 2771 #endif /* _PC_SATTR_ENABLED */ 2772 } 2773 2774 #if defined(_PC_SATTR_ENABLED) 2775 } else if (saflag) { 2776 /* Verify system attributes are supported */ 2777 if (sysattr_support(filename, (actflag == ARC_CREATE) ? 2778 _PC_SATTR_EXISTS : _PC_SATTR_ENABLED) != 1) { 2779 return (ATTR_SATTR_ERR); 2780 } 2781 #endif /* _PC_SATTR_ENABLED */ 2782 } else { 2783 return (ATTR_SKIP); 2784 } 2785 2786 return (ATTR_OK); 2787 } 2788 #endif 2789 2790 #if defined(O_XATTR) 2791 /* 2792 * Recursively open attribute directories until the attribute directory 2793 * containing the specified attribute, attrname, is opened. 2794 * 2795 * Currently, only 2 directory levels of attributes are supported, (i.e., 2796 * extended system attributes on extended attributes). The following are 2797 * the possible input combinations: 2798 * 1. Open the attribute directory of the base file (don't change 2799 * into it). 2800 * attrinfo->parent = NULL 2801 * attrname = '.' 2802 * 2. Open the attribute directory of the base file and change into it. 2803 * attrinfo->parent = NULL 2804 * attrname = <attr> | <sys_attr> 2805 * 3. Open the attribute directory of the base file, change into it, 2806 * then recursively call open_attr_dir() to open the attribute's 2807 * parent directory (don't change into it). 2808 * attrinfo->parent = <attr> 2809 * attrname = '.' 2810 * 4. Open the attribute directory of the base file, change into it, 2811 * then recursively call open_attr_dir() to open the attribute's 2812 * parent directory and change into it. 2813 * attrinfo->parent = <attr> 2814 * attrname = <attr> | <sys_attr> 2815 * 2816 * An attribute directory will be opened only if the underlying file system 2817 * supports the attribute type, and if the command line specifications (atflag 2818 * and saflag) enable the processing of the attribute type. 2819 * 2820 * On succesful return, attrinfo->parentfd will be the file descriptor of the 2821 * opened attribute directory. In addition, if the attribute is a read-write 2822 * extended system attribute, attrinfo->rw_sysattr will be set to 1, otherwise 2823 * it will be set to 0. 2824 * 2825 * Possible return values: 2826 * ATTR_OK Successfully opened and, if needed, changed into the 2827 * attribute directory containing attrname. 2828 * ATTR_SKIP The command line specifications don't enable the 2829 * processing of the attribute type. 2830 * ATTR_CHDIR_ERR An error occurred while trying to change into an 2831 * attribute directory. 2832 * ATTR_OPEN_ERR An error occurred while trying to open an 2833 * attribute directory. 2834 * ATTR_XATTR_ERR The underlying file system doesn't support extended 2835 * attributes. 2836 * ATTR_SATTR_ERR The underlying file system doesn't support extended 2837 * system attributes. 2838 */ 2839 static int 2840 open_attr_dir(char *attrname, char *dirp, int cwd, attr_data_t *attrinfo) 2841 { 2842 attr_status_t rc; 2843 int firsttime = (attrinfo->attr_parentfd == -1); 2844 int saveerrno; 2845 int ext_attr; 2846 2847 /* 2848 * open_attr_dir() was recursively called (input combination number 4), 2849 * close the previously opened file descriptor as we've already changed 2850 * into it. 2851 */ 2852 if (!firsttime) { 2853 (void) close(attrinfo->attr_parentfd); 2854 attrinfo->attr_parentfd = -1; 2855 } 2856 2857 /* 2858 * Verify that the underlying file system supports the restoration 2859 * of the attribute. 2860 */ 2861 if ((rc = verify_attr_support(dirp, firsttime, ARC_RESTORE, 2862 &ext_attr)) != ATTR_OK) { 2863 return (rc); 2864 } 2865 2866 /* Open the base file's attribute directory */ 2867 if ((attrinfo->attr_parentfd = attropen(dirp, ".", O_RDONLY)) == -1) { 2868 /* 2869 * Save the errno from the attropen so it can be reported 2870 * if the retry of the attropen fails. 2871 */ 2872 saveerrno = errno; 2873 if ((attrinfo->attr_parentfd = retry_open_attr(-1, cwd, dirp, 2874 NULL, ".", O_RDONLY, 0)) == -1) { 2875 /* 2876 * Reset typeflag back to real value so passtape 2877 * will skip ahead correctly. 2878 */ 2879 dblock.dbuf.typeflag = _XATTR_HDRTYPE; 2880 (void) close(attrinfo->attr_parentfd); 2881 attrinfo->attr_parentfd = -1; 2882 errno = saveerrno; 2883 return (ATTR_OPEN_ERR); 2884 } 2885 } 2886 2887 /* 2888 * Change into the parent attribute's directory unless we are 2889 * processing the hidden attribute directory of the base file itself. 2890 */ 2891 if ((Hiddendir == 0) || (firsttime && attrinfo->attr_parent != NULL)) { 2892 if (fchdir(attrinfo->attr_parentfd) != 0) { 2893 saveerrno = errno; 2894 (void) close(attrinfo->attr_parentfd); 2895 attrinfo->attr_parentfd = -1; 2896 errno = saveerrno; 2897 return (ATTR_CHDIR_ERR); 2898 } 2899 } 2900 2901 /* Determine if the attribute should be processed */ 2902 if ((rc = verify_attr(attrname, attrinfo->attr_parent, 1, 2903 &attrinfo->attr_rw_sysattr)) != ATTR_OK) { 2904 saveerrno = errno; 2905 (void) close(attrinfo->attr_parentfd); 2906 attrinfo->attr_parentfd = -1; 2907 errno = saveerrno; 2908 return (rc); 2909 } 2910 2911 /* 2912 * If the attribute is an extended attribute, or extended system 2913 * attribute, of an attribute (i.e., <attr>/<sys_attr>), then 2914 * recursively call open_attr_dir() to open the attribute directory 2915 * of the parent attribute. 2916 */ 2917 if (firsttime && (attrinfo->attr_parent != NULL)) { 2918 return (open_attr_dir(attrname, attrinfo->attr_parent, 2919 attrinfo->attr_parentfd, attrinfo)); 2920 } 2921 2922 return (ATTR_OK); 2923 } 2924 #endif 2925 2926 static void 2927 doxtract(char *argv[]) 2928 { 2929 struct stat xtractbuf; /* stat on file after extracting */ 2930 blkcnt_t blocks; 2931 off_t bytes; 2932 int ofile; 2933 int newfile; /* Does the file already exist */ 2934 int xcnt = 0; /* count # files extracted */ 2935 int fcnt = 0; /* count # files in argv list */ 2936 int dir; 2937 int dirfd = -1; 2938 int cwd = -1; 2939 int rw_sysattr; 2940 int saveerrno; 2941 uid_t Uid; 2942 char *namep, *dirp, *comp, *linkp; /* for removing absolute paths */ 2943 char dirname[PATH_MAX+1]; 2944 char templink[PATH_MAX+1]; /* temp link with terminating NULL */ 2945 int once = 1; 2946 int error; 2947 int symflag; 2948 int want; 2949 attr_data_t *attrinfo = NULL; /* attribute info */ 2950 acl_t *aclp = NULL; /* acl info */ 2951 char dot[] = "."; /* dirp for using realpath */ 2952 timestruc_t time_zero; /* used for call to doDirTimes */ 2953 int dircreate; 2954 int convflag; 2955 time_zero.tv_sec = 0; 2956 time_zero.tv_nsec = 0; 2957 2958 /* reset Trusted Extensions variables */ 2959 rpath_flag = 0; 2960 lk_rpath_flag = 0; 2961 dir_flag = 0; 2962 mld_flag = 0; 2963 bslundef(&bs_label); 2964 bsllow(&admin_low); 2965 bslhigh(&admin_high); 2966 orig_namep = 0; 2967 2968 dumping = 0; /* for newvol(), et al: we are not writing */ 2969 2970 Uid = getuid(); 2971 2972 for (;;) { 2973 convflag = 0; 2974 symflag = 0; 2975 dir = 0; 2976 Hiddendir = 0; 2977 rw_sysattr = 0; 2978 ofile = -1; 2979 2980 if (dirfd != -1) { 2981 (void) close(dirfd); 2982 dirfd = -1; 2983 } 2984 if (ofile != -1) { 2985 if (close(ofile) != 0) 2986 vperror(2, gettext("close error")); 2987 } 2988 2989 #if defined(O_XATTR) 2990 if (cwd != -1) { 2991 rest_cwd(&cwd); 2992 } 2993 #endif 2994 2995 /* namep is set by wantit to point to the full name */ 2996 if ((want = wantit(argv, &namep, &dirp, &comp, 2997 &attrinfo)) == 0) { 2998 #if defined(O_XATTR) 2999 if (xattrp != NULL) { 3000 free(xattrhead); 3001 xattrp = NULL; 3002 xattr_linkp = NULL; 3003 xattrhead = NULL; 3004 } 3005 #endif 3006 continue; 3007 } 3008 if (want == -1) 3009 break; 3010 3011 /* Trusted Extensions */ 3012 /* 3013 * During tar extract (x): 3014 * If the pathname of the restored file has been 3015 * reconstructed from the ancillary file, 3016 * use it to process the normal file. 3017 */ 3018 if (mld_flag) { /* Skip over .MLD. directory */ 3019 mld_flag = 0; 3020 passtape(); 3021 continue; 3022 } 3023 orig_namep = namep; /* save original */ 3024 if (rpath_flag) { 3025 namep = real_path; /* use zone path */ 3026 comp = real_path; /* use zone path */ 3027 dirp = dot; /* work from the top */ 3028 rpath_flag = 0; /* reset */ 3029 } 3030 3031 if (dirfd != -1) 3032 (void) close(dirfd); 3033 3034 (void) strcpy(&dirname[0], namep); 3035 dircreate = checkdir(&dirname[0]); 3036 3037 #if defined(O_XATTR) 3038 if (xattrp != NULL) { 3039 int rc; 3040 3041 if (((cwd = save_cwd()) == -1) || 3042 ((rc = open_attr_dir(comp, dirp, cwd, 3043 attrinfo)) != ATTR_OK)) { 3044 if (cwd == -1) { 3045 vperror(0, gettext( 3046 "unable to save current working " 3047 "directory while processing " 3048 "attribute %s of %s"), 3049 dirp, attrinfo->attr_path); 3050 } else if (rc != ATTR_SKIP) { 3051 (void) fprintf(vfile, 3052 gettext("tar: cannot open " 3053 "%sattribute %s of file %s: %s\n"), 3054 attrinfo->attr_rw_sysattr ? gettext( 3055 "system ") : "", 3056 comp, dirp, strerror(errno)); 3057 } 3058 free(xattrhead); 3059 xattrp = NULL; 3060 xattr_linkp = NULL; 3061 xattrhead = NULL; 3062 3063 passtape(); 3064 continue; 3065 } else { 3066 dirfd = attrinfo->attr_parentfd; 3067 rw_sysattr = attrinfo->attr_rw_sysattr; 3068 } 3069 } else { 3070 dirfd = open(dirp, O_RDONLY); 3071 } 3072 #else 3073 dirfd = open(dirp, O_RDONLY); 3074 #endif 3075 if (dirfd == -1) { 3076 (void) fprintf(vfile, gettext( 3077 "tar: cannot open %s: %s\n"), 3078 dirp, strerror(errno)); 3079 passtape(); 3080 continue; 3081 } 3082 3083 if (xhdr_flgs & _X_LINKPATH) 3084 (void) strcpy(templink, Xtarhdr.x_linkpath); 3085 else { 3086 #if defined(O_XATTR) 3087 if (xattrp && dblock.dbuf.typeflag == '1') { 3088 (void) sprintf(templink, "%.*s", NAMSIZ, 3089 xattrp->h_names); 3090 } else { 3091 (void) sprintf(templink, "%.*s", NAMSIZ, 3092 dblock.dbuf.linkname); 3093 } 3094 #else 3095 (void) sprintf(templink, "%.*s", NAMSIZ, 3096 dblock.dbuf.linkname); 3097 #endif 3098 } 3099 3100 if (Fflag) { 3101 if (checkf(namep, is_directory(namep), Fflag) == 0) { 3102 passtape(); 3103 continue; 3104 } 3105 } 3106 3107 if (checkw('x', namep) == 0) { 3108 passtape(); 3109 continue; 3110 } 3111 if (once) { 3112 if (strcmp(dblock.dbuf.magic, magic_type) == 0) { 3113 if (geteuid() == (uid_t)0) { 3114 checkflag = 1; 3115 pflag = 1; 3116 } else { 3117 /* get file creation mask */ 3118 Oumask = umask(0); 3119 (void) umask(Oumask); 3120 } 3121 once = 0; 3122 } else { 3123 if (geteuid() == (uid_t)0) { 3124 pflag = 1; 3125 checkflag = 2; 3126 } 3127 if (!pflag) { 3128 /* get file creation mask */ 3129 Oumask = umask(0); 3130 (void) umask(Oumask); 3131 } 3132 once = 0; 3133 } 3134 } 3135 3136 #if defined(O_XATTR) 3137 /* 3138 * Handle extraction of hidden attr dir. 3139 * Dir is automatically created, we only 3140 * need to update mode and perm's. 3141 */ 3142 if ((xattrp != NULL) && Hiddendir == 1) { 3143 bytes = stbuf.st_size; 3144 blocks = TBLOCKS(bytes); 3145 if (vflag) { 3146 (void) fprintf(vfile, 3147 "x %s%s%s, %" FMT_off_t " %s, ", namep, 3148 gettext(" attribute "), 3149 xattrapath, bytes, 3150 gettext("bytes")); 3151 if (NotTape) 3152 (void) fprintf(vfile, 3153 "%" FMT_blkcnt_t "K\n", K(blocks)); 3154 else 3155 (void) fprintf(vfile, gettext("%" 3156 FMT_blkcnt_t " tape blocks\n"), 3157 blocks); 3158 } 3159 3160 /* 3161 * Set the permissions and mode of the attribute 3162 * unless the attribute is a system attribute (can't 3163 * successfully do this) or the hidden attribute 3164 * directory (".") of an attribute (when the attribute 3165 * is restored, the hidden attribute directory of an 3166 * attribute is transient). Note: when the permissions 3167 * and mode are set for the hidden attribute directory 3168 * of a file on a system supporting extended system 3169 * attributes, even though it returns successfully, it 3170 * will not have any affect since the attribute 3171 * directory is transient. 3172 */ 3173 if (attrinfo->attr_parent == NULL) { 3174 if (fchownat(dirfd, ".", stbuf.st_uid, 3175 stbuf.st_gid, 0) != 0) { 3176 vperror(0, gettext( 3177 "%s%s%s: failed to set ownership " 3178 "of attribute directory"), namep, 3179 gettext(" attribute "), xattrapath); 3180 } 3181 3182 if (fchmod(dirfd, stbuf.st_mode) != 0) { 3183 vperror(0, gettext( 3184 "%s%s%s: failed to set permissions " 3185 "of attribute directory"), namep, 3186 gettext(" attribute "), xattrapath); 3187 } 3188 } 3189 goto filedone; 3190 } 3191 #endif 3192 3193 if (dircreate && (!is_posix || dblock.dbuf.typeflag == '5')) { 3194 dir = 1; 3195 if (vflag) { 3196 (void) fprintf(vfile, "x %s, 0 %s, ", 3197 &dirname[0], gettext("bytes")); 3198 if (NotTape) 3199 (void) fprintf(vfile, "0K\n"); 3200 else 3201 (void) fprintf(vfile, gettext("%" 3202 FMT_blkcnt_t " tape blocks\n"), 3203 (blkcnt_t)0); 3204 } 3205 goto filedone; 3206 } 3207 3208 if (dblock.dbuf.typeflag == '6') { /* FIFO */ 3209 if (rmdir(namep) < 0) { 3210 if (errno == ENOTDIR) 3211 (void) unlink(namep); 3212 } 3213 linkp = templink; 3214 if (*linkp != NULL) { 3215 if (Aflag && *linkp == '/') 3216 linkp++; 3217 if (link(linkp, namep) < 0) { 3218 (void) fprintf(stderr, gettext( 3219 "tar: %s: cannot link\n"), namep); 3220 continue; 3221 } 3222 if (vflag) 3223 (void) fprintf(vfile, gettext( 3224 "x %s linked to %s\n"), namep, 3225 linkp); 3226 xcnt++; /* increment # files extracted */ 3227 continue; 3228 } 3229 if (mknod(namep, (int)(Gen.g_mode|S_IFIFO), 3230 (int)Gen.g_devmajor) < 0) { 3231 vperror(0, gettext("%s: mknod failed"), namep); 3232 continue; 3233 } 3234 bytes = stbuf.st_size; 3235 blocks = TBLOCKS(bytes); 3236 if (vflag) { 3237 (void) fprintf(vfile, "x %s, %" FMT_off_t 3238 " %s, ", namep, bytes, gettext("bytes")); 3239 if (NotTape) 3240 (void) fprintf(vfile, "%" FMT_blkcnt_t 3241 "K\n", K(blocks)); 3242 else 3243 (void) fprintf(vfile, gettext("%" 3244 FMT_blkcnt_t " tape blocks\n"), 3245 blocks); 3246 } 3247 goto filedone; 3248 } 3249 if (dblock.dbuf.typeflag == '3' && !Uid) { /* CHAR SPECIAL */ 3250 if (rmdir(namep) < 0) { 3251 if (errno == ENOTDIR) 3252 (void) unlink(namep); 3253 } 3254 linkp = templink; 3255 if (*linkp != NULL) { 3256 if (Aflag && *linkp == '/') 3257 linkp++; 3258 if (link(linkp, namep) < 0) { 3259 (void) fprintf(stderr, gettext( 3260 "tar: %s: cannot link\n"), namep); 3261 continue; 3262 } 3263 if (vflag) 3264 (void) fprintf(vfile, gettext( 3265 "x %s linked to %s\n"), namep, 3266 linkp); 3267 xcnt++; /* increment # files extracted */ 3268 continue; 3269 } 3270 if (mknod(namep, (int)(Gen.g_mode|S_IFCHR), 3271 (int)makedev(Gen.g_devmajor, Gen.g_devminor)) < 0) { 3272 vperror(0, gettext( 3273 "%s: mknod failed"), namep); 3274 continue; 3275 } 3276 bytes = stbuf.st_size; 3277 blocks = TBLOCKS(bytes); 3278 if (vflag) { 3279 (void) fprintf(vfile, "x %s, %" FMT_off_t 3280 " %s, ", namep, bytes, gettext("bytes")); 3281 if (NotTape) 3282 (void) fprintf(vfile, "%" FMT_blkcnt_t 3283 "K\n", K(blocks)); 3284 else 3285 (void) fprintf(vfile, gettext("%" 3286 FMT_blkcnt_t " tape blocks\n"), 3287 blocks); 3288 } 3289 goto filedone; 3290 } else if (dblock.dbuf.typeflag == '3' && Uid) { 3291 (void) fprintf(stderr, gettext( 3292 "Can't create special %s\n"), namep); 3293 continue; 3294 } 3295 3296 /* BLOCK SPECIAL */ 3297 3298 if (dblock.dbuf.typeflag == '4' && !Uid) { 3299 if (rmdir(namep) < 0) { 3300 if (errno == ENOTDIR) 3301 (void) unlink(namep); 3302 } 3303 linkp = templink; 3304 if (*linkp != NULL) { 3305 if (Aflag && *linkp == '/') 3306 linkp++; 3307 if (link(linkp, namep) < 0) { 3308 (void) fprintf(stderr, gettext( 3309 "tar: %s: cannot link\n"), namep); 3310 continue; 3311 } 3312 if (vflag) 3313 (void) fprintf(vfile, gettext( 3314 "x %s linked to %s\n"), namep, 3315 linkp); 3316 xcnt++; /* increment # files extracted */ 3317 continue; 3318 } 3319 if (mknod(namep, (int)(Gen.g_mode|S_IFBLK), 3320 (int)makedev(Gen.g_devmajor, Gen.g_devminor)) < 0) { 3321 vperror(0, gettext("%s: mknod failed"), namep); 3322 continue; 3323 } 3324 bytes = stbuf.st_size; 3325 blocks = TBLOCKS(bytes); 3326 if (vflag) { 3327 (void) fprintf(vfile, gettext("x %s, %" 3328 FMT_off_t " bytes, "), namep, bytes); 3329 if (NotTape) 3330 (void) fprintf(vfile, "%" FMT_blkcnt_t 3331 "K\n", K(blocks)); 3332 else 3333 (void) fprintf(vfile, gettext("%" 3334 FMT_blkcnt_t " tape blocks\n"), 3335 blocks); 3336 } 3337 goto filedone; 3338 } else if (dblock.dbuf.typeflag == '4' && Uid) { 3339 (void) fprintf(stderr, 3340 gettext("Can't create special %s\n"), namep); 3341 continue; 3342 } 3343 if (dblock.dbuf.typeflag == '2') { /* symlink */ 3344 if ((Tflag) && (lk_rpath_flag == 1)) 3345 linkp = lk_real_path; 3346 else 3347 linkp = templink; 3348 if (Aflag && *linkp == '/') 3349 linkp++; 3350 if (rmdir(namep) < 0) { 3351 if (errno == ENOTDIR) 3352 (void) unlink(namep); 3353 } 3354 if (symlink(linkp, namep) < 0) { 3355 vperror(0, gettext("%s: symbolic link failed"), 3356 namep); 3357 continue; 3358 } 3359 if (vflag) 3360 (void) fprintf(vfile, gettext( 3361 "x %s symbolic link to %s\n"), 3362 namep, linkp); 3363 3364 symflag = AT_SYMLINK_NOFOLLOW; 3365 goto filedone; 3366 } 3367 if (dblock.dbuf.typeflag == '1') { 3368 linkp = templink; 3369 if (Aflag && *linkp == '/') 3370 linkp++; 3371 if (unlinkat(dirfd, comp, AT_REMOVEDIR) < 0) { 3372 if (errno == ENOTDIR) 3373 (void) unlinkat(dirfd, comp, 0); 3374 } 3375 #if defined(O_XATTR) 3376 if (xattrp && xattr_linkp) { 3377 if (fchdir(dirfd) < 0) { 3378 vperror(0, gettext( 3379 "Cannot fchdir to attribute " 3380 "directory %s"), 3381 (attrinfo->attr_parent == NULL) ? 3382 dirp : attrinfo->attr_parent); 3383 exit(1); 3384 } 3385 3386 error = link(xattr_linkaname, xattrapath); 3387 } else { 3388 error = link(linkp, namep); 3389 } 3390 #else 3391 error = link(linkp, namep); 3392 #endif 3393 3394 if (error < 0) { 3395 (void) fprintf(stderr, gettext( 3396 "tar: %s%s%s: cannot link\n"), 3397 namep, (xattr_linkp != NULL) ? 3398 gettext(" attribute ") : "", 3399 (xattr_linkp != NULL) ? 3400 xattrapath : ""); 3401 continue; 3402 } 3403 if (vflag) 3404 (void) fprintf(vfile, gettext( 3405 "x %s%s%s linked to %s%s%s\n"), namep, 3406 (xattr_linkp != NULL) ? 3407 gettext(" attribute ") : "", 3408 (xattr_linkp != NULL) ? 3409 xattr_linkaname : "", 3410 linkp, 3411 (xattr_linkp != NULL) ? 3412 gettext(" attribute ") : "", 3413 (xattr_linkp != NULL) ? xattrapath : ""); 3414 xcnt++; /* increment # files extracted */ 3415 #if defined(O_XATTR) 3416 if (xattrp != NULL) { 3417 free(xattrhead); 3418 xattrp = NULL; 3419 xattr_linkp = NULL; 3420 xattrhead = NULL; 3421 } 3422 #endif 3423 continue; 3424 } 3425 3426 /* REGULAR FILES */ 3427 3428 if (convtoreg(stbuf.st_size)) { 3429 convflag = 1; 3430 if (errflag) { 3431 (void) fprintf(stderr, gettext( 3432 "tar: %s: typeflag '%c' not recognized\n"), 3433 namep, dblock.dbuf.typeflag); 3434 done(1); 3435 } else { 3436 (void) fprintf(stderr, gettext( 3437 "tar: %s: typeflag '%c' not recognized, " 3438 "converting to regular file\n"), namep, 3439 dblock.dbuf.typeflag); 3440 Errflg = 1; 3441 } 3442 } 3443 if (dblock.dbuf.typeflag == '0' || 3444 dblock.dbuf.typeflag == NULL || convflag) { 3445 delete_target(dirfd, comp, namep); 3446 linkp = templink; 3447 if (*linkp != NULL) { 3448 if (Aflag && *linkp == '/') 3449 linkp++; 3450 if (link(linkp, comp) < 0) { 3451 (void) fprintf(stderr, gettext( 3452 "tar: %s: cannot link\n"), namep); 3453 continue; 3454 } 3455 if (vflag) 3456 (void) fprintf(vfile, gettext( 3457 "x %s linked to %s\n"), comp, 3458 linkp); 3459 xcnt++; /* increment # files extracted */ 3460 #if defined(O_XATTR) 3461 if (xattrp != NULL) { 3462 free(xattrhead); 3463 xattrp = NULL; 3464 xattr_linkp = NULL; 3465 xattrhead = NULL; 3466 } 3467 #endif 3468 continue; 3469 } 3470 newfile = ((fstatat(dirfd, comp, 3471 &xtractbuf, 0) == -1) ? TRUE : FALSE); 3472 ofile = openat(dirfd, comp, O_RDWR|O_CREAT|O_TRUNC, 3473 stbuf.st_mode & MODEMASK); 3474 saveerrno = errno; 3475 3476 #if defined(O_XATTR) 3477 if (xattrp != NULL) { 3478 if (ofile < 0) { 3479 ofile = retry_open_attr(dirfd, cwd, 3480 dirp, attrinfo->attr_parent, comp, 3481 O_RDWR|O_CREAT|O_TRUNC, 3482 stbuf.st_mode & MODEMASK); 3483 } 3484 } 3485 #endif 3486 if (ofile < 0) { 3487 errno = saveerrno; 3488 (void) fprintf(stderr, gettext( 3489 "tar: %s%s%s%s - cannot create\n"), 3490 (xattrp == NULL) ? "" : (rw_sysattr ? 3491 gettext("system attribute ") : 3492 gettext("attribute ")), 3493 (xattrp == NULL) ? "" : xattrapath, 3494 (xattrp == NULL) ? "" : gettext(" of "), 3495 (xattrp == NULL) ? comp : namep); 3496 if (errflag) 3497 done(1); 3498 else 3499 Errflg = 1; 3500 #if defined(O_XATTR) 3501 if (xattrp != NULL) { 3502 dblock.dbuf.typeflag = _XATTR_HDRTYPE; 3503 free(xattrhead); 3504 xattrp = NULL; 3505 xattr_linkp = NULL; 3506 xattrhead = NULL; 3507 } 3508 #endif 3509 passtape(); 3510 continue; 3511 } 3512 3513 if (Tflag && (check_ext_attr(namep) == 0)) { 3514 if (errflag) 3515 done(1); 3516 else 3517 Errflg = 1; 3518 passtape(); 3519 continue; 3520 } 3521 3522 if (extno != 0) { /* file is in pieces */ 3523 if (extotal < 1 || extotal > MAXEXT) 3524 (void) fprintf(stderr, gettext( 3525 "tar: ignoring bad extent info for " 3526 "%s%s%s%s\n"), 3527 (xattrp == NULL) ? "" : (rw_sysattr ? 3528 gettext("system attribute ") : 3529 gettext("attribute ")), 3530 (xattrp == NULL) ? "" : xattrapath, 3531 (xattrp == NULL) ? "" : gettext(" of "), 3532 (xattrp == NULL) ? comp : namep); 3533 else { 3534 /* extract it */ 3535 (void) xsfile(rw_sysattr, ofile); 3536 } 3537 } 3538 extno = 0; /* let everyone know file is not split */ 3539 bytes = stbuf.st_size; 3540 blocks = TBLOCKS(bytes); 3541 if (vflag) { 3542 (void) fprintf(vfile, 3543 "x %s%s%s, %" FMT_off_t " %s, ", 3544 (xattrp == NULL) ? "" : dirp, 3545 (xattrp == NULL) ? "" : (rw_sysattr ? 3546 gettext(" system attribute ") : 3547 gettext(" attribute ")), 3548 (xattrp == NULL) ? namep : xattrapath, bytes, 3549 gettext("bytes")); 3550 if (NotTape) 3551 (void) fprintf(vfile, "%" FMT_blkcnt_t "K\n", 3552 K(blocks)); 3553 else 3554 (void) fprintf(vfile, gettext("%" 3555 FMT_blkcnt_t " tape blocks\n"), blocks); 3556 } 3557 3558 if (xblocks(rw_sysattr, bytes, ofile) != 0) { 3559 #if defined(O_XATTR) 3560 if (xattrp != NULL) { 3561 free(xattrhead); 3562 xattrp = NULL; 3563 xattr_linkp = NULL; 3564 xattrhead = NULL; 3565 } 3566 #endif 3567 continue; 3568 } 3569 filedone: 3570 if (mflag == 0 && !symflag) { 3571 if (dir) 3572 doDirTimes(namep, stbuf.st_mtim); 3573 3574 else 3575 #if defined(O_XATTR) 3576 if (xattrp != NULL) { 3577 /* 3578 * Set the time on the attribute unless 3579 * the attribute is a system attribute 3580 * (can't successfully do this) or the 3581 * hidden attribute directory, "." (the 3582 * time on the hidden attribute 3583 * directory will be updated when 3584 * attributes are restored, otherwise 3585 * it's transient). 3586 */ 3587 if (!rw_sysattr && (Hiddendir == 0)) { 3588 setPathTimes(dirfd, comp, 3589 stbuf.st_mtim); 3590 } 3591 } else 3592 setPathTimes(dirfd, comp, 3593 stbuf.st_mtim); 3594 #else 3595 setPathTimes(dirfd, comp, stbuf.st_mtim); 3596 #endif 3597 } 3598 3599 /* moved this code from above */ 3600 if (pflag && !symflag && Hiddendir == 0) { 3601 if (xattrp != NULL) 3602 (void) fchmod(ofile, stbuf.st_mode & MODEMASK); 3603 else 3604 (void) chmod(namep, stbuf.st_mode & MODEMASK); 3605 } 3606 3607 3608 /* 3609 * Because ancillary file preceeds the normal file, 3610 * acl info may have been retrieved (in aclp). 3611 * All file types are directed here (go filedone). 3612 * Always restore ACLs if there are ACLs. 3613 */ 3614 if (aclp != NULL) { 3615 int ret; 3616 3617 #if defined(O_XATTR) 3618 if (xattrp != NULL) { 3619 if (Hiddendir) 3620 ret = facl_set(dirfd, aclp); 3621 else 3622 ret = facl_set(ofile, aclp); 3623 } else { 3624 ret = acl_set(namep, aclp); 3625 } 3626 #else 3627 ret = acl_set(namep, aclp); 3628 #endif 3629 if (ret < 0) { 3630 if (pflag) { 3631 (void) fprintf(stderr, gettext( 3632 "%s%s%s%s: failed to set acl " 3633 "entries\n"), namep, 3634 (xattrp == NULL) ? "" : 3635 (rw_sysattr ? gettext( 3636 " system attribute ") : 3637 gettext(" attribute ")), 3638 (xattrp == NULL) ? "" : 3639 xattrapath); 3640 } 3641 /* else: silent and continue */ 3642 } 3643 acl_free(aclp); 3644 aclp = NULL; 3645 } 3646 3647 if (!oflag) 3648 /* set file ownership */ 3649 resugname(dirfd, comp, symflag); 3650 3651 if (pflag && newfile == TRUE && !dir && 3652 (dblock.dbuf.typeflag == '0' || 3653 dblock.dbuf.typeflag == NULL || 3654 convflag || dblock.dbuf.typeflag == '1')) { 3655 if (fstat(ofile, &xtractbuf) == -1) 3656 (void) fprintf(stderr, gettext( 3657 "tar: cannot stat extracted file " 3658 "%s%s%s%s\n"), 3659 (xattrp == NULL) ? "" : (rw_sysattr ? 3660 gettext("system attribute ") : 3661 gettext("attribute ")), 3662 (xattrp == NULL) ? "" : xattrapath, 3663 (xattrp == NULL) ? "" : 3664 gettext(" of "), namep); 3665 3666 else if ((xtractbuf.st_mode & (MODEMASK & ~S_IFMT)) 3667 != (stbuf.st_mode & (MODEMASK & ~S_IFMT))) { 3668 (void) fprintf(stderr, gettext( 3669 "tar: warning - file permissions have " 3670 "changed for %s%s%s%s (are 0%o, should be " 3671 "0%o)\n"), 3672 (xattrp == NULL) ? "" : (rw_sysattr ? 3673 gettext("system attribute ") : 3674 gettext("attribute ")), 3675 (xattrp == NULL) ? "" : xattrapath, 3676 (xattrp == NULL) ? "" : 3677 gettext(" of "), namep, 3678 xtractbuf.st_mode, stbuf.st_mode); 3679 3680 } 3681 } 3682 #if defined(O_XATTR) 3683 if (xattrp != NULL) { 3684 free(xattrhead); 3685 xattrp = NULL; 3686 xattr_linkp = NULL; 3687 xattrhead = NULL; 3688 } 3689 #endif 3690 3691 if (ofile != -1) { 3692 (void) close(dirfd); 3693 dirfd = -1; 3694 if (close(ofile) != 0) 3695 vperror(2, gettext("close error")); 3696 ofile = -1; 3697 } 3698 xcnt++; /* increment # files extracted */ 3699 } 3700 3701 /* 3702 * Process ancillary file. 3703 * 3704 */ 3705 3706 if (dblock.dbuf.typeflag == 'A') { /* acl info */ 3707 char buf[TBLOCK]; 3708 char *secp; 3709 char *tp; 3710 int attrsize; 3711 int cnt; 3712 3713 /* reset Trusted Extensions flags */ 3714 dir_flag = 0; 3715 mld_flag = 0; 3716 lk_rpath_flag = 0; 3717 rpath_flag = 0; 3718 3719 if (pflag) { 3720 bytes = stbuf.st_size; 3721 if ((secp = malloc((int)bytes)) == NULL) { 3722 (void) fprintf(stderr, gettext( 3723 "Insufficient memory for acl\n")); 3724 passtape(); 3725 continue; 3726 } 3727 tp = secp; 3728 blocks = TBLOCKS(bytes); 3729 3730 /* 3731 * Display a line for each ancillary file. 3732 */ 3733 if (vflag && Tflag) 3734 (void) fprintf(vfile, "x %s(A), %" 3735 FMT_blkcnt_t " %s, %" 3736 FMT_blkcnt_t " %s\n", 3737 namep, bytes, gettext("bytes"), 3738 blocks, gettext("tape blocks")); 3739 3740 while (blocks-- > 0) { 3741 readtape(buf); 3742 if (bytes <= TBLOCK) { 3743 (void) memcpy(tp, buf, 3744 (size_t)bytes); 3745 break; 3746 } else { 3747 (void) memcpy(tp, buf, 3748 TBLOCK); 3749 tp += TBLOCK; 3750 } 3751 bytes -= TBLOCK; 3752 } 3753 bytes = stbuf.st_size; 3754 /* got all attributes in secp */ 3755 tp = secp; 3756 do { 3757 attr = (struct sec_attr *)tp; 3758 switch (attr->attr_type) { 3759 case UFSD_ACL: 3760 case ACE_ACL: 3761 (void) sscanf(attr->attr_len, 3762 "%7o", 3763 (uint_t *) 3764 &cnt); 3765 /* header is 8 */ 3766 attrsize = 8 + (int)strlen( 3767 &attr->attr_info[0]) + 1; 3768 error = 3769 acl_fromtext( 3770 &attr->attr_info[0], &aclp); 3771 3772 if (error != 0) { 3773 (void) fprintf(stderr, 3774 gettext( 3775 "aclfromtext " 3776 "failed: %s\n"), 3777 acl_strerror( 3778 error)); 3779 bytes -= attrsize; 3780 break; 3781 } 3782 if (acl_cnt(aclp) != cnt) { 3783 (void) fprintf(stderr, 3784 gettext( 3785 "aclcnt error\n")); 3786 bytes -= attrsize; 3787 break; 3788 } 3789 bytes -= attrsize; 3790 break; 3791 3792 /* Trusted Extensions */ 3793 3794 case DIR_TYPE: 3795 case LBL_TYPE: 3796 case APRIV_TYPE: 3797 case FPRIV_TYPE: 3798 case COMP_TYPE: 3799 case LK_COMP_TYPE: 3800 case ATTR_FLAG_TYPE: 3801 attrsize = 3802 sizeof (struct sec_attr) + 3803 strlen(&attr->attr_info[0]); 3804 bytes -= attrsize; 3805 if (Tflag) 3806 extract_attr(&namep, 3807 attr); 3808 break; 3809 3810 default: 3811 (void) fprintf(stderr, gettext( 3812 "unrecognized attr" 3813 " type\n")); 3814 bytes = (off_t)0; 3815 break; 3816 } 3817 3818 /* next attributes */ 3819 tp += attrsize; 3820 } while (bytes != 0); 3821 free(secp); 3822 } else { 3823 passtape(); 3824 } 3825 } /* acl */ 3826 3827 } /* for */ 3828 3829 /* 3830 * Ensure that all the directories still on the directory stack 3831 * get their modification times set correctly by flushing the 3832 * stack. 3833 */ 3834 3835 doDirTimes(NULL, time_zero); 3836 3837 #if defined(O_XATTR) 3838 if (xattrp != NULL) { 3839 free(xattrhead); 3840 xattrp = NULL; 3841 xattr_linkp = NULL; 3842 xattrhead = NULL; 3843 } 3844 #endif 3845 3846 /* 3847 * Check if the number of files extracted is different from the 3848 * number of files listed on the command line 3849 */ 3850 if (fcnt > xcnt) { 3851 (void) fprintf(stderr, 3852 gettext("tar: %d file(s) not extracted\n"), 3853 fcnt-xcnt); 3854 Errflg = 1; 3855 } 3856 } 3857 3858 /* 3859 * xblocks extract file/extent from tape to output file 3860 * 3861 * xblocks(issysattr, bytes, ofile); 3862 * 3863 * issysattr flag set if the files being extracted 3864 * is an extended system attribute file. 3865 * unsigned long long bytes size of extent or file to be extracted 3866 * ofile output file 3867 * 3868 * called by doxtract() and xsfile() 3869 */ 3870 3871 static int 3872 xblocks(int issysattr, off_t bytes, int ofile) 3873 { 3874 char *buf; 3875 char tempname[NAMSIZ+1]; 3876 size_t maxwrite; 3877 size_t bytesread; 3878 size_t piosize; /* preferred I/O size */ 3879 struct stat tsbuf; 3880 3881 /* Don't need to do anything if this is a zero size file */ 3882 if (bytes <= 0) { 3883 return (0); 3884 } 3885 3886 /* 3887 * To figure out the size of the buffer used to accumulate data 3888 * from readtape() and to write to the file, we need to determine 3889 * the largest chunk of data to be written to the file at one time. 3890 * This is determined based on the smallest of the following two 3891 * things: 3892 * 1) The size of the archived file. 3893 * 2) The preferred I/O size of the file. 3894 */ 3895 if (issysattr || (bytes <= TBLOCK)) { 3896 /* 3897 * Writes to system attribute files must be 3898 * performed in one operation. 3899 */ 3900 maxwrite = bytes; 3901 } else { 3902 /* 3903 * fstat() the file to get the preferred I/O size. 3904 * If it fails, then resort back to just writing 3905 * one block at a time. 3906 */ 3907 if (fstat(ofile, &tsbuf) == 0) { 3908 piosize = tsbuf.st_blksize; 3909 } else { 3910 piosize = TBLOCK; 3911 } 3912 maxwrite = min(bytes, piosize); 3913 } 3914 3915 /* 3916 * The buffer used to accumulate the data for the write operation 3917 * needs to be the maximum number of bytes to be written rounded up 3918 * to the nearest TBLOCK since readtape reads one block at a time. 3919 */ 3920 if ((buf = malloc(TBLOCKS(maxwrite) * TBLOCK)) == NULL) { 3921 fatal(gettext("cannot allocate buffer")); 3922 } 3923 3924 while (bytes > 0) { 3925 3926 /* 3927 * readtape() obtains one block (TBLOCK) of data at a time. 3928 * Accumulate as many blocks of data in buf as we can write 3929 * in one operation. 3930 */ 3931 for (bytesread = 0; bytesread < maxwrite; bytesread += TBLOCK) { 3932 readtape(buf + bytesread); 3933 } 3934 3935 if (write(ofile, buf, maxwrite) < 0) { 3936 int saveerrno = errno; 3937 3938 if (xhdr_flgs & _X_PATH) 3939 (void) strlcpy(tempname, Xtarhdr.x_path, 3940 sizeof (tempname)); 3941 else 3942 (void) sprintf(tempname, "%.*s", NAMSIZ, 3943 dblock.dbuf.name); 3944 /* 3945 * If the extended system attribute being extracted 3946 * contains attributes that the user needs privileges 3947 * for, then just display a warning message, skip 3948 * the extraction of this file, and return. 3949 */ 3950 if ((saveerrno == EPERM) && issysattr) { 3951 (void) fprintf(stderr, gettext( 3952 "tar: unable to extract system attribute " 3953 "%s: insufficient privileges\n"), tempname); 3954 Errflg = 1; 3955 (void) free(buf); 3956 return (1); 3957 } else { 3958 (void) fprintf(stderr, gettext( 3959 "tar: %s: HELP - extract write error\n"), 3960 tempname); 3961 done(2); 3962 } 3963 } 3964 bytes -= maxwrite; 3965 3966 /* 3967 * If we've reached this point and there is still data 3968 * to be written, maxwrite had to have been determined 3969 * by the preferred I/O size. If the number of bytes 3970 * left to write is smaller than the preferred I/O size, 3971 * then we're about to do our final write to the file, so 3972 * just set maxwrite to the number of bytes left to write. 3973 */ 3974 if ((bytes > 0) && (bytes < maxwrite)) { 3975 maxwrite = bytes; 3976 } 3977 } 3978 free(buf); 3979 3980 return (0); 3981 } 3982 3983 /* 3984 * xsfile extract split file 3985 * 3986 * xsfile(ofd); ofd = output file descriptor 3987 * 3988 * file extracted and put in ofd via xblocks() 3989 * 3990 * NOTE: only called by doxtract() to extract one large file 3991 */ 3992 3993 static union hblock savedblock; /* to ensure same file across volumes */ 3994 3995 static int 3996 xsfile(int issysattr, int ofd) 3997 { 3998 int i, c; 3999 int sysattrerr = 0; 4000 char name[PATH_MAX+1]; /* holds name for diagnostics */ 4001 int extents, totalext; 4002 off_t bytes, totalbytes; 4003 4004 if (xhdr_flgs & _X_PATH) 4005 (void) strcpy(name, Xtarhdr.x_path); 4006 else 4007 (void) sprintf(name, "%.*s", NAMSIZ, dblock.dbuf.name); 4008 4009 totalbytes = (off_t)0; /* in case we read in half the file */ 4010 totalext = 0; /* these keep count */ 4011 4012 (void) fprintf(stderr, gettext( 4013 "tar: %s split across %d volumes\n"), name, extotal); 4014 4015 /* make sure we do extractions in order */ 4016 if (extno != 1) { /* starting in middle of file? */ 4017 (void) printf(gettext( 4018 "tar: first extent read is not #1\n" 4019 "OK to read file beginning with extent #%d (%s/%s) ? "), 4020 extno, yesstr, nostr); 4021 if (yes() == 0) { 4022 canit: 4023 passtape(); 4024 if (close(ofd) != 0) 4025 vperror(2, gettext("close error")); 4026 if (sysattrerr) { 4027 return (1); 4028 } else { 4029 return (0); 4030 } 4031 } 4032 } 4033 extents = extotal; 4034 i = extno; 4035 /*CONSTCOND*/ 4036 while (1) { 4037 if (xhdr_flgs & _X_SIZE) { 4038 bytes = extsize; 4039 } else { 4040 bytes = stbuf.st_size; 4041 } 4042 4043 if (vflag) 4044 (void) fprintf(vfile, "+++ x %s [%s #%d], %" 4045 FMT_off_t " %s, %ldK\n", 4046 name, gettext("extent"), extno, 4047 bytes, gettext("bytes"), 4048 (long)K(TBLOCKS(bytes))); 4049 if (xblocks(issysattr, bytes, ofd) != 0) { 4050 sysattrerr = 1; 4051 goto canit; 4052 } 4053 4054 totalbytes += bytes; 4055 totalext++; 4056 if (++i > extents) 4057 break; 4058 4059 /* get next volume and verify it's the right one */ 4060 copy(&savedblock, &dblock); 4061 tryagain: 4062 newvol(); 4063 xhdr_flgs = 0; 4064 getdir(); 4065 if (Xhdrflag > 0) 4066 (void) get_xdata(); /* Get x-header & regular hdr */ 4067 if ((dblock.dbuf.typeflag != 'A') && (xhdr_flgs != 0)) { 4068 load_info_from_xtarhdr(xhdr_flgs, &Xtarhdr); 4069 xhdr_flgs |= _X_XHDR; 4070 } 4071 if (endtape()) { /* seemingly empty volume */ 4072 (void) fprintf(stderr, gettext( 4073 "tar: first record is null\n")); 4074 asknicely: 4075 (void) fprintf(stderr, gettext( 4076 "tar: need volume with extent #%d of %s\n"), 4077 i, name); 4078 goto tryagain; 4079 } 4080 if (notsame()) { 4081 (void) fprintf(stderr, gettext( 4082 "tar: first file on that volume is not " 4083 "the same file\n")); 4084 goto asknicely; 4085 } 4086 if (i != extno) { 4087 (void) fprintf(stderr, gettext( 4088 "tar: extent #%d received out of order\ntar: " 4089 "should be #%d\n"), extno, i); 4090 (void) fprintf(stderr, gettext( 4091 "Ignore error, Abort this file, or " 4092 "load New volume (i/a/n) ? ")); 4093 c = response(); 4094 if (c == 'a') 4095 goto canit; 4096 if (c != 'i') /* default to new volume */ 4097 goto asknicely; 4098 i = extno; /* okay, start from there */ 4099 } 4100 } 4101 if (vflag) 4102 (void) fprintf(vfile, gettext( 4103 "x %s (in %d extents), %" FMT_off_t " bytes, %ldK\n"), 4104 name, totalext, totalbytes, (long)K(TBLOCKS(totalbytes))); 4105 4106 return (0); 4107 } 4108 4109 4110 /* 4111 * notsame() check if extract file extent is invalid 4112 * 4113 * returns true if anything differs between savedblock and dblock 4114 * except extno (extent number), checksum, or size (extent size). 4115 * Determines if this header belongs to the same file as the one we're 4116 * extracting. 4117 * 4118 * NOTE: though rather bulky, it is only called once per file 4119 * extension, and it can withstand changes in the definition 4120 * of the header structure. 4121 * 4122 * WARNING: this routine is local to xsfile() above 4123 */ 4124 4125 static int 4126 notsame(void) 4127 { 4128 return ( 4129 (strncmp(savedblock.dbuf.name, dblock.dbuf.name, NAMSIZ)) || 4130 (strcmp(savedblock.dbuf.mode, dblock.dbuf.mode)) || 4131 (strcmp(savedblock.dbuf.uid, dblock.dbuf.uid)) || 4132 (strcmp(savedblock.dbuf.gid, dblock.dbuf.gid)) || 4133 (strcmp(savedblock.dbuf.mtime, dblock.dbuf.mtime)) || 4134 (savedblock.dbuf.typeflag != dblock.dbuf.typeflag) || 4135 (strncmp(savedblock.dbuf.linkname, dblock.dbuf.linkname, NAMSIZ)) || 4136 (savedblock.dbuf.extotal != dblock.dbuf.extotal) || 4137 (strcmp(savedblock.dbuf.efsize, dblock.dbuf.efsize))); 4138 } 4139 4140 static void 4141 dotable(char *argv[]) 4142 { 4143 int tcnt = 0; /* count # files tabled */ 4144 int fcnt = 0; /* count # files in argv list */ 4145 char *namep, *dirp, *comp; 4146 int want; 4147 char aclchar = ' '; /* either blank or '+' */ 4148 char templink[PATH_MAX+1]; 4149 attr_data_t *attrinfo = NULL; 4150 4151 dumping = 0; 4152 4153 /* if not on magtape, maximize seek speed */ 4154 if (NotTape && !bflag) { 4155 #if SYS_BLOCK > TBLOCK 4156 nblock = SYS_BLOCK / TBLOCK; 4157 #else 4158 nblock = 1; 4159 #endif 4160 } 4161 4162 for (;;) { 4163 4164 /* namep is set by wantit to point to the full name */ 4165 if ((want = wantit(argv, &namep, &dirp, &comp, &attrinfo)) == 0) 4166 continue; 4167 if (want == -1) 4168 break; 4169 if (dblock.dbuf.typeflag != 'A') 4170 ++tcnt; 4171 4172 if (Fflag) { 4173 if (checkf(namep, is_directory(namep), Fflag) == 0) { 4174 passtape(); 4175 continue; 4176 } 4177 } 4178 /* 4179 * ACL support: 4180 * aclchar is introduced to indicate if there are 4181 * acl entries. longt() now takes one extra argument. 4182 */ 4183 if (vflag) { 4184 if (dblock.dbuf.typeflag == 'A') { 4185 aclchar = '+'; 4186 passtape(); 4187 continue; 4188 } 4189 longt(&stbuf, aclchar); 4190 aclchar = ' '; 4191 } 4192 4193 4194 #if defined(O_XATTR) 4195 if (xattrp != NULL) { 4196 int issysattr; 4197 char *bn = basename(attrinfo->attr_path); 4198 4199 /* 4200 * We could use sysattr_type() to test whether or not 4201 * the attribute we are processing is really an 4202 * extended system attribute, which as of this writing 4203 * just does a strcmp(), however, sysattr_type() may 4204 * be changed to issue a pathconf() call instead, which 4205 * would require being changed into the parent attribute 4206 * directory. So instead, just do simple string 4207 * comparisons to see if we are processing an extended 4208 * system attribute. 4209 */ 4210 issysattr = is_sysattr(bn); 4211 4212 (void) printf(gettext("%s %sattribute %s"), 4213 xattrp->h_names, 4214 issysattr ? gettext("system ") : "", 4215 attrinfo->attr_path); 4216 } else { 4217 (void) printf("%s", namep); 4218 } 4219 #else 4220 (void) printf("%s", namep); 4221 #endif 4222 4223 if (extno != 0) { 4224 if (vflag) { 4225 /* keep the '\n' for backwards compatibility */ 4226 (void) fprintf(vfile, gettext( 4227 "\n [extent #%d of %d]"), extno, extotal); 4228 } else { 4229 (void) fprintf(vfile, gettext( 4230 " [extent #%d of %d]"), extno, extotal); 4231 } 4232 } 4233 if (xhdr_flgs & _X_LINKPATH) { 4234 (void) strcpy(templink, Xtarhdr.x_linkpath); 4235 } else { 4236 #if defined(O_XATTR) 4237 if (xattrp != NULL) { 4238 (void) sprintf(templink, 4239 "file %.*s", NAMSIZ, xattrp->h_names); 4240 } else { 4241 (void) sprintf(templink, "%.*s", NAMSIZ, 4242 dblock.dbuf.linkname); 4243 } 4244 #else 4245 (void) sprintf(templink, "%.*s", NAMSIZ, 4246 dblock.dbuf.linkname); 4247 #endif 4248 templink[NAMSIZ] = '\0'; 4249 } 4250 if (dblock.dbuf.typeflag == '1') { 4251 /* 4252 * TRANSLATION_NOTE 4253 * Subject is omitted here. 4254 * Translate this as if 4255 * <subject> linked to %s 4256 */ 4257 #if defined(O_XATTR) 4258 if (xattrp != NULL) { 4259 (void) printf( 4260 gettext(" linked to attribute %s"), 4261 xattr_linkp->h_names + 4262 strlen(xattr_linkp->h_names) + 1); 4263 } else { 4264 (void) printf( 4265 gettext(" linked to %s"), templink); 4266 } 4267 #else 4268 (void) printf( 4269 gettext(" linked to %s"), templink); 4270 4271 #endif 4272 } 4273 if (dblock.dbuf.typeflag == '2') 4274 (void) printf(gettext( 4275 /* 4276 * TRANSLATION_NOTE 4277 * Subject is omitted here. 4278 * Translate this as if 4279 * <subject> symbolic link to %s 4280 */ 4281 " symbolic link to %s"), templink); 4282 (void) printf("\n"); 4283 #if defined(O_XATTR) 4284 if (xattrp != NULL) { 4285 free(xattrhead); 4286 xattrp = NULL; 4287 xattrhead = NULL; 4288 } 4289 #endif 4290 passtape(); 4291 } 4292 /* 4293 * Check if the number of files tabled is different from the 4294 * number of files listed on the command line 4295 */ 4296 if (fcnt > tcnt) { 4297 (void) fprintf(stderr, gettext( 4298 "tar: %d file(s) not found\n"), fcnt-tcnt); 4299 Errflg = 1; 4300 } 4301 } 4302 4303 static void 4304 putempty(blkcnt_t n) 4305 { 4306 char buf[TBLOCK]; 4307 char *cp; 4308 4309 for (cp = buf; cp < &buf[TBLOCK]; ) 4310 *cp++ = '\0'; 4311 while (n-- > 0) 4312 (void) writetbuf(buf, 1); 4313 } 4314 4315 static ushort_t Ftype = S_IFMT; 4316 4317 static void 4318 verbose(struct stat *st, char aclchar) 4319 { 4320 int i, j, temp; 4321 mode_t mode; 4322 char modestr[12]; 4323 4324 for (i = 0; i < 11; i++) 4325 modestr[i] = '-'; 4326 modestr[i] = '\0'; 4327 4328 /* a '+' sign is printed if there is ACL */ 4329 modestr[i-1] = aclchar; 4330 4331 mode = st->st_mode; 4332 for (i = 0; i < 3; i++) { 4333 temp = (mode >> (6 - (i * 3))); 4334 j = (i * 3) + 1; 4335 if (S_IROTH & temp) 4336 modestr[j] = 'r'; 4337 if (S_IWOTH & temp) 4338 modestr[j + 1] = 'w'; 4339 if (S_IXOTH & temp) 4340 modestr[j + 2] = 'x'; 4341 } 4342 temp = st->st_mode & Ftype; 4343 switch (temp) { 4344 case (S_IFIFO): 4345 modestr[0] = 'p'; 4346 break; 4347 case (S_IFCHR): 4348 modestr[0] = 'c'; 4349 break; 4350 case (S_IFDIR): 4351 modestr[0] = 'd'; 4352 break; 4353 case (S_IFBLK): 4354 modestr[0] = 'b'; 4355 break; 4356 case (S_IFREG): /* was initialized to '-' */ 4357 break; 4358 case (S_IFLNK): 4359 modestr[0] = 'l'; 4360 break; 4361 default: 4362 /* This field may be zero in old archives. */ 4363 if (is_posix && dblock.dbuf.typeflag != '1') { 4364 /* 4365 * For POSIX compliant archives, the mode field 4366 * consists of 12 bits, ie: the file type bits 4367 * are not stored in dblock.dbuf.mode. 4368 * For files other than hard links, getdir() sets 4369 * the file type bits in the st_mode field of the 4370 * stat structure based upon dblock.dbuf.typeflag. 4371 */ 4372 (void) fprintf(stderr, gettext( 4373 "tar: impossible file type")); 4374 } 4375 } 4376 4377 if ((S_ISUID & Gen.g_mode) == S_ISUID) 4378 modestr[3] = 's'; 4379 if ((S_ISVTX & Gen.g_mode) == S_ISVTX) 4380 modestr[9] = 't'; 4381 if ((S_ISGID & Gen.g_mode) == S_ISGID && modestr[6] == 'x') 4382 modestr[6] = 's'; 4383 else if ((S_ENFMT & Gen.g_mode) == S_ENFMT && modestr[6] != 'x') 4384 modestr[6] = 'l'; 4385 (void) fprintf(vfile, "%s", modestr); 4386 } 4387 4388 static void 4389 longt(struct stat *st, char aclchar) 4390 { 4391 char fileDate[30]; 4392 struct tm *tm; 4393 4394 verbose(st, aclchar); 4395 (void) fprintf(vfile, "%3ld/%-3ld", st->st_uid, st->st_gid); 4396 4397 if (dblock.dbuf.typeflag == '2') { 4398 if (xhdr_flgs & _X_LINKPATH) 4399 st->st_size = (off_t)strlen(Xtarhdr.x_linkpath); 4400 else 4401 st->st_size = (off_t)(memchr(dblock.dbuf.linkname, 4402 '\0', NAMSIZ) ? 4403 (strlen(dblock.dbuf.linkname)) : (NAMSIZ)); 4404 } 4405 (void) fprintf(vfile, " %6" FMT_off_t, st->st_size); 4406 4407 tm = localtime(&(st->st_mtime)); 4408 (void) strftime(fileDate, sizeof (fileDate), 4409 dcgettext((const char *)0, "%b %e %R %Y", LC_TIME), tm); 4410 (void) fprintf(vfile, " %s ", fileDate); 4411 } 4412 4413 4414 /* 4415 * checkdir - Attempt to ensure that the path represented in name 4416 * exists, and return 1 if this is true and name itself is a 4417 * directory. 4418 * Return 0 if this path cannot be created or if name is not 4419 * a directory. 4420 */ 4421 4422 static int 4423 checkdir(char *name) 4424 { 4425 char lastChar; /* the last character in name */ 4426 char *cp; /* scratch pointer into name */ 4427 char *firstSlash = NULL; /* first slash in name */ 4428 char *lastSlash = NULL; /* last slash in name */ 4429 int nameLen; /* length of name */ 4430 int trailingSlash; /* true if name ends in slash */ 4431 int leadingSlash; /* true if name begins with slash */ 4432 int markedDir; /* true if name denotes a directory */ 4433 int success; /* status of makeDir call */ 4434 4435 4436 /* 4437 * Scan through the name, and locate first and last slashes. 4438 */ 4439 4440 for (cp = name; *cp; cp++) { 4441 if (*cp == '/') { 4442 if (! firstSlash) { 4443 firstSlash = cp; 4444 } 4445 lastSlash = cp; 4446 } 4447 } 4448 4449 /* 4450 * Determine what you can from the proceeds of the scan. 4451 */ 4452 4453 lastChar = *(cp - 1); 4454 nameLen = (int)(cp - name); 4455 trailingSlash = (lastChar == '/'); 4456 leadingSlash = (*name == '/'); 4457 markedDir = (dblock.dbuf.typeflag == '5' || trailingSlash); 4458 4459 if (! lastSlash && ! markedDir) { 4460 /* 4461 * The named file does not have any subdrectory 4462 * structure; just bail out. 4463 */ 4464 4465 return (0); 4466 } 4467 4468 /* 4469 * Make sure that name doesn`t end with slash for the loop. 4470 * This ensures that the makeDir attempt after the loop is 4471 * meaningful. 4472 */ 4473 4474 if (trailingSlash) { 4475 name[nameLen-1] = '\0'; 4476 } 4477 4478 /* 4479 * Make the path one component at a time. 4480 */ 4481 4482 for (cp = strchr(leadingSlash ? name+1 : name, '/'); 4483 cp; 4484 cp = strchr(cp+1, '/')) { 4485 *cp = '\0'; 4486 success = makeDir(name); 4487 *cp = '/'; 4488 4489 if (!success) { 4490 name[nameLen-1] = lastChar; 4491 return (0); 4492 } 4493 } 4494 4495 /* 4496 * This makes the last component of the name, if it is a 4497 * directory. 4498 */ 4499 4500 if (markedDir) { 4501 if (! makeDir(name)) { 4502 name[nameLen-1] = lastChar; 4503 return (0); 4504 } 4505 } 4506 4507 name[nameLen-1] = (lastChar == '/') ? '\0' : lastChar; 4508 return (markedDir); 4509 } 4510 4511 /* 4512 * resugname - Restore the user name and group name. Search the NIS 4513 * before using the uid and gid. 4514 * (It is presumed that an archive entry cannot be 4515 * simultaneously a symlink and some other type.) 4516 */ 4517 4518 static void 4519 resugname(int dirfd, /* dir fd file resides in */ 4520 char *name, /* name of the file to be modified */ 4521 int symflag) /* true if file is a symbolic link */ 4522 { 4523 uid_t duid; 4524 gid_t dgid; 4525 struct stat *sp = &stbuf; 4526 char *u_g_name; 4527 4528 if (checkflag == 1) { /* Extended tar format and euid == 0 */ 4529 4530 /* 4531 * Try and extract the intended uid and gid from the name 4532 * service before believing the uid and gid in the header. 4533 * 4534 * In the case where we archived a setuid or setgid file 4535 * owned by someone with a large uid, then it will 4536 * have made it into the archive with a uid of nobody. If 4537 * the corresponding username doesn't appear to exist, then we 4538 * want to make sure it *doesn't* end up as setuid nobody! 4539 * 4540 * Our caller will print an error message about the fact 4541 * that the restore didn't work out quite right .. 4542 */ 4543 if (xhdr_flgs & _X_UNAME) 4544 u_g_name = Xtarhdr.x_uname; 4545 else 4546 u_g_name = dblock.dbuf.uname; 4547 if ((duid = getuidbyname(u_g_name)) == -1) { 4548 if (S_ISREG(sp->st_mode) && sp->st_uid == UID_NOBODY && 4549 (sp->st_mode & S_ISUID) == S_ISUID) 4550 (void) chmod(name, 4551 MODEMASK & sp->st_mode & ~S_ISUID); 4552 duid = sp->st_uid; 4553 } 4554 4555 /* (Ditto for gids) */ 4556 4557 if (xhdr_flgs & _X_GNAME) 4558 u_g_name = Xtarhdr.x_gname; 4559 else 4560 u_g_name = dblock.dbuf.gname; 4561 if ((dgid = getgidbyname(u_g_name)) == -1) { 4562 if (S_ISREG(sp->st_mode) && sp->st_gid == GID_NOBODY && 4563 (sp->st_mode & S_ISGID) == S_ISGID) 4564 (void) chmod(name, 4565 MODEMASK & sp->st_mode & ~S_ISGID); 4566 dgid = sp->st_gid; 4567 } 4568 } else if (checkflag == 2) { /* tar format and euid == 0 */ 4569 duid = sp->st_uid; 4570 dgid = sp->st_gid; 4571 } 4572 if ((checkflag == 1) || (checkflag == 2)) 4573 (void) fchownat(dirfd, name, duid, dgid, symflag); 4574 } 4575 4576 /*ARGSUSED*/ 4577 static void 4578 onintr(int sig) 4579 { 4580 (void) signal(SIGINT, SIG_IGN); 4581 term++; 4582 } 4583 4584 /*ARGSUSED*/ 4585 static void 4586 onquit(int sig) 4587 { 4588 (void) signal(SIGQUIT, SIG_IGN); 4589 term++; 4590 } 4591 4592 /*ARGSUSED*/ 4593 static void 4594 onhup(int sig) 4595 { 4596 (void) signal(SIGHUP, SIG_IGN); 4597 term++; 4598 } 4599 4600 static void 4601 tomodes(struct stat *sp) 4602 { 4603 uid_t uid; 4604 gid_t gid; 4605 4606 bzero(dblock.dummy, TBLOCK); 4607 4608 /* 4609 * If the uid or gid is too large, we can't put it into 4610 * the archive. We could fail to put anything in the 4611 * archive at all .. but most of the time the name service 4612 * will save the day when we do a lookup at restore time. 4613 * 4614 * Instead we choose a "safe" uid and gid, and fix up whether 4615 * or not the setuid and setgid bits are left set to extraction 4616 * time. 4617 */ 4618 if (Eflag) { 4619 if ((ulong_t)(uid = sp->st_uid) > (ulong_t)OCTAL7CHAR) { 4620 xhdr_flgs |= _X_UID; 4621 Xtarhdr.x_uid = uid; 4622 } 4623 if ((ulong_t)(gid = sp->st_gid) > (ulong_t)OCTAL7CHAR) { 4624 xhdr_flgs |= _X_GID; 4625 Xtarhdr.x_gid = gid; 4626 } 4627 if (sp->st_size > TAR_OFFSET_MAX) { 4628 xhdr_flgs |= _X_SIZE; 4629 Xtarhdr.x_filesz = sp->st_size; 4630 (void) sprintf(dblock.dbuf.size, "%011" FMT_off_t_o, 4631 (off_t)0); 4632 } else 4633 (void) sprintf(dblock.dbuf.size, "%011" FMT_off_t_o, 4634 sp->st_size); 4635 } else { 4636 (void) sprintf(dblock.dbuf.size, "%011" FMT_off_t_o, 4637 sp->st_size); 4638 } 4639 if ((ulong_t)(uid = sp->st_uid) > (ulong_t)OCTAL7CHAR) 4640 uid = UID_NOBODY; 4641 if ((ulong_t)(gid = sp->st_gid) > (ulong_t)OCTAL7CHAR) 4642 gid = GID_NOBODY; 4643 (void) sprintf(dblock.dbuf.gid, "%07lo", gid); 4644 (void) sprintf(dblock.dbuf.uid, "%07lo", uid); 4645 (void) sprintf(dblock.dbuf.mode, "%07lo", sp->st_mode & POSIXMODES); 4646 (void) sprintf(dblock.dbuf.mtime, "%011lo", sp->st_mtime); 4647 } 4648 4649 static int 4650 #ifdef EUC 4651 /* 4652 * Warning: the result of this function depends whether 'char' is a 4653 * signed or unsigned data type. This a source of potential 4654 * non-portability among heterogeneous systems. It is retained here 4655 * for backward compatibility. 4656 */ 4657 checksum_signed(union hblock *dblockp) 4658 #else 4659 checksum(union hblock *dblockp) 4660 #endif /* EUC */ 4661 { 4662 int i; 4663 char *cp; 4664 4665 for (cp = dblockp->dbuf.chksum; 4666 cp < &dblockp->dbuf.chksum[sizeof (dblockp->dbuf.chksum)]; cp++) 4667 *cp = ' '; 4668 i = 0; 4669 for (cp = dblockp->dummy; cp < &(dblockp->dummy[TBLOCK]); cp++) 4670 i += *cp; 4671 return (i); 4672 } 4673 4674 #ifdef EUC 4675 /* 4676 * Generate unsigned checksum, regardless of what C compiler is 4677 * used. Survives in the face of arbitrary 8-bit clean filenames, 4678 * e.g., internationalized filenames. 4679 */ 4680 static int 4681 checksum(union hblock *dblockp) 4682 { 4683 unsigned i; 4684 unsigned char *cp; 4685 4686 for (cp = (unsigned char *) dblockp->dbuf.chksum; 4687 cp < (unsigned char *) 4688 &(dblockp->dbuf.chksum[sizeof (dblockp->dbuf.chksum)]); cp++) 4689 *cp = ' '; 4690 i = 0; 4691 for (cp = (unsigned char *) dblockp->dummy; 4692 cp < (unsigned char *) &(dblockp->dummy[TBLOCK]); cp++) 4693 i += *cp; 4694 4695 return (i); 4696 } 4697 #endif /* EUC */ 4698 4699 /* 4700 * If the w flag is set, output the action to be taken and the name of the 4701 * file. Perform the action if the user response is affirmative. 4702 */ 4703 4704 static int 4705 checkw(char c, char *name) 4706 { 4707 if (wflag) { 4708 (void) fprintf(vfile, "%c ", c); 4709 if (vflag) 4710 longt(&stbuf, ' '); /* do we have acl info here */ 4711 (void) fprintf(vfile, "%s: ", name); 4712 if (yes() == 1) { 4713 return (1); 4714 } 4715 return (0); 4716 } 4717 return (1); 4718 } 4719 4720 /* 4721 * When the F flag is set, exclude RCS and SCCS directories (and any files 4722 * or directories under them). If F is set twice, also exclude .o files, 4723 * and files names errs, core, and a.out. 4724 * 4725 * Return 0 if file should be excluded, 1 otherwise. 4726 */ 4727 4728 static int 4729 checkf(char *longname, int is_dir, int howmuch) 4730 { 4731 static char fullname[PATH_MAX + 1]; 4732 char *dir, *name; 4733 4734 #if defined(O_XATTR) 4735 /* 4736 * If there is an xattr_buf structure associated with this file, 4737 * always return 1. 4738 */ 4739 if (xattrp) { 4740 return (1); 4741 } 4742 #endif 4743 4744 /* 4745 * First check to see if the base name is an RCS or SCCS directory. 4746 */ 4747 if (strlcpy(fullname, longname, sizeof (fullname)) >= sizeof (fullname)) 4748 return (1); 4749 4750 name = basename(fullname); 4751 if (is_dir) { 4752 if ((strcmp(name, "SCCS") == 0) || (strcmp(name, "RCS") == 0)) 4753 return (0); 4754 } 4755 4756 /* 4757 * If two -F command line options were given then exclude .o files, 4758 * and files named errs, core, and a.out. 4759 */ 4760 if (howmuch > 1 && !is_dir) { 4761 size_t l = strlen(name); 4762 4763 if (l >= 3 && name[l - 2] == '.' && name[l - 1] == 'o') 4764 return (0); 4765 if (strcmp(name, "core") == 0 || strcmp(name, "errs") == 0 || 4766 strcmp(name, "a.out") == 0) 4767 return (0); 4768 } 4769 4770 /* 4771 * At this point, check to see if this file has a parent directory 4772 * named RCS or SCCS. If so, then this file should be excluded too. 4773 * The strcpy() operation is done again, because basename(3C) may 4774 * modify the path string passed to it. 4775 */ 4776 if (strlcpy(fullname, longname, sizeof (fullname)) >= sizeof (fullname)) 4777 return (1); 4778 4779 dir = dirname(fullname); 4780 while (strcmp(dir, ".") != 0) { 4781 name = basename(dir); 4782 if ((strcmp(name, "SCCS") == 0) || (strcmp(name, "RCS") == 0)) 4783 return (0); 4784 dir = dirname(dir); 4785 } 4786 4787 return (1); 4788 } 4789 4790 static int 4791 response(void) 4792 { 4793 int c; 4794 4795 c = getchar(); 4796 if (c != '\n') 4797 while (getchar() != '\n') 4798 ; 4799 else c = 'n'; 4800 return ((c >= 'A' && c <= 'Z') ? c + ('a'-'A') : c); 4801 } 4802 4803 /* Has file been modified since being put into archive? If so, return > 0. */ 4804 4805 static off_t lookup(char *); 4806 4807 static int 4808 checkupdate(char *arg) 4809 { 4810 char name[PATH_MAX+1]; 4811 time_t mtime; 4812 long nsecs; 4813 off_t seekp; 4814 4815 rewind(tfile); 4816 if ((seekp = lookup(arg)) < 0) 4817 return (1); 4818 (void) fseek(tfile, seekp, 0); 4819 (void) fscanf(tfile, "%s %ld.%ld", name, &mtime, &nsecs); 4820 4821 /* 4822 * Unless nanoseconds were stored in the file, only use seconds for 4823 * comparison of time. Nanoseconds are stored when -E is specified. 4824 */ 4825 if (Eflag == 0) 4826 return (stbuf.st_mtime > mtime); 4827 4828 if ((stbuf.st_mtime < mtime) || 4829 ((stbuf.st_mtime == mtime) && (stbuf.st_mtim.tv_nsec <= nsecs))) 4830 return (0); 4831 return (1); 4832 } 4833 4834 4835 /* 4836 * newvol get new floppy (or tape) volume 4837 * 4838 * newvol(); resets tapepos and first to TRUE, prompts for 4839 * for new volume, and waits. 4840 * if dumping, end-of-file is written onto the tape. 4841 */ 4842 4843 static void 4844 newvol(void) 4845 { 4846 int c; 4847 4848 if (dumping) { 4849 dlog("newvol called with 'dumping' set\n"); 4850 putempty((blkcnt_t)2); /* 2 EOT marks */ 4851 closevol(); 4852 flushtape(); 4853 sync(); 4854 tapepos = 0; 4855 } else 4856 first = TRUE; 4857 if (close(mt) != 0) 4858 vperror(2, gettext("close error")); 4859 mt = 0; 4860 (void) fprintf(stderr, gettext( 4861 "tar: \007please insert new volume, then press RETURN.")); 4862 (void) fseek(stdin, (off_t)0, 2); /* scan over read-ahead */ 4863 while ((c = getchar()) != '\n' && ! term) 4864 if (c == EOF) 4865 done(Errflg); 4866 if (term) 4867 done(Errflg); 4868 4869 errno = 0; 4870 4871 if (strcmp(usefile, "-") == 0) { 4872 mt = dup(1); 4873 } else { 4874 mt = open(usefile, dumping ? update : 0); 4875 } 4876 4877 if (mt < 0) { 4878 (void) fprintf(stderr, gettext( 4879 "tar: cannot reopen %s (%s)\n"), 4880 dumping ? gettext("output") : gettext("input"), usefile); 4881 4882 dlog("update=%d, usefile=%s ", update, usefile); 4883 dlog("mt=%d, [%s]\n", mt, strerror(errno)); 4884 4885 done(2); 4886 } 4887 } 4888 4889 /* 4890 * Write a trailer portion to close out the current output volume. 4891 */ 4892 4893 static void 4894 closevol(void) 4895 { 4896 if (mulvol) { 4897 /* 4898 * blocklim does not count the 2 EOT marks; 4899 * tapepos does count the 2 EOT marks; 4900 * therefore we need the +2 below. 4901 */ 4902 putempty(blocklim + (blkcnt_t)2 - tapepos); 4903 } 4904 } 4905 4906 static void 4907 done(int n) 4908 { 4909 /* 4910 * If we were terminated in some way, and we would otherwise have 4911 * exited with a value of 0, adjust to 1, so that external callers 4912 * can determine this by looking at the exit status. 4913 */ 4914 if (term && n == 0) 4915 n = 1; 4916 4917 if (tfile != NULL) 4918 (void) unlink(tname); 4919 if (compress_opt != NULL) 4920 (void) free(compress_opt); 4921 if (mt > 0) { 4922 if ((close(mt) != 0) || (fclose(stdout) != 0)) { 4923 perror(gettext("tar: close error")); 4924 exit(2); 4925 } 4926 } 4927 /* 4928 * If we have a compression child, we should have a child process that 4929 * we're waiting for to finish compressing or uncompressing the tar 4930 * stream. 4931 */ 4932 if (comp_pid != 0) 4933 wait_pid(comp_pid); 4934 exit(n); 4935 } 4936 4937 /* 4938 * Determine if s1 is a prefix portion of s2 (or the same as s2). 4939 */ 4940 4941 static int 4942 is_prefix(char *s1, char *s2) 4943 { 4944 while (*s1) 4945 if (*s1++ != *s2++) 4946 return (0); 4947 if (*s2) 4948 return (*s2 == '/'); 4949 return (1); 4950 } 4951 4952 /* 4953 * lookup and bsrch look through tfile entries to find a match for a name. 4954 * The name can be up to PATH_MAX bytes. bsrch compares what it sees between 4955 * a pair of newline chars, so the buffer it uses must be long enough for 4956 * two lines: name and modification time as well as period, newline and space. 4957 * 4958 * A kludge was added to bsrch to take care of matching on the first entry 4959 * in the file--there is no leading newline. So, if we are reading from the 4960 * start of the file, read into byte two and set the first byte to a newline. 4961 * Otherwise, the first entry cannot be matched. 4962 * 4963 */ 4964 4965 #define N (2 * (PATH_MAX + TIME_MAX_DIGITS + LONG_MAX_DIGITS + 3)) 4966 static off_t 4967 lookup(char *s) 4968 { 4969 int i; 4970 off_t a; 4971 4972 for (i = 0; s[i]; i++) 4973 if (s[i] == ' ') 4974 break; 4975 a = bsrch(s, i, low, high); 4976 return (a); 4977 } 4978 4979 static off_t 4980 bsrch(char *s, int n, off_t l, off_t h) 4981 { 4982 int i, j; 4983 char b[N]; 4984 off_t m, m1; 4985 4986 4987 loop: 4988 if (l >= h) 4989 return ((off_t)-1); 4990 m = l + (h-l)/2 - N/2; 4991 if (m < l) 4992 m = l; 4993 (void) fseek(tfile, m, 0); 4994 if (m == 0) { 4995 (void) fread(b+1, 1, N-1, tfile); 4996 b[0] = '\n'; 4997 m--; 4998 } else 4999 (void) fread(b, 1, N, tfile); 5000 for (i = 0; i < N; i++) { 5001 if (b[i] == '\n') 5002 break; 5003 m++; 5004 } 5005 if (m >= h) 5006 return ((off_t)-1); 5007 m1 = m; 5008 j = i; 5009 for (i++; i < N; i++) { 5010 m1++; 5011 if (b[i] == '\n') 5012 break; 5013 } 5014 i = cmp(b+j, s, n); 5015 if (i < 0) { 5016 h = m; 5017 goto loop; 5018 } 5019 if (i > 0) { 5020 l = m1; 5021 goto loop; 5022 } 5023 if (m < 0) 5024 m = 0; 5025 return (m); 5026 } 5027 5028 static int 5029 cmp(char *b, char *s, int n) 5030 { 5031 int i; 5032 5033 assert(b[0] == '\n'); 5034 5035 for (i = 0; i < n; i++) { 5036 if (b[i+1] > s[i]) 5037 return (-1); 5038 if (b[i+1] < s[i]) 5039 return (1); 5040 } 5041 return (b[i+1] == ' '? 0 : -1); 5042 } 5043 5044 5045 /* 5046 * seekdisk seek to next file on archive 5047 * 5048 * called by passtape() only 5049 * 5050 * WARNING: expects "nblock" to be set, that is, readtape() to have 5051 * already been called. Since passtape() is only called 5052 * after a file header block has been read (why else would 5053 * we skip to next file?), this is currently safe. 5054 * 5055 * changed to guarantee SYS_BLOCK boundary 5056 */ 5057 5058 static void 5059 seekdisk(blkcnt_t blocks) 5060 { 5061 off_t seekval; 5062 #if SYS_BLOCK > TBLOCK 5063 /* handle non-multiple of SYS_BLOCK */ 5064 blkcnt_t nxb; /* # extra blocks */ 5065 #endif 5066 5067 tapepos += blocks; 5068 dlog("seekdisk(%" FMT_blkcnt_t ") called\n", blocks); 5069 if (recno + blocks <= nblock) { 5070 recno += blocks; 5071 return; 5072 } 5073 if (recno > nblock) 5074 recno = nblock; 5075 seekval = (off_t)blocks - (nblock - recno); 5076 recno = nblock; /* so readtape() reads next time through */ 5077 #if SYS_BLOCK > TBLOCK 5078 nxb = (blkcnt_t)(seekval % (off_t)(SYS_BLOCK / TBLOCK)); 5079 dlog("xtrablks=%" FMT_blkcnt_t " seekval=%" FMT_blkcnt_t " blks\n", 5080 nxb, seekval); 5081 if (nxb && nxb > seekval) /* don't seek--we'll read */ 5082 goto noseek; 5083 seekval -= nxb; /* don't seek quite so far */ 5084 #endif 5085 if (lseek(mt, (off_t)(TBLOCK * seekval), 1) == (off_t)-1) { 5086 (void) fprintf(stderr, gettext( 5087 "tar: device seek error\n")); 5088 done(3); 5089 } 5090 #if SYS_BLOCK > TBLOCK 5091 /* read those extra blocks */ 5092 noseek: 5093 if (nxb) { 5094 dlog("reading extra blocks\n"); 5095 if (read(mt, tbuf, TBLOCK*nblock) < 0) { 5096 (void) fprintf(stderr, gettext( 5097 "tar: read error while skipping file\n")); 5098 done(8); 5099 } 5100 recno = nxb; /* so we don't read in next readtape() */ 5101 } 5102 #endif 5103 } 5104 5105 static void 5106 readtape(char *buffer) 5107 { 5108 int i, j; 5109 5110 ++tapepos; 5111 if (recno >= nblock || first) { 5112 if (first) { 5113 /* 5114 * set the number of blocks to read initially, based on 5115 * the defined defaults for the device, or on the 5116 * explicit block factor given. 5117 */ 5118 if (bflag || defaults_used || NotTape) 5119 j = nblock; 5120 else 5121 j = NBLOCK; 5122 } else 5123 j = nblock; 5124 5125 if ((i = read(mt, tbuf, TBLOCK*j)) < 0) { 5126 (void) fprintf(stderr, gettext( 5127 "tar: tape read error\n")); 5128 done(3); 5129 /* 5130 * i == 0 and !rflag means that EOF is reached and we are 5131 * trying to update or replace an empty tar file, so exit 5132 * with an error. 5133 * 5134 * If i == 0 and !first and NotTape, it means the pointer 5135 * has gone past the EOF. It could happen if two processes 5136 * try to update the same tar file simultaneously. So exit 5137 * with an error. 5138 */ 5139 5140 } else if (i == 0) { 5141 if (first && !rflag) { 5142 (void) fprintf(stderr, gettext( 5143 "tar: blocksize = %d\n"), i); 5144 done(Errflg); 5145 } else if (!first && (!rflag || NotTape)) { 5146 mterr("read", 0, 2); 5147 } 5148 } else if ((!first || Bflag) && i != TBLOCK*j) { 5149 /* 5150 * Short read - try to get the remaining bytes. 5151 */ 5152 5153 int remaining = (TBLOCK * j) - i; 5154 char *b = (char *)tbuf + i; 5155 int r; 5156 5157 do { 5158 if ((r = read(mt, b, remaining)) < 0) { 5159 (void) fprintf(stderr, 5160 gettext("tar: tape read error\n")); 5161 done(3); 5162 } 5163 b += r; 5164 remaining -= r; 5165 i += r; 5166 } while (remaining > 0 && r != 0); 5167 } 5168 if (first) { 5169 if ((i % TBLOCK) != 0) { 5170 (void) fprintf(stderr, gettext( 5171 "tar: tape blocksize error\n")); 5172 done(3); 5173 } 5174 i /= TBLOCK; 5175 if (vflag && i != nblock && i != 1) { 5176 if (!NotTape) 5177 (void) fprintf(stderr, gettext( 5178 "tar: blocksize = %d\n"), i); 5179 } 5180 5181 /* 5182 * If we are reading a tape, then a short read is 5183 * understood to signify that the amount read is 5184 * the tape's actual blocking factor. We adapt 5185 * nblock accordingly. There is no reason to do 5186 * this when the device is not blocked. 5187 */ 5188 5189 if (!NotTape) 5190 nblock = i; 5191 } 5192 recno = 0; 5193 } 5194 5195 first = FALSE; 5196 copy(buffer, &tbuf[recno++]); 5197 } 5198 5199 5200 /* 5201 * replacement for writetape. 5202 */ 5203 5204 static int 5205 writetbuf(char *buffer, int n) 5206 { 5207 int i; 5208 5209 tapepos += n; /* output block count */ 5210 5211 if (recno >= nblock) { 5212 i = write(mt, (char *)tbuf, TBLOCK*nblock); 5213 if (i != TBLOCK*nblock) 5214 mterr("write", i, 2); 5215 recno = 0; 5216 } 5217 5218 /* 5219 * Special case: We have an empty tape buffer, and the 5220 * users data size is >= the tape block size: Avoid 5221 * the bcopy and dma direct to tape. BIG WIN. Add the 5222 * residual to the tape buffer. 5223 */ 5224 while (recno == 0 && n >= nblock) { 5225 i = (int)write(mt, buffer, TBLOCK*nblock); 5226 if (i != TBLOCK*nblock) 5227 mterr("write", i, 2); 5228 n -= nblock; 5229 buffer += (nblock * TBLOCK); 5230 } 5231 5232 while (n-- > 0) { 5233 (void) memcpy((char *)&tbuf[recno++], buffer, TBLOCK); 5234 buffer += TBLOCK; 5235 if (recno >= nblock) { 5236 i = (int)write(mt, (char *)tbuf, TBLOCK*nblock); 5237 if (i != TBLOCK*nblock) 5238 mterr("write", i, 2); 5239 recno = 0; 5240 } 5241 } 5242 5243 /* Tell the user how much to write to get in sync */ 5244 return (nblock - recno); 5245 } 5246 5247 /* 5248 * backtape - reposition tape after reading soft "EOF" record 5249 * 5250 * Backtape tries to reposition the tape back over the EOF 5251 * record. This is for the 'u' and 'r' function letters so that the 5252 * tape can be extended. This code is not well designed, but 5253 * I'm confident that the only callers who care about the 5254 * backspace-over-EOF feature are those involved in 'u' and 'r'. 5255 * 5256 * The proper way to backup the tape is through the use of mtio. 5257 * Earlier spins used lseek combined with reads in a confusing 5258 * maneuver that only worked on 4.x, but shouldn't have, even 5259 * there. Lseeks are explicitly not supported for tape devices. 5260 */ 5261 5262 static void 5263 backtape(void) 5264 { 5265 struct mtop mtcmd; 5266 dlog("backtape() called, recno=%" FMT_blkcnt_t " nblock=%d\n", recno, 5267 nblock); 5268 /* 5269 * Backup to the position in the archive where the record 5270 * currently sitting in the tbuf buffer is situated. 5271 */ 5272 5273 if (NotTape) { 5274 /* 5275 * For non-tape devices, this means lseeking to the 5276 * correct position. The absolute location tapepos-recno 5277 * should be the beginning of the current record. 5278 */ 5279 5280 if (lseek(mt, (off_t)(TBLOCK*(tapepos-recno)), SEEK_SET) == 5281 (off_t)-1) { 5282 (void) fprintf(stderr, 5283 gettext("tar: lseek to end of archive failed\n")); 5284 done(4); 5285 } 5286 } else { 5287 /* 5288 * For tape devices, we backup over the most recently 5289 * read record. 5290 */ 5291 5292 mtcmd.mt_op = MTBSR; 5293 mtcmd.mt_count = 1; 5294 5295 if (ioctl(mt, MTIOCTOP, &mtcmd) < 0) { 5296 (void) fprintf(stderr, 5297 gettext("tar: backspace over record failed\n")); 5298 done(4); 5299 } 5300 } 5301 5302 /* 5303 * Decrement the tape and tbuf buffer indices to prepare for the 5304 * coming write to overwrite the soft EOF record. 5305 */ 5306 5307 recno--; 5308 tapepos--; 5309 } 5310 5311 5312 /* 5313 * flushtape write buffered block(s) onto tape 5314 * 5315 * recno points to next free block in tbuf. If nonzero, a write is done. 5316 * Care is taken to write in multiples of SYS_BLOCK when device is 5317 * non-magtape in case raw i/o is used. 5318 * 5319 * NOTE: this is called by writetape() to do the actual writing 5320 */ 5321 5322 static void 5323 flushtape(void) 5324 { 5325 dlog("flushtape() called, recno=%" FMT_blkcnt_t "\n", recno); 5326 if (recno > 0) { /* anything buffered? */ 5327 if (NotTape) { 5328 #if SYS_BLOCK > TBLOCK 5329 int i; 5330 5331 /* 5332 * an odd-block write can only happen when 5333 * we are at the end of a volume that is not a tape. 5334 * Here we round recno up to an even SYS_BLOCK 5335 * boundary. 5336 */ 5337 if ((i = recno % (SYS_BLOCK / TBLOCK)) != 0) { 5338 dlog("flushtape() %d rounding blocks\n", i); 5339 recno += i; /* round up to even SYS_BLOCK */ 5340 } 5341 #endif 5342 if (recno > nblock) 5343 recno = nblock; 5344 } 5345 dlog("writing out %" FMT_blkcnt_t " blocks of %" FMT_blkcnt_t 5346 " bytes\n", (blkcnt_t)(NotTape ? recno : nblock), 5347 (blkcnt_t)(NotTape ? recno : nblock) * TBLOCK); 5348 if (write(mt, tbuf, 5349 (size_t)(NotTape ? recno : nblock) * TBLOCK) < 0) { 5350 (void) fprintf(stderr, gettext( 5351 "tar: tape write error\n")); 5352 done(2); 5353 } 5354 recno = 0; 5355 } 5356 } 5357 5358 static void 5359 copy(void *dst, void *src) 5360 { 5361 (void) memcpy(dst, src, TBLOCK); 5362 } 5363 5364 /* 5365 * kcheck() 5366 * - checks the validity of size values for non-tape devices 5367 * - if size is zero, mulvol tar is disabled and size is 5368 * assumed to be infinite. 5369 * - returns volume size in TBLOCKS 5370 */ 5371 5372 static blkcnt_t 5373 kcheck(char *kstr) 5374 { 5375 blkcnt_t kval; 5376 5377 kval = strtoll(kstr, NULL, 0); 5378 if (kval == (blkcnt_t)0) { /* no multi-volume; size is infinity. */ 5379 mulvol = 0; /* definitely not mulvol, but we must */ 5380 return (0); /* took out setting of NotTape */ 5381 } 5382 if (kval < (blkcnt_t)MINSIZE) { 5383 (void) fprintf(stderr, gettext( 5384 "tar: sizes below %luK not supported (%" FMT_blkcnt_t 5385 ").\n"), (ulong_t)MINSIZE, kval); 5386 (void) fprintf(stderr, gettext( 5387 "bad size entry for %s in %s.\n"), 5388 archive, DEF_FILE); 5389 done(1); 5390 } 5391 mulvol++; 5392 NotTape++; /* implies non-tape */ 5393 return (kval * 1024 / TBLOCK); /* convert to TBLOCKS */ 5394 } 5395 5396 5397 /* 5398 * bcheck() 5399 * - checks the validity of blocking factors 5400 * - returns blocking factor 5401 */ 5402 5403 static int 5404 bcheck(char *bstr) 5405 { 5406 blkcnt_t bval; 5407 5408 bval = strtoll(bstr, NULL, 0); 5409 if ((bval <= 0) || (bval > INT_MAX / TBLOCK)) { 5410 (void) fprintf(stderr, gettext( 5411 "tar: invalid blocksize \"%s\".\n"), bstr); 5412 if (!bflag) 5413 (void) fprintf(stderr, gettext( 5414 "bad blocksize entry for '%s' in %s.\n"), 5415 archive, DEF_FILE); 5416 done(1); 5417 } 5418 5419 return ((int)bval); 5420 } 5421 5422 5423 /* 5424 * defset() 5425 * - reads DEF_FILE for the set of default values specified. 5426 * - initializes 'usefile', 'nblock', and 'blocklim', and 'NotTape'. 5427 * - 'usefile' points to static data, so will be overwritten 5428 * if this routine is called a second time. 5429 * - the pattern specified by 'arch' must be followed by four 5430 * blank-separated fields (1) device (2) blocking, 5431 * (3) size(K), and (4) tape 5432 * for example: archive0=/dev/fd 1 400 n 5433 */ 5434 5435 static int 5436 defset(char *arch) 5437 { 5438 char *bp; 5439 5440 if (defopen(DEF_FILE) != 0) 5441 return (FALSE); 5442 if (defcntl(DC_SETFLAGS, (DC_STD & ~(DC_CASE))) == -1) { 5443 (void) fprintf(stderr, gettext( 5444 "tar: error setting parameters for %s.\n"), DEF_FILE); 5445 return (FALSE); /* & following ones too */ 5446 } 5447 if ((bp = defread(arch)) == NULL) { 5448 (void) fprintf(stderr, gettext( 5449 "tar: missing or invalid '%s' entry in %s.\n"), 5450 arch, DEF_FILE); 5451 return (FALSE); 5452 } 5453 if ((usefile = strtok(bp, " \t")) == NULL) { 5454 (void) fprintf(stderr, gettext( 5455 "tar: '%s' entry in %s is empty!\n"), arch, DEF_FILE); 5456 return (FALSE); 5457 } 5458 if ((bp = strtok(NULL, " \t")) == NULL) { 5459 (void) fprintf(stderr, gettext( 5460 "tar: block component missing in '%s' entry in %s.\n"), 5461 arch, DEF_FILE); 5462 return (FALSE); 5463 } 5464 nblock = bcheck(bp); 5465 if ((bp = strtok(NULL, " \t")) == NULL) { 5466 (void) fprintf(stderr, gettext( 5467 "tar: size component missing in '%s' entry in %s.\n"), 5468 arch, DEF_FILE); 5469 return (FALSE); 5470 } 5471 blocklim = kcheck(bp); 5472 if ((bp = strtok(NULL, " \t")) != NULL) 5473 NotTape = (*bp == 'n' || *bp == 'N'); 5474 else 5475 NotTape = (blocklim != 0); 5476 (void) defopen(NULL); 5477 dlog("defset: archive='%s'; usefile='%s'\n", arch, usefile); 5478 dlog("defset: nblock='%d'; blocklim='%" FMT_blkcnt_t "'\n", 5479 nblock, blocklim); 5480 dlog("defset: not tape = %d\n", NotTape); 5481 return (TRUE); 5482 } 5483 5484 5485 /* 5486 * Following code handles excluded and included files. 5487 * A hash table of file names to be {in,ex}cluded is built. 5488 * For excluded files, before writing or extracting a file 5489 * check to see if it is in the exclude_tbl. 5490 * For included files, the wantit() procedure will check to 5491 * see if the named file is in the include_tbl. 5492 */ 5493 5494 static void 5495 build_table(file_list_t *table[], char *file) 5496 { 5497 FILE *fp; 5498 char buf[PATH_MAX + 1]; 5499 5500 if ((fp = fopen(file, "r")) == (FILE *)NULL) 5501 vperror(1, gettext("could not open %s"), file); 5502 while (fgets(buf, sizeof (buf), fp) != NULL) { 5503 if (buf[strlen(buf) - 1] == '\n') 5504 buf[strlen(buf) - 1] = '\0'; 5505 /* Only add to table if line has something in it */ 5506 if (strspn(buf, " \t") != strlen(buf)) 5507 add_file_to_table(table, buf); 5508 } 5509 (void) fclose(fp); 5510 } 5511 5512 5513 /* 5514 * Add a file name to the the specified table, if the file name has any 5515 * trailing '/'s then delete them before inserting into the table 5516 */ 5517 5518 static void 5519 add_file_to_table(file_list_t *table[], char *str) 5520 { 5521 char name[PATH_MAX + 1]; 5522 unsigned int h; 5523 file_list_t *exp; 5524 5525 (void) strcpy(name, str); 5526 while (name[strlen(name) - 1] == '/') { 5527 name[strlen(name) - 1] = NULL; 5528 } 5529 5530 h = hash(name); 5531 if ((exp = (file_list_t *)calloc(sizeof (file_list_t), 5532 sizeof (char))) == NULL) { 5533 (void) fprintf(stderr, gettext( 5534 "tar: out of memory, exclude/include table(entry)\n")); 5535 exit(1); 5536 } 5537 5538 if ((exp->name = strdup(name)) == NULL) { 5539 (void) fprintf(stderr, gettext( 5540 "tar: out of memory, exclude/include table(file name)\n")); 5541 exit(1); 5542 } 5543 5544 exp->next = table[h]; 5545 table[h] = exp; 5546 } 5547 5548 5549 /* 5550 * See if a file name or any of the file's parent directories is in the 5551 * specified table, if the file name has any trailing '/'s then delete 5552 * them before searching the table 5553 */ 5554 5555 static int 5556 is_in_table(file_list_t *table[], char *str) 5557 { 5558 char name[PATH_MAX + 1]; 5559 unsigned int h; 5560 file_list_t *exp; 5561 char *ptr; 5562 5563 (void) strcpy(name, str); 5564 while (name[strlen(name) - 1] == '/') { 5565 name[strlen(name) - 1] = NULL; 5566 } 5567 5568 /* 5569 * check for the file name in the passed list 5570 */ 5571 h = hash(name); 5572 exp = table[h]; 5573 while (exp != NULL) { 5574 if (strcmp(name, exp->name) == 0) { 5575 return (1); 5576 } 5577 exp = exp->next; 5578 } 5579 5580 /* 5581 * check for any parent directories in the file list 5582 */ 5583 while ((ptr = strrchr(name, '/'))) { 5584 *ptr = NULL; 5585 h = hash(name); 5586 exp = table[h]; 5587 while (exp != NULL) { 5588 if (strcmp(name, exp->name) == 0) { 5589 return (1); 5590 } 5591 exp = exp->next; 5592 } 5593 } 5594 5595 return (0); 5596 } 5597 5598 5599 /* 5600 * Compute a hash from a string. 5601 */ 5602 5603 static unsigned int 5604 hash(char *str) 5605 { 5606 char *cp; 5607 unsigned int h; 5608 5609 h = 0; 5610 for (cp = str; *cp; cp++) { 5611 h += *cp; 5612 } 5613 return (h % TABLE_SIZE); 5614 } 5615 5616 static void * 5617 getmem(size_t size) 5618 { 5619 void *p = calloc((unsigned)size, sizeof (char)); 5620 5621 if (p == NULL && freemem) { 5622 (void) fprintf(stderr, gettext( 5623 "tar: out of memory, link and directory modtime " 5624 "info lost\n")); 5625 freemem = 0; 5626 if (errflag) 5627 done(1); 5628 else 5629 Errflg = 1; 5630 } 5631 return (p); 5632 } 5633 5634 /* 5635 * vperror() --variable argument perror. 5636 * Takes 3 args: exit_status, formats, args. If exit_status is 0, then 5637 * the errflag (exit on error) is checked -- if it is non-zero, tar exits 5638 * with the value of whatever "errno" is set to. If exit_status is not 5639 * zero, then tar exits with that error status. If errflag and exit_status 5640 * are both zero, the routine returns to where it was called and sets Errflg 5641 * to errno. 5642 */ 5643 5644 static void 5645 vperror(int exit_status, char *fmt, ...) 5646 { 5647 va_list ap; 5648 5649 va_start(ap, fmt); 5650 (void) fputs("tar: ", stderr); 5651 (void) vfprintf(stderr, fmt, ap); 5652 (void) fprintf(stderr, ": %s\n", strerror(errno)); 5653 va_end(ap); 5654 if (exit_status) 5655 done(exit_status); 5656 else 5657 if (errflag) 5658 done(errno); 5659 else 5660 Errflg = errno; 5661 } 5662 5663 5664 static void 5665 fatal(char *format, ...) 5666 { 5667 va_list ap; 5668 5669 va_start(ap, format); 5670 (void) fprintf(stderr, "tar: "); 5671 (void) vfprintf(stderr, format, ap); 5672 (void) fprintf(stderr, "\n"); 5673 va_end(ap); 5674 done(1); 5675 } 5676 5677 5678 /* 5679 * Check to make sure that argument is a char * ptr. 5680 * Actually, we just check to see that it is non-null. 5681 * If it is null, print out the message and call usage(), bailing out. 5682 */ 5683 5684 static void 5685 assert_string(char *s, char *msg) 5686 { 5687 if (s == NULL) { 5688 (void) fprintf(stderr, msg); 5689 usage(); 5690 } 5691 } 5692 5693 5694 static void 5695 mterr(char *operation, int i, int exitcode) 5696 { 5697 (void) fprintf(stderr, gettext( 5698 "tar: %s error: "), operation); 5699 if (i < 0) 5700 perror(""); 5701 else 5702 (void) fprintf(stderr, gettext("unexpected EOF\n")); 5703 done(exitcode); 5704 } 5705 5706 static int 5707 wantit(char *argv[], char **namep, char **dirp, char **component, 5708 attr_data_t **attrinfo) 5709 { 5710 char **cp; 5711 int gotit; /* true if we've found a match */ 5712 int ret; 5713 5714 top: 5715 if (xhdr_flgs & _X_XHDR) { 5716 xhdr_flgs = 0; 5717 } 5718 getdir(); 5719 if (Xhdrflag > 0) { 5720 ret = get_xdata(); 5721 if (ret != 0) { /* Xhdr items and regular header */ 5722 setbytes_to_skip(&stbuf, ret); 5723 passtape(); 5724 return (0); /* Error--don't want to extract */ 5725 } 5726 } 5727 5728 /* 5729 * If typeflag is not 'A' and xhdr_flgs is set, then processing 5730 * of ancillary file is either over or ancillary file 5731 * processing is not required, load info from Xtarhdr and set 5732 * _X_XHDR bit in xhdr_flgs. 5733 */ 5734 if ((dblock.dbuf.typeflag != 'A') && (xhdr_flgs != 0)) { 5735 load_info_from_xtarhdr(xhdr_flgs, &Xtarhdr); 5736 xhdr_flgs |= _X_XHDR; 5737 } 5738 5739 #if defined(O_XATTR) 5740 if (dblock.dbuf.typeflag == _XATTR_HDRTYPE && xattrbadhead == 0) { 5741 /* 5742 * Always needs to read the extended header. If atflag, saflag, 5743 * or tflag isn't set, then we'll have the correct info for 5744 * passtape() later. 5745 */ 5746 (void) read_xattr_hdr(attrinfo); 5747 goto top; 5748 } 5749 /* 5750 * Now that we've read the extended header, call passtape() 5751 * if we don't want to restore attributes or system attributes. 5752 * Don't restore the attribute if we are extracting 5753 * a file from an archive (as opposed to doing a table of 5754 * contents) and any of the following are true: 5755 * 1. neither -@ or -/ was specified. 5756 * 2. -@ was specified, -/ wasn't specified, and we're 5757 * processing a hidden attribute directory of an attribute 5758 * or we're processing a read-write system attribute file. 5759 * 3. -@ wasn't specified, -/ was specified, and the file 5760 * we're processing is not a read-write system attribute file, 5761 * or we're processing the hidden attribute directory of an 5762 * attribute. 5763 * 5764 * We always process the attributes if we're just generating 5765 * generating a table of contents, or if both -@ and -/ were 5766 * specified. 5767 */ 5768 if (xattrp != NULL) { 5769 attr_data_t *ainfo = *attrinfo; 5770 5771 if (!tflag && 5772 ((!atflag && !saflag) || 5773 (atflag && !saflag && ((ainfo->attr_parent != NULL) || 5774 ainfo->attr_rw_sysattr)) || 5775 (!atflag && saflag && ((ainfo->attr_parent != NULL) || 5776 !ainfo->attr_rw_sysattr)))) { 5777 passtape(); 5778 return (0); 5779 } 5780 } 5781 #endif 5782 5783 /* sets *namep to point at the proper name */ 5784 if (check_prefix(namep, dirp, component) != 0) { 5785 passtape(); 5786 return (0); 5787 } 5788 5789 if (endtape()) { 5790 if (Bflag) { 5791 ssize_t sz; 5792 size_t extra_blocks = 0; 5793 5794 /* 5795 * Logically at EOT - consume any extra blocks 5796 * so that write to our stdin won't fail and 5797 * emit an error message; otherwise something 5798 * like "dd if=foo.tar | (cd bar; tar xvf -)" 5799 * will produce a bogus error message from "dd". 5800 */ 5801 5802 while ((sz = read(mt, tbuf, TBLOCK*nblock)) > 0) { 5803 extra_blocks += sz; 5804 } 5805 dlog("wantit(): %d bytes of extra blocks\n", 5806 extra_blocks); 5807 } 5808 dlog("wantit(): at end of tape.\n"); 5809 return (-1); 5810 } 5811 5812 gotit = 0; 5813 5814 if ((Iflag && is_in_table(include_tbl, *namep)) || 5815 (! Iflag && *argv == NULL)) { 5816 gotit = 1; 5817 } else { 5818 for (cp = argv; *cp; cp++) { 5819 if (is_prefix(*cp, *namep)) { 5820 gotit = 1; 5821 break; 5822 } 5823 } 5824 } 5825 5826 if (! gotit) { 5827 passtape(); 5828 return (0); 5829 } 5830 5831 if (Xflag && is_in_table(exclude_tbl, *namep)) { 5832 if (vflag) { 5833 (void) fprintf(stderr, gettext("%s excluded\n"), 5834 *namep); 5835 } 5836 passtape(); 5837 return (0); 5838 } 5839 5840 return (1); 5841 } 5842 5843 5844 static void 5845 setbytes_to_skip(struct stat *st, int err) 5846 { 5847 /* 5848 * In a scenario where a typeflag 'X' was followed by 5849 * a typeflag 'A' and typeflag 'O', then the number of 5850 * bytes to skip should be the size of ancillary file, 5851 * plus the dblock for regular file, and the size 5852 * from Xtarhdr. However, if the typeflag was just 'X' 5853 * followed by typeflag 'O', then the number of bytes 5854 * to skip should be the size from Xtarhdr. 5855 */ 5856 if ((err != 0) && (dblock.dbuf.typeflag == 'A') && 5857 (xhdr_flgs & _X_SIZE)) { 5858 st->st_size += TBLOCK + Xtarhdr.x_filesz; 5859 xhdr_flgs |= _X_XHDR; 5860 } else if ((dblock.dbuf.typeflag != 'A') && 5861 (xhdr_flgs & _X_SIZE)) { 5862 st->st_size += Xtarhdr.x_filesz; 5863 xhdr_flgs |= _X_XHDR; 5864 } 5865 } 5866 5867 static int 5868 fill_in_attr_info(char *attr, char *longname, char *attrparent, int atparentfd, 5869 int rw_sysattr, attr_data_t **attrinfo) 5870 { 5871 size_t pathlen; 5872 char *tpath; 5873 char *tparent; 5874 5875 /* parent info */ 5876 if (attrparent != NULL) { 5877 if ((tparent = strdup(attrparent)) == NULL) { 5878 vperror(0, gettext( 5879 "unable to allocate memory for attribute parent " 5880 "name for %sattribute %s/%s of %s"), 5881 rw_sysattr ? gettext("system ") : "", 5882 attrparent, attr, longname); 5883 return (1); 5884 } 5885 } else { 5886 tparent = NULL; 5887 } 5888 5889 /* path info */ 5890 pathlen = strlen(attr) + 1; 5891 if (attrparent != NULL) { 5892 pathlen += strlen(attrparent) + 1; /* add 1 for '/' */ 5893 } 5894 if ((tpath = calloc(1, pathlen)) == NULL) { 5895 vperror(0, gettext( 5896 "unable to allocate memory for full " 5897 "attribute path name for %sattribute %s%s%s of %s"), 5898 rw_sysattr ? gettext("system ") : "", 5899 (attrparent == NULL) ? "" : attrparent, 5900 (attrparent == NULL) ? "" : "/", 5901 attr, longname); 5902 if (tparent != NULL) { 5903 free(tparent); 5904 } 5905 return (1); 5906 } 5907 (void) snprintf(tpath, pathlen, "%s%s%s", 5908 (attrparent == NULL) ? "" : attrparent, 5909 (attrparent == NULL) ? "" : "/", 5910 attr); 5911 5912 /* fill in the attribute info */ 5913 if (*attrinfo == NULL) { 5914 if ((*attrinfo = malloc(sizeof (attr_data_t))) == NULL) { 5915 vperror(0, gettext( 5916 "unable to allocate memory for attribute " 5917 "information for %sattribute %s%s%s of %s"), 5918 rw_sysattr ? gettext("system ") : "", 5919 (attrparent == NULL) ? "" : attrparent, 5920 (attrparent == NULL) ? "" : gettext("/"), 5921 attr, longname); 5922 if (tparent != NULL) { 5923 free(tparent); 5924 } 5925 free(tpath); 5926 return (1); 5927 } 5928 } else { 5929 if ((*attrinfo)->attr_parent != NULL) { 5930 free((*attrinfo)->attr_parent); 5931 } 5932 if ((*attrinfo)->attr_path != NULL) { 5933 free((*attrinfo)->attr_path); 5934 } 5935 /* 5936 * The parent file descriptor is passed in, so don't 5937 * close it here as it should be closed by the function 5938 * that opened it. 5939 */ 5940 } 5941 (*attrinfo)->attr_parent = tparent; 5942 (*attrinfo)->attr_path = tpath; 5943 (*attrinfo)->attr_rw_sysattr = rw_sysattr; 5944 (*attrinfo)->attr_parentfd = atparentfd; 5945 5946 return (0); 5947 } 5948 5949 /* 5950 * Test to see if name is a directory. 5951 * 5952 * Return 1 if true, 0 otherwise. 5953 */ 5954 5955 static int 5956 is_directory(char *name) 5957 { 5958 #if defined(O_XATTR) 5959 /* 5960 * If there is an xattr_buf structure associated with this file, 5961 * then the directory test is based on whether the name has a 5962 * trailing slash. 5963 */ 5964 if (xattrp) 5965 return (name[strlen(name) - 1] == '/'); 5966 #endif 5967 if (is_posix) 5968 return (dblock.dbuf.typeflag == '5'); 5969 else 5970 return (name[strlen(name) - 1] == '/'); 5971 } 5972 5973 /* 5974 * Version of chdir that handles directory pathnames of greater than PATH_MAX 5975 * length, by changing the working directory to manageable portions of the 5976 * complete directory pathname. If any of these attempts fail, then it exits 5977 * non-zero. 5978 * 5979 * If a segment (i.e. a portion of "path" between two "/"'s) of the overall 5980 * pathname is greater than PATH_MAX, then this still won't work, and this 5981 * routine will return -1 with errno set to ENAMETOOLONG. 5982 * 5983 * NOTE: this routine is semantically different to the system chdir in 5984 * that it is remotely possible for the currently working directory to be 5985 * changed to a different directory, if a chdir call fails when processing 5986 * one of the segments of a path that is greater than PATH_MAX. This isn't 5987 * a problem as this is tar's own specific version of chdir. 5988 */ 5989 5990 static int 5991 tar_chdir(const char *path) { 5992 const char *sep = "/"; 5993 char *path_copy = NULL; 5994 char *ptr = NULL; 5995 5996 /* The trivial case. */ 5997 if (chdir(path) == 0) { 5998 return (0); 5999 } 6000 if (errno == ENAMETOOLONG) { 6001 if (path[0] == '/' && chdir(sep) != 0) 6002 return (-1); 6003 6004 /* strtok(3C) modifies the string, so make a copy. */ 6005 if ((path_copy = strdup(path)) == NULL) { 6006 return (-1); 6007 } 6008 6009 /* chdir(2) for every path element. */ 6010 for (ptr = strtok(path_copy, sep); 6011 ptr != NULL; 6012 ptr = strtok(NULL, sep)) { 6013 if (chdir(ptr) != 0) { 6014 free(path_copy); 6015 return (-1); 6016 } 6017 } 6018 free(path_copy); 6019 return (0); 6020 } 6021 6022 /* If chdir fails for any reason except ENAMETOOLONG. */ 6023 return (-1); 6024 } 6025 6026 /* 6027 * Test if name has a '..' sequence in it. 6028 * 6029 * Return 1 if found, 0 otherwise. 6030 */ 6031 6032 static int 6033 has_dot_dot(char *name) 6034 { 6035 char *s; 6036 size_t name_len = strlen(name); 6037 6038 for (s = name; s < (name + name_len - 2); s++) { 6039 if (s[0] == '.' && s[1] == '.' && ((s[2] == '/') || !s[2])) 6040 return (1); 6041 6042 while (! (*s == '/')) { 6043 if (! *s++) 6044 return (0); 6045 } 6046 } 6047 6048 return (0); 6049 } 6050 6051 /* 6052 * Test if name is an absolute path name. 6053 * 6054 * Return 1 if true, 0 otherwise. 6055 */ 6056 6057 static int 6058 is_absolute(char *name) 6059 { 6060 #if defined(O_XATTR) 6061 /* 6062 * If this is an extended attribute (whose name will begin with 6063 * "/dev/null/", always return 0 as they should be extracted with 6064 * the name intact, to allow other tar archiving programs that 6065 * don't understand extended attributes, to correctly throw them away. 6066 */ 6067 if (xattrp) 6068 return (0); 6069 #endif 6070 6071 return (name[0] == '/'); 6072 } 6073 6074 /* 6075 * Adjust the pathname to make it a relative one. Strip off any leading 6076 * '/' characters and if the pathname contains any '..' sequences, strip 6077 * upto and including the last occurance of '../' (or '..' if found at 6078 * the very end of the pathname). 6079 * 6080 * Return the relative pathname. stripped_prefix will also return the 6081 * portion of name that was stripped off and should be freed by the 6082 * calling routine when no longer needed. 6083 */ 6084 6085 static char * 6086 make_relative_name(char *name, char **stripped_prefix) 6087 { 6088 char *s; 6089 size_t prefix_len = 0; 6090 size_t name_len = strlen(name); 6091 6092 for (s = name + prefix_len; s < (name + name_len - 2); ) { 6093 if (s[0] == '.' && s[1] == '.' && ((s[2] == '/') || !s[2])) 6094 prefix_len = s + 2 - name; 6095 6096 do { 6097 char c = *s++; 6098 6099 if (c == '/') 6100 break; 6101 } while (*s); 6102 } 6103 6104 for (s = name + prefix_len; *s == '/'; s++) 6105 continue; 6106 prefix_len = s - name; 6107 6108 /* Create the portion of the name that was stripped off. */ 6109 s = malloc(prefix_len + 1); 6110 memcpy(s, name, prefix_len); 6111 s[prefix_len] = 0; 6112 *stripped_prefix = s; 6113 s = &name[prefix_len]; 6114 6115 return (s); 6116 } 6117 6118 /* 6119 * Return through *namep a pointer to the proper fullname (i.e "<name> | 6120 * <prefix>/<name>"), as represented in the header entry dblock.dbuf. 6121 * 6122 * Returns 0 if successful, otherwise returns 1. 6123 */ 6124 6125 static int 6126 check_prefix(char **namep, char **dirp, char **compp) 6127 { 6128 static char fullname[PATH_MAX + 1]; 6129 static char dir[PATH_MAX + 1]; 6130 static char component[PATH_MAX + 1]; 6131 static char savename[PATH_MAX + 1]; 6132 char *s; 6133 6134 (void) memset(dir, 0, sizeof (dir)); 6135 (void) memset(component, 0, sizeof (component)); 6136 6137 if (xhdr_flgs & _X_PATH) { 6138 (void) strcpy(fullname, Xtarhdr.x_path); 6139 } else { 6140 if (dblock.dbuf.prefix[0] != '\0') 6141 (void) sprintf(fullname, "%.*s/%.*s", PRESIZ, 6142 dblock.dbuf.prefix, NAMSIZ, dblock.dbuf.name); 6143 else 6144 (void) sprintf(fullname, "%.*s", NAMSIZ, 6145 dblock.dbuf.name); 6146 } 6147 6148 /* 6149 * If we are printing a table of contents or extracting an archive, 6150 * make absolute pathnames relative and prohibit the unpacking of 6151 * files contain ".." in their name (unless the user has supplied 6152 * the -P option). 6153 */ 6154 if ((tflag || xflag) && !Pflag) { 6155 if (is_absolute(fullname) || has_dot_dot(fullname)) { 6156 char *stripped_prefix; 6157 6158 (void) strcpy(savename, fullname); 6159 strcpy(fullname, 6160 make_relative_name(savename, &stripped_prefix)); 6161 (void) fprintf(stderr, 6162 gettext("tar: Removing leading '%s' from '%s'\n"), 6163 stripped_prefix, savename); 6164 free(stripped_prefix); 6165 } 6166 } 6167 6168 /* 6169 * Set dir and component names 6170 */ 6171 6172 get_parent(fullname, dir); 6173 6174 #if defined(O_XATTR) 6175 if (xattrp == NULL) { 6176 #endif 6177 /* 6178 * Save of real name since were going to chop off the 6179 * trailing slashes. 6180 */ 6181 (void) strcpy(savename, fullname); 6182 /* 6183 * first strip of trailing slashes. 6184 */ 6185 chop_endslashes(savename); 6186 s = get_component(savename); 6187 (void) strcpy(component, s); 6188 6189 #if defined(O_XATTR) 6190 } else { 6191 (void) strcpy(fullname, xattrp->h_names); 6192 (void) strcpy(dir, fullname); 6193 (void) strcpy(component, basename(xattrp->h_names + 6194 strlen(xattrp->h_names) + 1)); 6195 } 6196 #endif 6197 *namep = fullname; 6198 *dirp = dir; 6199 *compp = component; 6200 6201 return (0); 6202 } 6203 6204 /* 6205 * Return true if the object indicated by the file descriptor and type 6206 * is a tape device, false otherwise 6207 */ 6208 6209 static int 6210 istape(int fd, int type) 6211 { 6212 int result = 0; 6213 6214 if (S_ISCHR(type)) { 6215 struct mtget mtg; 6216 6217 if (ioctl(fd, MTIOCGET, &mtg) != -1) { 6218 result = 1; 6219 } 6220 } 6221 6222 return (result); 6223 } 6224 6225 #include <utmpx.h> 6226 6227 struct utmpx utmpx; 6228 6229 #define NMAX (sizeof (utmpx.ut_name)) 6230 6231 typedef struct cachenode { /* this struct must be zeroed before using */ 6232 struct cachenode *next; /* next in hash chain */ 6233 int val; /* the uid or gid of this entry */ 6234 int namehash; /* name's hash signature */ 6235 char name[NMAX+1]; /* the string that val maps to */ 6236 } cachenode_t; 6237 6238 #define HASHSIZE 256 6239 6240 static cachenode_t *names[HASHSIZE]; 6241 static cachenode_t *groups[HASHSIZE]; 6242 static cachenode_t *uids[HASHSIZE]; 6243 static cachenode_t *gids[HASHSIZE]; 6244 6245 static int 6246 hash_byname(char *name) 6247 { 6248 int i, c, h = 0; 6249 6250 for (i = 0; i < NMAX; i++) { 6251 c = name[i]; 6252 if (c == '\0') 6253 break; 6254 h = (h << 4) + h + c; 6255 } 6256 return (h); 6257 } 6258 6259 static cachenode_t * 6260 hash_lookup_byval(cachenode_t *table[], int val) 6261 { 6262 int h = val; 6263 cachenode_t *c; 6264 6265 for (c = table[h & (HASHSIZE - 1)]; c != NULL; c = c->next) { 6266 if (c->val == val) 6267 return (c); 6268 } 6269 return (NULL); 6270 } 6271 6272 static cachenode_t * 6273 hash_lookup_byname(cachenode_t *table[], char *name) 6274 { 6275 int h = hash_byname(name); 6276 cachenode_t *c; 6277 6278 for (c = table[h & (HASHSIZE - 1)]; c != NULL; c = c->next) { 6279 if (c->namehash == h && strcmp(c->name, name) == 0) 6280 return (c); 6281 } 6282 return (NULL); 6283 } 6284 6285 static cachenode_t * 6286 hash_insert(cachenode_t *table[], char *name, int value) 6287 { 6288 cachenode_t *c; 6289 int signature; 6290 6291 c = calloc(1, sizeof (cachenode_t)); 6292 if (c == NULL) { 6293 perror("malloc"); 6294 exit(1); 6295 } 6296 if (name != NULL) { 6297 (void) strncpy(c->name, name, NMAX); 6298 c->namehash = hash_byname(name); 6299 } 6300 c->val = value; 6301 if (table == uids || table == gids) 6302 signature = c->val; 6303 else 6304 signature = c->namehash; 6305 c->next = table[signature & (HASHSIZE - 1)]; 6306 table[signature & (HASHSIZE - 1)] = c; 6307 return (c); 6308 } 6309 6310 static char * 6311 getname(uid_t uid) 6312 { 6313 cachenode_t *c; 6314 6315 if ((c = hash_lookup_byval(uids, uid)) == NULL) { 6316 struct passwd *pwent = getpwuid(uid); 6317 c = hash_insert(uids, pwent ? pwent->pw_name : NULL, uid); 6318 } 6319 return (c->name); 6320 } 6321 6322 static char * 6323 getgroup(gid_t gid) 6324 { 6325 cachenode_t *c; 6326 6327 if ((c = hash_lookup_byval(gids, gid)) == NULL) { 6328 struct group *grent = getgrgid(gid); 6329 c = hash_insert(gids, grent ? grent->gr_name : NULL, gid); 6330 } 6331 return (c->name); 6332 } 6333 6334 static uid_t 6335 getuidbyname(char *name) 6336 { 6337 cachenode_t *c; 6338 6339 if ((c = hash_lookup_byname(names, name)) == NULL) { 6340 struct passwd *pwent = getpwnam(name); 6341 c = hash_insert(names, name, pwent ? (int)pwent->pw_uid : -1); 6342 } 6343 return ((uid_t)c->val); 6344 } 6345 6346 static gid_t 6347 getgidbyname(char *group) 6348 { 6349 cachenode_t *c; 6350 6351 if ((c = hash_lookup_byname(groups, group)) == NULL) { 6352 struct group *grent = getgrnam(group); 6353 c = hash_insert(groups, group, grent ? (int)grent->gr_gid : -1); 6354 } 6355 return ((gid_t)c->val); 6356 } 6357 6358 /* 6359 * Build the header. 6360 * Determine whether or not an extended header is also needed. If needed, 6361 * create and write the extended header and its data. 6362 * Writing of the extended header assumes that "tomodes" has been called and 6363 * the relevant information has been placed in the header block. 6364 */ 6365 6366 static int 6367 build_dblock( 6368 const char *name, 6369 const char *linkname, 6370 const char typeflag, 6371 const int filetype, 6372 const struct stat *sp, 6373 const dev_t device, 6374 const char *prefix) 6375 { 6376 int nblks; 6377 major_t dev; 6378 const char *filename; 6379 const char *lastslash; 6380 6381 if (filetype == XATTR_FILE) 6382 dblock.dbuf.typeflag = _XATTR_HDRTYPE; 6383 else 6384 dblock.dbuf.typeflag = typeflag; 6385 (void) memset(dblock.dbuf.name, '\0', NAMSIZ); 6386 (void) memset(dblock.dbuf.linkname, '\0', NAMSIZ); 6387 (void) memset(dblock.dbuf.prefix, '\0', PRESIZ); 6388 6389 if (xhdr_flgs & _X_PATH) 6390 filename = Xtarhdr.x_path; 6391 else 6392 filename = name; 6393 6394 if ((dev = major(device)) > OCTAL7CHAR) { 6395 if (Eflag) { 6396 xhdr_flgs |= _X_DEVMAJOR; 6397 Xtarhdr.x_devmajor = dev; 6398 } else { 6399 (void) fprintf(stderr, gettext( 6400 "Device major too large for %s. Use -E flag."), 6401 filename); 6402 if (errflag) 6403 done(1); 6404 else 6405 Errflg = 1; 6406 } 6407 dev = 0; 6408 } 6409 (void) sprintf(dblock.dbuf.devmajor, "%07lo", dev); 6410 if ((dev = minor(device)) > OCTAL7CHAR) { 6411 if (Eflag) { 6412 xhdr_flgs |= _X_DEVMINOR; 6413 Xtarhdr.x_devminor = dev; 6414 } else { 6415 (void) fprintf(stderr, gettext( 6416 "Device minor too large for %s. Use -E flag."), 6417 filename); 6418 if (errflag) 6419 done(1); 6420 else 6421 Errflg = 1; 6422 } 6423 dev = 0; 6424 } 6425 (void) sprintf(dblock.dbuf.devminor, "%07lo", dev); 6426 6427 (void) strncpy(dblock.dbuf.name, name, NAMSIZ); 6428 (void) strncpy(dblock.dbuf.linkname, linkname, NAMSIZ); 6429 (void) sprintf(dblock.dbuf.magic, "%.5s", magic_type); 6430 (void) sprintf(dblock.dbuf.version, "00"); 6431 (void) sprintf(dblock.dbuf.uname, "%.31s", getname(sp->st_uid)); 6432 (void) sprintf(dblock.dbuf.gname, "%.31s", getgroup(sp->st_gid)); 6433 (void) strncpy(dblock.dbuf.prefix, prefix, PRESIZ); 6434 (void) sprintf(dblock.dbuf.chksum, "%07o", checksum(&dblock)); 6435 6436 if (Eflag) { 6437 (void) bcopy(dblock.dummy, xhdr_buf.dummy, TBLOCK); 6438 (void) memset(xhdr_buf.dbuf.name, '\0', NAMSIZ); 6439 lastslash = strrchr(name, '/'); 6440 if (lastslash == NULL) 6441 lastslash = name; 6442 else 6443 lastslash++; 6444 (void) strcpy(xhdr_buf.dbuf.name, lastslash); 6445 (void) memset(xhdr_buf.dbuf.linkname, '\0', NAMSIZ); 6446 (void) memset(xhdr_buf.dbuf.prefix, '\0', PRESIZ); 6447 (void) strcpy(xhdr_buf.dbuf.prefix, xhdr_dirname); 6448 xhdr_count++; 6449 xrec_offset = 0; 6450 gen_date("mtime", sp->st_mtim); 6451 xhdr_buf.dbuf.typeflag = 'X'; 6452 if (gen_utf8_names(filename) != 0) 6453 return (1); 6454 6455 #ifdef XHDR_DEBUG 6456 Xtarhdr.x_uname = dblock.dbuf.uname; 6457 Xtarhdr.x_gname = dblock.dbuf.gname; 6458 xhdr_flgs |= (_X_UNAME | _X_GNAME); 6459 #endif 6460 if (xhdr_flgs) { 6461 if (xhdr_flgs & _X_DEVMAJOR) 6462 gen_num("SUN.devmajor", Xtarhdr.x_devmajor); 6463 if (xhdr_flgs & _X_DEVMINOR) 6464 gen_num("SUN.devminor", Xtarhdr.x_devminor); 6465 if (xhdr_flgs & _X_GID) 6466 gen_num("gid", Xtarhdr.x_gid); 6467 if (xhdr_flgs & _X_UID) 6468 gen_num("uid", Xtarhdr.x_uid); 6469 if (xhdr_flgs & _X_SIZE) 6470 gen_num("size", Xtarhdr.x_filesz); 6471 if (xhdr_flgs & _X_PATH) 6472 gen_string("path", Xtarhdr.x_path); 6473 if (xhdr_flgs & _X_LINKPATH) 6474 gen_string("linkpath", Xtarhdr.x_linkpath); 6475 if (xhdr_flgs & _X_GNAME) 6476 gen_string("gname", Xtarhdr.x_gname); 6477 if (xhdr_flgs & _X_UNAME) 6478 gen_string("uname", Xtarhdr.x_uname); 6479 } 6480 (void) sprintf(xhdr_buf.dbuf.size, 6481 "%011" FMT_off_t_o, xrec_offset); 6482 (void) sprintf(xhdr_buf.dbuf.chksum, "%07o", 6483 checksum(&xhdr_buf)); 6484 (void) writetbuf((char *)&xhdr_buf, 1); 6485 nblks = TBLOCKS(xrec_offset); 6486 (void) writetbuf(xrec_ptr, nblks); 6487 } 6488 return (0); 6489 } 6490 6491 6492 /* 6493 * makeDir - ensure that a directory with the pathname denoted by name 6494 * exists, and return 1 on success, and 0 on failure (e.g., 6495 * read-only file system, exists but not-a-directory). 6496 */ 6497 6498 static int 6499 makeDir(char *name) 6500 { 6501 struct stat buf; 6502 6503 if (access(name, 0) < 0) { /* name doesn't exist */ 6504 if (mkdir(name, 0777) < 0) { 6505 vperror(0, "%s", name); 6506 return (0); 6507 } 6508 } else { /* name exists */ 6509 if (stat(name, &buf) < 0) { 6510 vperror(0, "%s", name); 6511 return (0); 6512 } 6513 6514 return ((buf.st_mode & S_IFMT) == S_IFDIR); 6515 } 6516 6517 return (1); 6518 } 6519 6520 6521 /* 6522 * Save this directory and its mtime on the stack, popping and setting 6523 * the mtimes of any stacked dirs which aren't parents of this one. 6524 * A null name causes the entire stack to be unwound and set. 6525 * 6526 * Since all the elements of the directory "stack" share a common 6527 * prefix, we can make do with one string. We keep only the current 6528 * directory path, with an associated array of mtime's. A negative 6529 * mtime means no mtime. 6530 * 6531 * This stack algorithm is not guaranteed to work for tapes created 6532 * with the 'r' function letter, but the vast majority of tapes with 6533 * directories are not. This avoids saving every directory record on 6534 * the tape and setting all the times at the end. 6535 * 6536 * (This was borrowed from the 4.1.3 source, and adapted to the 5.x 6537 * environment) 6538 */ 6539 6540 static void 6541 doDirTimes(char *name, timestruc_t modTime) 6542 { 6543 static char dirstack[PATH_MAX+2]; 6544 /* Add spaces for the last slash and last NULL */ 6545 static timestruc_t modtimes[PATH_MAX+1]; /* hash table */ 6546 char *p = dirstack; 6547 char *q = name; 6548 char *savp; 6549 6550 if (q) { 6551 /* 6552 * Find common prefix 6553 */ 6554 6555 while (*p == *q && *p) { 6556 p++; q++; 6557 } 6558 } 6559 6560 savp = p; 6561 while (*p) { 6562 /* 6563 * Not a child: unwind the stack, setting the times. 6564 * The order we do this doesn't matter, so we go "forward." 6565 */ 6566 6567 if (*p == '/') 6568 if (modtimes[p - dirstack].tv_sec >= 0) { 6569 *p = '\0'; /* zap the slash */ 6570 setPathTimes(AT_FDCWD, dirstack, 6571 modtimes[p - dirstack]); 6572 *p = '/'; 6573 } 6574 ++p; 6575 } 6576 6577 p = savp; 6578 6579 /* 6580 * Push this one on the "stack" 6581 */ 6582 6583 if (q) { 6584 6585 /* 6586 * Since the name parameter points the dir pathname 6587 * which is limited only to contain PATH_MAX chars 6588 * at maximum, we can ignore the overflow case of p. 6589 */ 6590 6591 while ((*p = *q++)) { /* append the rest of the new dir */ 6592 modtimes[p - dirstack].tv_sec = -1; 6593 p++; 6594 } 6595 6596 /* 6597 * If the tar file had used 'P' or 'E' function modifier, 6598 * append the last slash. 6599 */ 6600 if (*(p - 1) != '/') { 6601 *p++ = '/'; 6602 *p = '\0'; 6603 } 6604 /* overwrite the last one */ 6605 modtimes[p - dirstack - 1] = modTime; 6606 } 6607 } 6608 6609 6610 /* 6611 * setPathTimes - set the modification time for given path. Return 1 if 6612 * successful and 0 if not successful. 6613 */ 6614 6615 static void 6616 setPathTimes(int dirfd, char *path, timestruc_t modTime) 6617 6618 { 6619 struct timeval timebuf[2]; 6620 6621 /* 6622 * futimesat takes an array of two timeval structs. 6623 * The first entry contains access time. 6624 * The second entry contains modification time. 6625 * Unlike a timestruc_t, which uses nanoseconds, timeval uses 6626 * microseconds. 6627 */ 6628 timebuf[0].tv_sec = time((time_t *)0); 6629 timebuf[0].tv_usec = 0; 6630 timebuf[1].tv_sec = modTime.tv_sec; 6631 6632 /* Extended header: use microseconds */ 6633 timebuf[1].tv_usec = (xhdr_flgs & _X_MTIME) ? modTime.tv_nsec/1000 : 0; 6634 6635 if (futimesat(dirfd, path, timebuf) < 0) 6636 vperror(0, gettext("can't set time on %s"), path); 6637 } 6638 6639 6640 /* 6641 * If hflag is set then delete the symbolic link's target. 6642 * If !hflag then delete the target. 6643 */ 6644 6645 static void 6646 delete_target(int fd, char *comp, char *namep) 6647 { 6648 struct stat xtractbuf; 6649 char buf[PATH_MAX + 1]; 6650 int n; 6651 6652 6653 if (unlinkat(fd, comp, AT_REMOVEDIR) < 0) { 6654 if (errno == ENOTDIR && !hflag) { 6655 (void) unlinkat(fd, comp, 0); 6656 } else if (errno == ENOTDIR && hflag) { 6657 if (!lstat(namep, &xtractbuf)) { 6658 if ((xtractbuf.st_mode & S_IFMT) != S_IFLNK) { 6659 (void) unlinkat(fd, comp, 0); 6660 } else if ((n = readlink(namep, buf, 6661 PATH_MAX)) != -1) { 6662 buf[n] = (char)NULL; 6663 (void) unlinkat(fd, buf, 6664 AT_REMOVEDIR); 6665 if (errno == ENOTDIR) 6666 (void) unlinkat(fd, buf, 0); 6667 } else { 6668 (void) unlinkat(fd, comp, 0); 6669 } 6670 } else { 6671 (void) unlinkat(fd, comp, 0); 6672 } 6673 } 6674 } 6675 } 6676 6677 6678 /* 6679 * ACL changes: 6680 * putfile(): 6681 * Get acl info after stat. Write out ancillary file 6682 * before the normal file, i.e. directory, regular, FIFO, 6683 * link, special. If acl count is less than 4, no need to 6684 * create ancillary file. (i.e. standard permission is in 6685 * use. 6686 * doxtract(): 6687 * Process ancillary file. Read it in and set acl info. 6688 * watch out for 'o' function modifier. 6689 * 't' function letter to display table 6690 */ 6691 6692 /* 6693 * New functions for ACLs and other security attributes 6694 */ 6695 6696 /* 6697 * The function appends the new security attribute info to the end of 6698 * existing secinfo. 6699 */ 6700 int 6701 append_secattr( 6702 char **secinfo, /* existing security info */ 6703 int *secinfo_len, /* length of existing security info */ 6704 int size, /* new attribute size: unit depends on type */ 6705 char *attrtext, /* new attribute text */ 6706 char attr_type) /* new attribute type */ 6707 { 6708 char *new_secinfo; 6709 int newattrsize; 6710 int oldsize; 6711 struct sec_attr *attr; 6712 6713 /* no need to add */ 6714 if (attr_type != DIR_TYPE) { 6715 if (attrtext == NULL) 6716 return (0); 6717 } 6718 6719 switch (attr_type) { 6720 case UFSD_ACL: 6721 case ACE_ACL: 6722 if (attrtext == NULL) { 6723 (void) fprintf(stderr, gettext("acltotext failed\n")); 6724 return (-1); 6725 } 6726 /* header: type + size = 8 */ 6727 newattrsize = 8 + (int)strlen(attrtext) + 1; 6728 attr = (struct sec_attr *)malloc(newattrsize); 6729 if (attr == NULL) { 6730 (void) fprintf(stderr, 6731 gettext("can't allocate memory\n")); 6732 return (-1); 6733 } 6734 attr->attr_type = attr_type; 6735 (void) sprintf(attr->attr_len, 6736 "%06o", size); /* acl entry count */ 6737 (void) strcpy((char *)&attr->attr_info[0], attrtext); 6738 free(attrtext); 6739 break; 6740 6741 /* Trusted Extensions */ 6742 case DIR_TYPE: 6743 case LBL_TYPE: 6744 newattrsize = sizeof (struct sec_attr) + strlen(attrtext); 6745 attr = (struct sec_attr *)malloc(newattrsize); 6746 if (attr == NULL) { 6747 (void) fprintf(stderr, 6748 gettext("can't allocate memory\n")); 6749 return (-1); 6750 } 6751 attr->attr_type = attr_type; 6752 (void) sprintf(attr->attr_len, 6753 "%06d", size); /* len of attr data */ 6754 (void) strcpy((char *)&attr->attr_info[0], attrtext); 6755 break; 6756 6757 default: 6758 (void) fprintf(stderr, 6759 gettext("unrecognized attribute type\n")); 6760 return (-1); 6761 } 6762 6763 /* old security info + new attr header(8) + new attr */ 6764 oldsize = *secinfo_len; 6765 *secinfo_len += newattrsize; 6766 new_secinfo = (char *)malloc(*secinfo_len); 6767 if (new_secinfo == NULL) { 6768 (void) fprintf(stderr, gettext("can't allocate memory\n")); 6769 *secinfo_len -= newattrsize; 6770 free(attr); 6771 return (-1); 6772 } 6773 6774 (void) memcpy(new_secinfo, *secinfo, oldsize); 6775 (void) memcpy(new_secinfo + oldsize, attr, newattrsize); 6776 6777 free(*secinfo); 6778 free(attr); 6779 *secinfo = new_secinfo; 6780 return (0); 6781 } 6782 6783 /* 6784 * write_ancillary(): write out an ancillary file. 6785 * The file has the same header as normal file except the type and size 6786 * fields. The type is 'A' and size is the sum of all attributes 6787 * in bytes. 6788 * The body contains a list of attribute type, size and info. Currently, 6789 * there is only ACL info. This file is put before the normal file. 6790 */ 6791 void 6792 write_ancillary(union hblock *dblockp, char *secinfo, int len, char hdrtype) 6793 { 6794 long blocks; 6795 int savflag; 6796 int savsize; 6797 6798 /* Just tranditional permissions or no security attribute info */ 6799 if (len == 0 || secinfo == NULL) 6800 return; 6801 6802 /* save flag and size */ 6803 savflag = (dblockp->dbuf).typeflag; 6804 (void) sscanf(dblockp->dbuf.size, "%12o", (uint_t *)&savsize); 6805 6806 /* special flag for ancillary file */ 6807 if (hdrtype == _XATTR_HDRTYPE) 6808 dblockp->dbuf.typeflag = _XATTR_HDRTYPE; 6809 else 6810 dblockp->dbuf.typeflag = 'A'; 6811 6812 /* for pre-2.5 versions of tar, need to make sure */ 6813 /* the ACL file is readable */ 6814 (void) sprintf(dblock.dbuf.mode, "%07lo", 6815 (stbuf.st_mode & POSIXMODES) | 0000200); 6816 (void) sprintf(dblockp->dbuf.size, "%011o", len); 6817 (void) sprintf(dblockp->dbuf.chksum, "%07o", checksum(dblockp)); 6818 6819 /* write out the header */ 6820 (void) writetbuf((char *)dblockp, 1); 6821 6822 /* write out security info */ 6823 blocks = TBLOCKS(len); 6824 (void) writetbuf((char *)secinfo, (int)blocks); 6825 6826 /* restore mode, flag and size */ 6827 (void) sprintf(dblock.dbuf.mode, "%07lo", stbuf.st_mode & POSIXMODES); 6828 dblockp->dbuf.typeflag = savflag; 6829 (void) sprintf(dblockp->dbuf.size, "%011o", savsize); 6830 } 6831 6832 /* 6833 * Read the data record for extended headers and then the regular header. 6834 * The data are read into the buffer and then null-terminated. Entries 6835 * for typeflag 'X' extended headers are of the format: 6836 * "%d %s=%s\n" 6837 * 6838 * When an extended header record is found, the extended header must 6839 * be processed and its values used to override the values in the 6840 * normal header. The way this is done is to process the extended 6841 * header data record and set the data values, then call getdir 6842 * to process the regular header, then then to reconcile the two 6843 * sets of data. 6844 */ 6845 6846 static int 6847 get_xdata(void) 6848 { 6849 struct keylist_pair { 6850 int keynum; 6851 char *keylist; 6852 } keylist_pair[] = { _X_DEVMAJOR, "SUN.devmajor", 6853 _X_DEVMINOR, "SUN.devminor", 6854 _X_GID, "gid", 6855 _X_GNAME, "gname", 6856 _X_LINKPATH, "linkpath", 6857 _X_PATH, "path", 6858 _X_SIZE, "size", 6859 _X_UID, "uid", 6860 _X_UNAME, "uname", 6861 _X_MTIME, "mtime", 6862 _X_LAST, "NULL" }; 6863 char *lineloc; 6864 int length, i; 6865 char *keyword, *value; 6866 blkcnt_t nblocks; 6867 int bufneeded; 6868 int errors; 6869 6870 (void) memset(&Xtarhdr, 0, sizeof (Xtarhdr)); 6871 xhdr_count++; 6872 errors = 0; 6873 6874 nblocks = TBLOCKS(stbuf.st_size); 6875 bufneeded = nblocks * TBLOCK; 6876 if (bufneeded >= xrec_size) { 6877 free(xrec_ptr); 6878 xrec_size = bufneeded + 1; 6879 if ((xrec_ptr = malloc(xrec_size)) == NULL) 6880 fatal(gettext("cannot allocate buffer")); 6881 } 6882 6883 lineloc = xrec_ptr; 6884 6885 while (nblocks-- > 0) { 6886 readtape(lineloc); 6887 lineloc += TBLOCK; 6888 } 6889 lineloc = xrec_ptr; 6890 xrec_ptr[stbuf.st_size] = '\0'; 6891 while (lineloc < xrec_ptr + stbuf.st_size) { 6892 if (dblock.dbuf.typeflag == 'L') { 6893 length = xrec_size; 6894 keyword = "path"; 6895 value = lineloc; 6896 } else { 6897 length = atoi(lineloc); 6898 *(lineloc + length - 1) = '\0'; 6899 keyword = strchr(lineloc, ' ') + 1; 6900 value = strchr(keyword, '=') + 1; 6901 *(value - 1) = '\0'; 6902 } 6903 i = 0; 6904 lineloc += length; 6905 while (keylist_pair[i].keynum != (int)_X_LAST) { 6906 if (strcmp(keyword, keylist_pair[i].keylist) == 0) 6907 break; 6908 i++; 6909 } 6910 errno = 0; 6911 switch (keylist_pair[i].keynum) { 6912 case _X_DEVMAJOR: 6913 Xtarhdr.x_devmajor = (major_t)strtoul(value, NULL, 0); 6914 if (errno) { 6915 (void) fprintf(stderr, gettext( 6916 "tar: Extended header major value error " 6917 "for file # %llu.\n"), xhdr_count); 6918 errors++; 6919 } else 6920 xhdr_flgs |= _X_DEVMAJOR; 6921 break; 6922 case _X_DEVMINOR: 6923 Xtarhdr.x_devminor = (minor_t)strtoul(value, NULL, 0); 6924 if (errno) { 6925 (void) fprintf(stderr, gettext( 6926 "tar: Extended header minor value error " 6927 "for file # %llu.\n"), xhdr_count); 6928 errors++; 6929 } else 6930 xhdr_flgs |= _X_DEVMINOR; 6931 break; 6932 case _X_GID: 6933 xhdr_flgs |= _X_GID; 6934 Xtarhdr.x_gid = strtol(value, NULL, 0); 6935 if ((errno) || (Xtarhdr.x_gid > UID_MAX)) { 6936 (void) fprintf(stderr, gettext( 6937 "tar: Extended header gid value error " 6938 "for file # %llu.\n"), xhdr_count); 6939 Xtarhdr.x_gid = GID_NOBODY; 6940 } 6941 break; 6942 case _X_GNAME: 6943 if (utf8_local("gname", &Xtarhdr.x_gname, 6944 local_gname, value, _POSIX_NAME_MAX) == 0) 6945 xhdr_flgs |= _X_GNAME; 6946 break; 6947 case _X_LINKPATH: 6948 if (utf8_local("linkpath", &Xtarhdr.x_linkpath, 6949 local_linkpath, value, PATH_MAX) == 0) 6950 xhdr_flgs |= _X_LINKPATH; 6951 else 6952 errors++; 6953 break; 6954 case _X_PATH: 6955 if (utf8_local("path", &Xtarhdr.x_path, 6956 local_path, value, PATH_MAX) == 0) 6957 xhdr_flgs |= _X_PATH; 6958 else 6959 errors++; 6960 break; 6961 case _X_SIZE: 6962 Xtarhdr.x_filesz = strtoull(value, NULL, 0); 6963 if (errno) { 6964 (void) fprintf(stderr, gettext( 6965 "tar: Extended header invalid filesize " 6966 "for file # %llu.\n"), xhdr_count); 6967 errors++; 6968 } else 6969 xhdr_flgs |= _X_SIZE; 6970 break; 6971 case _X_UID: 6972 xhdr_flgs |= _X_UID; 6973 Xtarhdr.x_uid = strtol(value, NULL, 0); 6974 if ((errno) || (Xtarhdr.x_uid > UID_MAX)) { 6975 (void) fprintf(stderr, gettext( 6976 "tar: Extended header uid value error " 6977 "for file # %llu.\n"), xhdr_count); 6978 Xtarhdr.x_uid = UID_NOBODY; 6979 } 6980 break; 6981 case _X_UNAME: 6982 if (utf8_local("uname", &Xtarhdr.x_uname, 6983 local_uname, value, _POSIX_NAME_MAX) == 0) 6984 xhdr_flgs |= _X_UNAME; 6985 break; 6986 case _X_MTIME: 6987 get_xtime(value, &(Xtarhdr.x_mtime)); 6988 if (errno) 6989 (void) fprintf(stderr, gettext( 6990 "tar: Extended header modification time " 6991 "value error for file # %llu.\n"), 6992 xhdr_count); 6993 else 6994 xhdr_flgs |= _X_MTIME; 6995 break; 6996 default: 6997 (void) fprintf(stderr, 6998 gettext("tar: unrecognized extended" 6999 " header keyword '%s'. Ignored.\n"), keyword); 7000 break; 7001 } 7002 } 7003 7004 getdir(); /* get regular header */ 7005 if (errors && errflag) 7006 done(1); 7007 else 7008 if (errors) 7009 Errflg = 1; 7010 return (errors); 7011 } 7012 7013 /* 7014 * load_info_from_xtarhdr - sets Gen and stbuf variables from 7015 * extended header 7016 * load_info_from_xtarhdr(flag, xhdrp); 7017 * u_longlong_t flag; xhdr_flgs 7018 * struct xtar_hdr *xhdrp; pointer to extended header 7019 * NOTE: called when typeflag is not 'A' and xhdr_flgs 7020 * is set. 7021 */ 7022 static void 7023 load_info_from_xtarhdr(u_longlong_t flag, struct xtar_hdr *xhdrp) 7024 { 7025 if (flag & _X_DEVMAJOR) { 7026 Gen.g_devmajor = xhdrp->x_devmajor; 7027 } 7028 if (flag & _X_DEVMINOR) { 7029 Gen.g_devminor = xhdrp->x_devminor; 7030 } 7031 if (flag & _X_GID) { 7032 Gen.g_gid = xhdrp->x_gid; 7033 stbuf.st_gid = xhdrp->x_gid; 7034 } 7035 if (flag & _X_UID) { 7036 Gen.g_uid = xhdrp->x_uid; 7037 stbuf.st_uid = xhdrp->x_uid; 7038 } 7039 if (flag & _X_SIZE) { 7040 Gen.g_filesz = xhdrp->x_filesz; 7041 stbuf.st_size = xhdrp->x_filesz; 7042 } 7043 if (flag & _X_MTIME) { 7044 Gen.g_mtime = xhdrp->x_mtime.tv_sec; 7045 stbuf.st_mtim.tv_sec = xhdrp->x_mtime.tv_sec; 7046 stbuf.st_mtim.tv_nsec = xhdrp->x_mtime.tv_nsec; 7047 } 7048 } 7049 7050 /* 7051 * gen_num creates a string from a keyword and an usigned long long in the 7052 * format: %d %s=%s\n 7053 * This is part of the extended header data record. 7054 */ 7055 7056 void 7057 gen_num(const char *keyword, const u_longlong_t number) 7058 { 7059 char save_val[ULONGLONG_MAX_DIGITS + 1]; 7060 int len; 7061 char *curr_ptr; 7062 7063 (void) sprintf(save_val, "%llu", number); 7064 /* 7065 * len = length of entire line, including itself. len will be 7066 * two digits. So, add the string lengths plus the length of len, 7067 * plus a blank, an equal sign, and a newline. 7068 */ 7069 len = strlen(save_val) + strlen(keyword) + 5; 7070 if (xrec_offset + len > xrec_size) { 7071 if (((curr_ptr = realloc(xrec_ptr, 2 * xrec_size)) == NULL)) 7072 fatal(gettext( 7073 "cannot allocate extended header buffer")); 7074 xrec_ptr = curr_ptr; 7075 xrec_size *= 2; 7076 } 7077 (void) sprintf(&xrec_ptr[xrec_offset], 7078 "%d %s=%s\n", len, keyword, save_val); 7079 xrec_offset += len; 7080 } 7081 7082 /* 7083 * gen_date creates a string from a keyword and a timestruc_t in the 7084 * format: %d %s=%s\n 7085 * This is part of the extended header data record. 7086 * Currently, granularity is only microseconds, so the low-order three digits 7087 * will be truncated. 7088 */ 7089 7090 void 7091 gen_date(const char *keyword, const timestruc_t time_value) 7092 { 7093 /* Allow for <seconds>.<nanoseconds>\n */ 7094 char save_val[TIME_MAX_DIGITS + LONG_MAX_DIGITS + 2]; 7095 int len; 7096 char *curr_ptr; 7097 7098 (void) sprintf(save_val, "%ld", time_value.tv_sec); 7099 len = strlen(save_val); 7100 save_val[len] = '.'; 7101 (void) sprintf(&save_val[len + 1], "%9.9ld", time_value.tv_nsec); 7102 7103 /* 7104 * len = length of entire line, including itself. len will be 7105 * two digits. So, add the string lengths plus the length of len, 7106 * plus a blank, an equal sign, and a newline. 7107 */ 7108 len = strlen(save_val) + strlen(keyword) + 5; 7109 if (xrec_offset + len > xrec_size) { 7110 if (((curr_ptr = realloc(xrec_ptr, 2 * xrec_size)) == NULL)) 7111 fatal(gettext( 7112 "cannot allocate extended header buffer")); 7113 xrec_ptr = curr_ptr; 7114 xrec_size *= 2; 7115 } 7116 (void) sprintf(&xrec_ptr[xrec_offset], 7117 "%d %s=%s\n", len, keyword, save_val); 7118 xrec_offset += len; 7119 } 7120 7121 /* 7122 * gen_string creates a string from a keyword and a char * in the 7123 * format: %d %s=%s\n 7124 * This is part of the extended header data record. 7125 */ 7126 7127 void 7128 gen_string(const char *keyword, const char *value) 7129 { 7130 int len; 7131 char *curr_ptr; 7132 7133 /* 7134 * len = length of entire line, including itself. The character length 7135 * of len must be 1-4 characters, because the maximum size of the path 7136 * or the name is PATH_MAX, which is 1024. So, assume 1 character 7137 * for len, one for the space, one for the "=", and one for the newline. 7138 * Then adjust as needed. 7139 */ 7140 /* LINTED constant expression */ 7141 assert(PATH_MAX <= 9996); 7142 len = strlen(value) + strlen(keyword) + 4; 7143 if (len > 997) 7144 len += 3; 7145 else if (len > 98) 7146 len += 2; 7147 else if (len > 9) 7148 len += 1; 7149 if (xrec_offset + len > xrec_size) { 7150 if (((curr_ptr = realloc(xrec_ptr, 2 * xrec_size)) == NULL)) 7151 fatal(gettext( 7152 "cannot allocate extended header buffer")); 7153 xrec_ptr = curr_ptr; 7154 xrec_size *= 2; 7155 } 7156 #ifdef XHDR_DEBUG 7157 if (strcmp(keyword+1, "name") != 0) 7158 #endif 7159 (void) sprintf(&xrec_ptr[xrec_offset], 7160 "%d %s=%s\n", len, keyword, value); 7161 #ifdef XHDR_DEBUG 7162 else { 7163 len += 11; 7164 (void) sprintf(&xrec_ptr[xrec_offset], 7165 "%d %s=%snametoolong\n", len, keyword, value); 7166 } 7167 #endif 7168 xrec_offset += len; 7169 } 7170 7171 /* 7172 * Convert time found in the extended header data to seconds and nanoseconds. 7173 */ 7174 7175 void 7176 get_xtime(char *value, timestruc_t *xtime) 7177 { 7178 char nanosec[10]; 7179 char *period; 7180 int i; 7181 7182 (void) memset(nanosec, '0', 9); 7183 nanosec[9] = '\0'; 7184 7185 period = strchr(value, '.'); 7186 if (period != NULL) 7187 period[0] = '\0'; 7188 xtime->tv_sec = strtol(value, NULL, 10); 7189 if (period == NULL) 7190 xtime->tv_nsec = 0; 7191 else { 7192 i = strlen(period +1); 7193 (void) strncpy(nanosec, period + 1, min(i, 9)); 7194 xtime->tv_nsec = strtol(nanosec, NULL, 10); 7195 } 7196 } 7197 7198 /* 7199 * Check linkpath for length. 7200 * Emit an error message and return 1 if too long. 7201 */ 7202 7203 int 7204 chk_path_build( 7205 char *name, 7206 char *longname, 7207 char *linkname, 7208 char *prefix, 7209 char type, 7210 int filetype) 7211 { 7212 7213 if (strlen(linkname) > (size_t)NAMSIZ) { 7214 if (Eflag > 0) { 7215 xhdr_flgs |= _X_LINKPATH; 7216 Xtarhdr.x_linkpath = linkname; 7217 } else { 7218 (void) fprintf(stderr, gettext( 7219 "tar: %s: linked to %s\n"), longname, linkname); 7220 (void) fprintf(stderr, gettext( 7221 "tar: %s: linked name too long\n"), linkname); 7222 if (errflag) 7223 done(1); 7224 else 7225 Errflg = 1; 7226 return (1); 7227 } 7228 } 7229 if (xhdr_flgs & _X_LINKPATH) 7230 return (build_dblock(name, tchar, type, 7231 filetype, &stbuf, stbuf.st_dev, 7232 prefix)); 7233 else 7234 return (build_dblock(name, linkname, type, 7235 filetype, &stbuf, stbuf.st_dev, prefix)); 7236 } 7237 7238 /* 7239 * Convert from UTF-8 to local character set. 7240 */ 7241 7242 static int 7243 utf8_local( 7244 char *option, 7245 char **Xhdr_ptrptr, 7246 char *target, 7247 const char *source, 7248 int max_val) 7249 { 7250 static iconv_t iconv_cd; 7251 char *nl_target; 7252 const char *iconv_src; 7253 char *iconv_trg; 7254 size_t inlen; 7255 size_t outlen; 7256 7257 if (charset_type == -1) { /* iconv_open failed in earlier try */ 7258 (void) fprintf(stderr, gettext( 7259 "tar: file # %llu: (%s) UTF-8 conversion failed.\n"), 7260 xhdr_count, source); 7261 return (1); 7262 } else if (charset_type == 0) { /* iconv_open has not yet been done */ 7263 nl_target = nl_langinfo(CODESET); 7264 if (strlen(nl_target) == 0) /* locale using 7-bit codeset */ 7265 nl_target = "646"; 7266 if (strcmp(nl_target, "646") == 0) 7267 charset_type = 1; 7268 else if (strcmp(nl_target, "UTF-8") == 0) 7269 charset_type = 3; 7270 else { 7271 if (strncmp(nl_target, "ISO", 3) == 0) 7272 nl_target += 3; 7273 charset_type = 2; 7274 errno = 0; 7275 if ((iconv_cd = iconv_open(nl_target, "UTF-8")) == 7276 (iconv_t)-1) { 7277 if (errno == EINVAL) 7278 (void) fprintf(stderr, gettext( 7279 "tar: conversion routines not " 7280 "available for current locale. ")); 7281 (void) fprintf(stderr, gettext( 7282 "file # %llu: (%s) UTF-8 conversion" 7283 " failed.\n"), xhdr_count, source); 7284 charset_type = -1; 7285 return (1); 7286 } 7287 } 7288 } 7289 7290 /* locale using 7-bit codeset or UTF-8 locale */ 7291 if (charset_type == 1 || charset_type == 3) { 7292 if (strlen(source) > max_val) { 7293 (void) fprintf(stderr, gettext( 7294 "tar: file # %llu: Extended header %s too long.\n"), 7295 xhdr_count, option); 7296 return (1); 7297 } 7298 if (charset_type == 3) 7299 (void) strcpy(target, source); 7300 else if (c_utf8(target, source) != 0) { 7301 (void) fprintf(stderr, gettext( 7302 "tar: file # %llu: (%s) UTF-8 conversion" 7303 " failed.\n"), xhdr_count, source); 7304 return (1); 7305 } 7306 *Xhdr_ptrptr = target; 7307 return (0); 7308 } 7309 7310 iconv_src = source; 7311 iconv_trg = target; 7312 inlen = strlen(source); 7313 outlen = max_val * UTF_8_FACTOR; 7314 if (iconv(iconv_cd, &iconv_src, &inlen, &iconv_trg, &outlen) == 7315 (size_t)-1) { /* Error occurred: didn't convert */ 7316 (void) fprintf(stderr, gettext( 7317 "tar: file # %llu: (%s) UTF-8 conversion failed.\n"), 7318 xhdr_count, source); 7319 /* Get remaining output; reinitialize conversion descriptor */ 7320 iconv_src = (const char *)NULL; 7321 inlen = 0; 7322 (void) iconv(iconv_cd, &iconv_src, &inlen, &iconv_trg, &outlen); 7323 return (1); 7324 } 7325 /* Get remaining output; reinitialize conversion descriptor */ 7326 iconv_src = (const char *)NULL; 7327 inlen = 0; 7328 if (iconv(iconv_cd, &iconv_src, &inlen, &iconv_trg, &outlen) == 7329 (size_t)-1) { /* Error occurred: didn't convert */ 7330 (void) fprintf(stderr, gettext( 7331 "tar: file # %llu: (%s) UTF-8 conversion failed.\n"), 7332 xhdr_count, source); 7333 return (1); 7334 } 7335 7336 *iconv_trg = '\0'; /* Null-terminate iconv output string */ 7337 if (strlen(target) > max_val) { 7338 (void) fprintf(stderr, gettext( 7339 "tar: file # %llu: Extended header %s too long.\n"), 7340 xhdr_count, option); 7341 return (1); 7342 } 7343 *Xhdr_ptrptr = target; 7344 return (0); 7345 } 7346 7347 /* 7348 * Check gname, uname, path, and linkpath to see if they need to go in an 7349 * extended header. If they are already slated to be in an extended header, 7350 * or if they are not ascii, then they need to be in the extended header. 7351 * Then, convert all extended names to UTF-8. 7352 */ 7353 7354 int 7355 gen_utf8_names(const char *filename) 7356 { 7357 static iconv_t iconv_cd; 7358 char *nl_target; 7359 char tempbuf[MAXNAM + 1]; 7360 int nbytes; 7361 int errors; 7362 7363 if (charset_type == -1) { /* Previous failure to open. */ 7364 (void) fprintf(stderr, gettext( 7365 "tar: file # %llu: UTF-8 conversion failed.\n"), 7366 xhdr_count); 7367 return (1); 7368 } 7369 7370 if (charset_type == 0) { /* Need to get conversion descriptor */ 7371 nl_target = nl_langinfo(CODESET); 7372 if (strlen(nl_target) == 0) /* locale using 7-bit codeset */ 7373 nl_target = "646"; 7374 if (strcmp(nl_target, "646") == 0) 7375 charset_type = 1; 7376 else if (strcmp(nl_target, "UTF-8") == 0) 7377 charset_type = 3; 7378 else { 7379 if (strncmp(nl_target, "ISO", 3) == 0) 7380 nl_target += 3; 7381 charset_type = 2; 7382 errno = 0; 7383 #ifdef ICONV_DEBUG 7384 (void) fprintf(stderr, 7385 gettext("Opening iconv_cd with target %s\n"), 7386 nl_target); 7387 #endif 7388 if ((iconv_cd = iconv_open("UTF-8", nl_target)) == 7389 (iconv_t)-1) { 7390 if (errno == EINVAL) 7391 (void) fprintf(stderr, gettext( 7392 "tar: conversion routines not " 7393 "available for current locale. ")); 7394 (void) fprintf(stderr, gettext( 7395 "file (%s): UTF-8 conversion failed.\n"), 7396 filename); 7397 charset_type = -1; 7398 return (1); 7399 } 7400 } 7401 } 7402 7403 errors = 0; 7404 7405 errors += local_utf8(&Xtarhdr.x_gname, local_gname, 7406 dblock.dbuf.gname, iconv_cd, _X_GNAME, _POSIX_NAME_MAX); 7407 errors += local_utf8(&Xtarhdr.x_uname, local_uname, 7408 dblock.dbuf.uname, iconv_cd, _X_UNAME, _POSIX_NAME_MAX); 7409 if ((xhdr_flgs & _X_LINKPATH) == 0) { /* Need null-terminated str. */ 7410 (void) strncpy(tempbuf, dblock.dbuf.linkname, NAMSIZ); 7411 tempbuf[NAMSIZ] = '\0'; 7412 } 7413 errors += local_utf8(&Xtarhdr.x_linkpath, local_linkpath, 7414 tempbuf, iconv_cd, _X_LINKPATH, PATH_MAX); 7415 if ((xhdr_flgs & _X_PATH) == 0) { /* Concatenate prefix & name */ 7416 (void) strncpy(tempbuf, dblock.dbuf.prefix, PRESIZ); 7417 tempbuf[PRESIZ] = '\0'; 7418 nbytes = strlen(tempbuf); 7419 if (nbytes > 0) { 7420 tempbuf[nbytes++] = '/'; 7421 tempbuf[nbytes] = '\0'; 7422 } 7423 (void) strncat(tempbuf + nbytes, dblock.dbuf.name, 7424 (MAXNAM - nbytes)); 7425 tempbuf[MAXNAM] = '\0'; 7426 } 7427 errors += local_utf8(&Xtarhdr.x_path, local_path, 7428 tempbuf, iconv_cd, _X_PATH, PATH_MAX); 7429 7430 if (errors > 0) 7431 (void) fprintf(stderr, gettext( 7432 "tar: file (%s): UTF-8 conversion failed.\n"), filename); 7433 7434 if (errors && errflag) 7435 done(1); 7436 else 7437 if (errors) 7438 Errflg = 1; 7439 return (errors); 7440 } 7441 7442 static int 7443 local_utf8( 7444 char **Xhdr_ptrptr, 7445 char *target, 7446 const char *source, 7447 iconv_t iconv_cd, 7448 int xhdrflg, 7449 int max_val) 7450 { 7451 const char *iconv_src; 7452 const char *starting_src; 7453 char *iconv_trg; 7454 size_t inlen; 7455 size_t outlen; 7456 #ifdef ICONV_DEBUG 7457 unsigned char c_to_hex; 7458 #endif 7459 7460 /* 7461 * If the item is already slated for extended format, get the string 7462 * to convert from the extended header record. Otherwise, get it from 7463 * the regular (dblock) area. 7464 */ 7465 if (xhdr_flgs & xhdrflg) { 7466 if (charset_type == 3) { /* Already UTF-8, just copy */ 7467 (void) strcpy(target, *Xhdr_ptrptr); 7468 *Xhdr_ptrptr = target; 7469 return (0); 7470 } else 7471 iconv_src = (const char *) *Xhdr_ptrptr; 7472 } else { 7473 if (charset_type == 3) /* Already in UTF-8 format */ 7474 return (0); /* Don't create xhdr record */ 7475 iconv_src = source; 7476 } 7477 starting_src = iconv_src; 7478 iconv_trg = target; 7479 if ((inlen = strlen(iconv_src)) == 0) 7480 return (0); 7481 7482 if (charset_type == 1) { /* locale using 7-bit codeset */ 7483 if (c_utf8(target, starting_src) != 0) { 7484 (void) fprintf(stderr, 7485 gettext("tar: invalid character in" 7486 " UTF-8 conversion of '%s'\n"), starting_src); 7487 return (1); 7488 } 7489 return (0); 7490 } 7491 7492 outlen = max_val * UTF_8_FACTOR; 7493 errno = 0; 7494 if (iconv(iconv_cd, &iconv_src, &inlen, &iconv_trg, &outlen) == 7495 (size_t)-1) { 7496 /* An error occurred, or not all characters were converted */ 7497 if (errno == EILSEQ) 7498 (void) fprintf(stderr, 7499 gettext("tar: invalid character in" 7500 " UTF-8 conversion of '%s'\n"), starting_src); 7501 else 7502 (void) fprintf(stderr, gettext( 7503 "tar: conversion to UTF-8 aborted for '%s'.\n"), 7504 starting_src); 7505 /* Get remaining output; reinitialize conversion descriptor */ 7506 iconv_src = (const char *)NULL; 7507 inlen = 0; 7508 (void) iconv(iconv_cd, &iconv_src, &inlen, &iconv_trg, &outlen); 7509 return (1); 7510 } 7511 /* Get remaining output; reinitialize conversion descriptor */ 7512 iconv_src = (const char *)NULL; 7513 inlen = 0; 7514 if (iconv(iconv_cd, &iconv_src, &inlen, &iconv_trg, &outlen) == 7515 (size_t)-1) { /* Error occurred: didn't convert */ 7516 if (errno == EILSEQ) 7517 (void) fprintf(stderr, 7518 gettext("tar: invalid character in" 7519 " UTF-8 conversion of '%s'\n"), starting_src); 7520 else 7521 (void) fprintf(stderr, gettext( 7522 "tar: conversion to UTF-8 aborted for '%s'.\n"), 7523 starting_src); 7524 return (1); 7525 } 7526 7527 *iconv_trg = '\0'; /* Null-terminate iconv output string */ 7528 if (strcmp(starting_src, target) != 0) { 7529 *Xhdr_ptrptr = target; 7530 xhdr_flgs |= xhdrflg; 7531 #ifdef ICONV_DEBUG 7532 (void) fprintf(stderr, "*** inlen: %d %d; outlen: %d %d\n", 7533 strlen(starting_src), inlen, max_val, outlen); 7534 (void) fprintf(stderr, "Input string:\n "); 7535 for (inlen = 0; inlen < strlen(starting_src); inlen++) { 7536 c_to_hex = (unsigned char)starting_src[inlen]; 7537 (void) fprintf(stderr, " %2.2x", c_to_hex); 7538 if (inlen % 20 == 19) 7539 (void) fprintf(stderr, "\n "); 7540 } 7541 (void) fprintf(stderr, "\nOutput string:\n "); 7542 for (inlen = 0; inlen < strlen(target); inlen++) { 7543 c_to_hex = (unsigned char)target[inlen]; 7544 (void) fprintf(stderr, " %2.2x", c_to_hex); 7545 if (inlen % 20 == 19) 7546 (void) fprintf(stderr, "\n "); 7547 } 7548 (void) fprintf(stderr, "\n"); 7549 #endif 7550 } 7551 7552 return (0); 7553 } 7554 7555 /* 7556 * Function to test each byte of the source string to make sure it is 7557 * in within bounds (value between 0 and 127). 7558 * If valid, copy source to target. 7559 */ 7560 7561 int 7562 c_utf8(char *target, const char *source) 7563 { 7564 size_t len; 7565 const char *thischar; 7566 7567 len = strlen(source); 7568 thischar = source; 7569 while (len-- > 0) { 7570 if (!isascii((int)(*thischar++))) 7571 return (1); 7572 } 7573 7574 (void) strcpy(target, source); 7575 return (0); 7576 } 7577 7578 7579 #if defined(O_XATTR) 7580 #define ROUNDTOTBLOCK(a) ((a + (TBLOCK -1)) & ~(TBLOCK -1)) 7581 7582 static void 7583 prepare_xattr( 7584 char **attrbuf, 7585 char *filename, 7586 char *attrpath, 7587 char typeflag, 7588 struct linkbuf *linkinfo, 7589 int *rlen) 7590 { 7591 char *bufhead; /* ptr to full buffer */ 7592 char *aptr; 7593 struct xattr_hdr *hptr; /* ptr to header in bufhead */ 7594 struct xattr_buf *tptr; /* ptr to pathing pieces */ 7595 int totalen; /* total buffer length */ 7596 int len; /* length returned to user */ 7597 int stringlen; /* length of filename + attr */ 7598 /* 7599 * length of filename + attr 7600 * in link section 7601 */ 7602 int linkstringlen; 7603 int complen; /* length of pathing section */ 7604 int linklen; /* length of link section */ 7605 int attrnames_index; /* attrnames starting index */ 7606 7607 /* 7608 * Release previous buffer 7609 */ 7610 7611 if (*attrbuf != (char *)NULL) { 7612 free(*attrbuf); 7613 *attrbuf = NULL; 7614 } 7615 7616 /* 7617 * First add in fixed size stuff 7618 */ 7619 len = sizeof (struct xattr_hdr) + sizeof (struct xattr_buf); 7620 7621 /* 7622 * Add space for two nulls 7623 */ 7624 stringlen = strlen(attrpath) + strlen(filename) + 2; 7625 complen = stringlen + sizeof (struct xattr_buf); 7626 7627 len += stringlen; 7628 7629 /* 7630 * Now add on space for link info if any 7631 */ 7632 7633 if (linkinfo != NULL) { 7634 /* 7635 * Again add space for two nulls 7636 */ 7637 linkstringlen = strlen(linkinfo->pathname) + 7638 strlen(linkinfo->attrname) + 2; 7639 linklen = linkstringlen + sizeof (struct xattr_buf); 7640 len += linklen; 7641 } else { 7642 linklen = 0; 7643 } 7644 7645 /* 7646 * Now add padding to end to fill out TBLOCK 7647 * 7648 * Function returns size of real data and not size + padding. 7649 */ 7650 7651 totalen = ROUNDTOTBLOCK(len); 7652 7653 if ((bufhead = calloc(1, totalen)) == NULL) { 7654 fatal(gettext("Out of memory.")); 7655 } 7656 7657 7658 /* 7659 * Now we can fill in the necessary pieces 7660 */ 7661 7662 /* 7663 * first fill in the fixed header 7664 */ 7665 hptr = (struct xattr_hdr *)bufhead; 7666 (void) sprintf(hptr->h_version, "%s", XATTR_ARCH_VERS); 7667 (void) sprintf(hptr->h_component_len, "%0*d", 7668 sizeof (hptr->h_component_len) - 1, complen); 7669 (void) sprintf(hptr->h_link_component_len, "%0*d", 7670 sizeof (hptr->h_link_component_len) - 1, linklen); 7671 (void) sprintf(hptr->h_size, "%0*d", sizeof (hptr->h_size) - 1, len); 7672 7673 /* 7674 * Now fill in the filename + attrnames section 7675 * The filename and attrnames section can be composed of two or more 7676 * path segments separated by a null character. The first segment 7677 * is the path to the parent file that roots the entire sequence in 7678 * the normal name space. The remaining segments describes a path 7679 * rooted at the hidden extended attribute directory of the leaf file of 7680 * the previous segment, making it possible to name attributes on 7681 * attributes. Thus, if we are just archiving an extended attribute, 7682 * the second segment will contain the attribute name. If we are 7683 * archiving a system attribute of an extended attribute, then the 7684 * second segment will contain the attribute name, and a third segment 7685 * will contain the system attribute name. The attribute pathing 7686 * information is obtained from 'attrpath'. 7687 */ 7688 7689 tptr = (struct xattr_buf *)(bufhead + sizeof (struct xattr_hdr)); 7690 (void) sprintf(tptr->h_namesz, "%0*d", sizeof (tptr->h_namesz) - 1, 7691 stringlen); 7692 (void) strcpy(tptr->h_names, filename); 7693 attrnames_index = strlen(filename) + 1; 7694 (void) strcpy(&tptr->h_names[attrnames_index], attrpath); 7695 tptr->h_typeflag = typeflag; 7696 7697 /* 7698 * Split the attrnames section into two segments if 'attrpath' 7699 * contains pathing information for a system attribute of an 7700 * extended attribute. We split them by replacing the '/' with 7701 * a '\0'. 7702 */ 7703 if ((aptr = strpbrk(&tptr->h_names[attrnames_index], "/")) != NULL) { 7704 *aptr = '\0'; 7705 } 7706 7707 /* 7708 * Now fill in the optional link section if we have one 7709 */ 7710 7711 if (linkinfo != (struct linkbuf *)NULL) { 7712 tptr = (struct xattr_buf *)(bufhead + 7713 sizeof (struct xattr_hdr) + complen); 7714 7715 (void) sprintf(tptr->h_namesz, "%0*d", 7716 sizeof (tptr->h_namesz) - 1, linkstringlen); 7717 (void) strcpy(tptr->h_names, linkinfo->pathname); 7718 (void) strcpy( 7719 &tptr->h_names[strlen(linkinfo->pathname) + 1], 7720 linkinfo->attrname); 7721 tptr->h_typeflag = typeflag; 7722 } 7723 *attrbuf = (char *)bufhead; 7724 *rlen = len; 7725 } 7726 7727 #else 7728 static void 7729 prepare_xattr( 7730 char **attrbuf, 7731 char *filename, 7732 char *attrname, 7733 char typeflag, 7734 struct linkbuf *linkinfo, 7735 int *rlen) 7736 { 7737 *attrbuf = NULL; 7738 *rlen = 0; 7739 } 7740 #endif 7741 7742 int 7743 getstat(int dirfd, char *longname, char *shortname, char *attrparent) 7744 { 7745 7746 int i, j; 7747 int printerr; 7748 int slnkerr; 7749 struct stat symlnbuf; 7750 7751 if (!hflag) 7752 i = fstatat(dirfd, shortname, &stbuf, AT_SYMLINK_NOFOLLOW); 7753 else 7754 i = fstatat(dirfd, shortname, &stbuf, 0); 7755 7756 if (i < 0) { 7757 /* Initialize flag to print error mesg. */ 7758 printerr = 1; 7759 /* 7760 * If stat is done, then need to do lstat 7761 * to determine whether it's a sym link 7762 */ 7763 if (hflag) { 7764 /* Save returned error */ 7765 slnkerr = errno; 7766 7767 j = fstatat(dirfd, shortname, 7768 &symlnbuf, AT_SYMLINK_NOFOLLOW); 7769 /* 7770 * Suppress error message when file is a symbolic link 7771 * and function modifier 'l' is off. Exception: when 7772 * a symlink points to a symlink points to a 7773 * symlink ... and we get past MAXSYMLINKS. That 7774 * error will cause a file not to be archived, and 7775 * needs to be printed. 7776 */ 7777 if ((j == 0) && (!linkerrok) && (slnkerr != ELOOP) && 7778 (S_ISLNK(symlnbuf.st_mode))) 7779 printerr = 0; 7780 7781 /* 7782 * Restore errno in case the lstat 7783 * on symbolic link change 7784 */ 7785 errno = slnkerr; 7786 } 7787 7788 if (printerr) { 7789 (void) fprintf(stderr, gettext( 7790 "tar: %s%s%s%s: %s\n"), 7791 (attrparent == NULL) ? "" : gettext("attribute "), 7792 (attrparent == NULL) ? "" : attrparent, 7793 (attrparent == NULL) ? "" : gettext(" of "), 7794 longname, strerror(errno)); 7795 Errflg = 1; 7796 } 7797 return (1); 7798 } 7799 return (0); 7800 } 7801 7802 /* 7803 * Recursively archive the extended attributes and/or extended system attributes 7804 * of the base file, longname. Note: extended system attribute files will be 7805 * archived only if the extended system attributes are not transient (i.e. the 7806 * extended system attributes are other than the default values). 7807 * 7808 * If -@ was specified and the underlying file system supports it, archive the 7809 * extended attributes, and if there is a system attribute associated with the 7810 * extended attribute, then recursively call xattrs_put() to archive the 7811 * hidden attribute directory and the extended system attribute. If -/ was 7812 * specified and the underlying file system supports it, archive the extended 7813 * system attributes. Read-only extended system attributes are never archived. 7814 * 7815 * Currently, there cannot be attributes on attributes; only system 7816 * attributes on attributes. In addition, there cannot be attributes on 7817 * system attributes. A file and it's attribute directory hierarchy looks as 7818 * follows: 7819 * longname ----> . ("." is the hidden attribute directory) 7820 * | 7821 * ---------------------------- 7822 * | | 7823 * <sys_attr_name> <attr_name> ----> . 7824 * | 7825 * <sys_attr_name> 7826 * 7827 */ 7828 #if defined(O_XATTR) 7829 static void 7830 xattrs_put(char *longname, char *shortname, char *parent, char *attrparent) 7831 { 7832 char *filename = (attrparent == NULL) ? shortname : attrparent; 7833 int arc_rwsysattr = 0; 7834 int dirfd; 7835 int fd = -1; 7836 int rw_sysattr = 0; 7837 int ext_attr = 0; 7838 int rc; 7839 DIR *dirp; 7840 struct dirent *dp; 7841 attr_data_t *attrinfo = NULL; 7842 7843 /* 7844 * If the underlying file system supports it, then archive the extended 7845 * attributes if -@ was specified, and the extended system attributes 7846 * if -/ was specified. 7847 */ 7848 if (verify_attr_support(filename, (attrparent == NULL), ARC_CREATE, 7849 &ext_attr) != ATTR_OK) { 7850 return; 7851 } 7852 7853 /* 7854 * Only want to archive a read-write extended system attribute file 7855 * if it contains extended system attribute settings that are not the 7856 * default values. 7857 */ 7858 #if defined(_PC_SATTR_ENABLED) 7859 if (saflag) { 7860 int filefd; 7861 nvlist_t *slist = NULL; 7862 7863 /* Determine if there are non-transient system attributes */ 7864 errno = 0; 7865 if ((filefd = open(filename, O_RDONLY)) == -1) { 7866 if (attrparent == NULL) { 7867 vperror(0, gettext( 7868 "unable to open file %s"), longname); 7869 } 7870 return; 7871 } 7872 if (((slist = sysattr_list(basename(myname), filefd, 7873 filename)) != NULL) || (errno != 0)) { 7874 arc_rwsysattr = 1; 7875 } 7876 if (slist != NULL) { 7877 (void) nvlist_free(slist); 7878 slist = NULL; 7879 } 7880 (void) close(filefd); 7881 } 7882 7883 /* 7884 * If we aren't archiving extended system attributes, and we are 7885 * processing an attribute, or if we are archiving extended system 7886 * attributes, and there are are no extended attributes, then there's 7887 * no need to open up the attribute directory of the file unless the 7888 * extended system attributes are not transient (i.e, the system 7889 * attributes are not the default values). 7890 */ 7891 if ((arc_rwsysattr == 0) && ((attrparent != NULL) || 7892 (saflag && !ext_attr))) { 7893 return; 7894 } 7895 #endif /* _PC_SATTR_ENABLED */ 7896 7897 /* open the parent attribute directory */ 7898 fd = attropen(filename, ".", O_RDONLY); 7899 if (fd < 0) { 7900 vperror(0, gettext( 7901 "unable to open attribute directory for %s%s%sfile %s"), 7902 (attrparent == NULL) ? "" : gettext("attribute "), 7903 (attrparent == NULL) ? "" : attrparent, 7904 (attrparent == NULL) ? "" : gettext(" of "), 7905 longname); 7906 return; 7907 } 7908 7909 /* 7910 * We need to change into the parent's attribute directory to determine 7911 * if each of the attributes should be archived. 7912 */ 7913 if (fchdir(fd) < 0) { 7914 vperror(0, gettext( 7915 "cannot change to attribute directory of %s%s%sfile %s"), 7916 (attrparent == NULL) ? "" : gettext("attribute "), 7917 (attrparent == NULL) ? "" : attrparent, 7918 (attrparent == NULL) ? "" : gettext(" of "), 7919 longname); 7920 (void) close(fd); 7921 return; 7922 } 7923 7924 if (((dirfd = dup(fd)) == -1) || 7925 ((dirp = fdopendir(dirfd)) == NULL)) { 7926 (void) fprintf(stderr, gettext( 7927 "tar: unable to open dir pointer for %s%s%sfile %s\n"), 7928 (attrparent == NULL) ? "" : gettext("attribute "), 7929 (attrparent == NULL) ? "" : attrparent, 7930 (attrparent == NULL) ? "" : gettext(" of "), 7931 longname); 7932 if (fd > 0) { 7933 (void) close(fd); 7934 } 7935 return; 7936 } 7937 7938 while ((dp = readdir(dirp)) != NULL) { 7939 if (strcmp(dp->d_name, "..") == 0) { 7940 continue; 7941 } else if (strcmp(dp->d_name, ".") == 0) { 7942 Hiddendir = 1; 7943 } else { 7944 Hiddendir = 0; 7945 } 7946 7947 /* Determine if this attribute should be archived */ 7948 if (verify_attr(dp->d_name, attrparent, arc_rwsysattr, 7949 &rw_sysattr) != ATTR_OK) { 7950 continue; 7951 } 7952 7953 /* gather the attribute's information to pass to putfile() */ 7954 if ((fill_in_attr_info(dp->d_name, longname, attrparent, 7955 fd, rw_sysattr, &attrinfo)) == 1) { 7956 continue; 7957 } 7958 7959 /* add the attribute to the archive */ 7960 rc = putfile(longname, dp->d_name, parent, attrinfo, 7961 XATTR_FILE, LEV0, SYMLINK_LEV0); 7962 7963 if (exitflag) { 7964 break; 7965 } 7966 7967 #if defined(_PC_SATTR_ENABLED) 7968 /* 7969 * If both -/ and -@ were specified, then archive the 7970 * attribute's extended system attributes and hidden directory 7971 * by making a recursive call to xattrs_put(). 7972 */ 7973 if (!rw_sysattr && saflag && atflag && (rc != PUT_AS_LINK) && 7974 (Hiddendir == 0)) { 7975 7976 xattrs_put(longname, shortname, parent, dp->d_name); 7977 7978 /* 7979 * Change back to the parent's attribute directory 7980 * to process any further attributes. 7981 */ 7982 if (fchdir(fd) < 0) { 7983 vperror(0, gettext( 7984 "cannot change back to attribute directory " 7985 "of file %s"), longname); 7986 break; 7987 } 7988 } 7989 #endif /* _PC_SATTR_ENABLED */ 7990 } 7991 7992 if (attrinfo != NULL) { 7993 if (attrinfo->attr_parent != NULL) { 7994 free(attrinfo->attr_parent); 7995 } 7996 free(attrinfo->attr_path); 7997 free(attrinfo); 7998 } 7999 (void) closedir(dirp); 8000 if (fd != -1) { 8001 (void) close(fd); 8002 } 8003 8004 /* Change back to the parent directory of the base file */ 8005 if (attrparent == NULL) { 8006 (void) tar_chdir(parent); 8007 } 8008 Hiddendir = 0; 8009 } 8010 #else 8011 static void 8012 xattrs_put(char *longname, char *shortname, char *parent, char *attrppath) 8013 { 8014 } 8015 #endif /* O_XATTR */ 8016 8017 static int 8018 put_link(char *name, char *longname, char *component, char *longattrname, 8019 char *prefix, int filetype, char type) 8020 { 8021 8022 if (stbuf.st_nlink > 1) { 8023 struct linkbuf *lp; 8024 int found = 0; 8025 8026 for (lp = ihead; lp != NULL; lp = lp->nextp) 8027 if (lp->inum == stbuf.st_ino && 8028 lp->devnum == stbuf.st_dev) { 8029 found++; 8030 break; 8031 } 8032 if (found) { 8033 #if defined(O_XATTR) 8034 if (filetype == XATTR_FILE) 8035 if (put_xattr_hdr(longname, component, 8036 longattrname, prefix, type, filetype, lp)) { 8037 goto out; 8038 } 8039 #endif 8040 stbuf.st_size = (off_t)0; 8041 if (filetype != XATTR_FILE) { 8042 tomodes(&stbuf); 8043 if (chk_path_build(name, longname, lp->pathname, 8044 prefix, type, filetype) > 0) { 8045 goto out; 8046 } 8047 } 8048 8049 if (mulvol && tapepos + 1 >= blocklim) 8050 newvol(); 8051 (void) writetbuf((char *)&dblock, 1); 8052 /* 8053 * write_ancillary() is not needed here. 8054 * The first link is handled in the following 8055 * else statement. No need to process ACLs 8056 * for other hard links since they are the 8057 * same file. 8058 */ 8059 8060 if (vflag) { 8061 if (NotTape) 8062 dlog("seek = %" FMT_blkcnt_t 8063 "K\n", K(tapepos)); 8064 if (filetype == XATTR_FILE) { 8065 (void) fprintf(vfile, gettext( 8066 "a %s attribute %s link to " 8067 "%s attribute %s\n"), 8068 name, component, name, 8069 lp->attrname); 8070 } else { 8071 (void) fprintf(vfile, gettext( 8072 "a %s link to %s\n"), 8073 longname, lp->pathname); 8074 } 8075 } 8076 lp->count--; 8077 return (0); 8078 } else { 8079 lp = (struct linkbuf *)getmem(sizeof (*lp)); 8080 if (lp != (struct linkbuf *)NULL) { 8081 lp->nextp = ihead; 8082 ihead = lp; 8083 lp->inum = stbuf.st_ino; 8084 lp->devnum = stbuf.st_dev; 8085 lp->count = stbuf.st_nlink - 1; 8086 if (filetype == XATTR_FILE) { 8087 (void) strcpy(lp->pathname, longname); 8088 (void) strcpy(lp->attrname, 8089 component); 8090 } else { 8091 (void) strcpy(lp->pathname, longname); 8092 (void) strcpy(lp->attrname, ""); 8093 } 8094 } 8095 } 8096 } 8097 8098 out: 8099 return (1); 8100 } 8101 8102 static int 8103 put_extra_attributes(char *longname, char *shortname, char *longattrname, 8104 char *prefix, int filetype, char typeflag) 8105 { 8106 static acl_t *aclp = NULL; 8107 int error; 8108 8109 if (aclp != NULL) { 8110 acl_free(aclp); 8111 aclp = NULL; 8112 } 8113 #if defined(O_XATTR) 8114 if ((atflag || saflag) && (filetype == XATTR_FILE)) { 8115 if (put_xattr_hdr(longname, shortname, longattrname, prefix, 8116 typeflag, filetype, NULL)) { 8117 return (1); 8118 } 8119 } 8120 #endif 8121 8122 /* ACL support */ 8123 if (pflag) { 8124 char *secinfo = NULL; 8125 int len = 0; 8126 8127 /* ACL support */ 8128 if (((stbuf.st_mode & S_IFMT) != S_IFLNK)) { 8129 /* 8130 * Get ACL info: dont bother allocating space if 8131 * there is only a trivial ACL. 8132 */ 8133 if ((error = acl_get(shortname, ACL_NO_TRIVIAL, 8134 &aclp)) != 0) { 8135 (void) fprintf(stderr, gettext( 8136 "%s: failed to retrieve acl : %s\n"), 8137 longname, acl_strerror(error)); 8138 return (1); 8139 } 8140 } 8141 8142 /* append security attributes if any */ 8143 if (aclp != NULL) { 8144 (void) append_secattr(&secinfo, &len, acl_cnt(aclp), 8145 acl_totext(aclp, ACL_APPEND_ID | ACL_COMPACT_FMT | 8146 ACL_SID_FMT), (acl_type(aclp) == ACLENT_T) ? 8147 UFSD_ACL : ACE_ACL); 8148 } 8149 8150 if (Tflag) { 8151 /* append Trusted Extensions extended attributes */ 8152 append_ext_attr(shortname, &secinfo, &len); 8153 (void) write_ancillary(&dblock, secinfo, len, ACL_HDR); 8154 8155 } else if (aclp != NULL) { 8156 (void) write_ancillary(&dblock, secinfo, len, ACL_HDR); 8157 } 8158 } 8159 return (0); 8160 } 8161 8162 #if defined(O_XATTR) 8163 static int 8164 put_xattr_hdr(char *longname, char *shortname, char *longattrname, char *prefix, 8165 int typeflag, int filetype, struct linkbuf *lp) 8166 { 8167 char *lname = NULL; 8168 char *sname = NULL; 8169 int error = 0; 8170 static char *attrbuf = NULL; 8171 int attrlen; 8172 8173 lname = malloc(sizeof (char) * strlen("/dev/null") + 1 + 8174 strlen(shortname) + strlen(".hdr") + 1); 8175 8176 if (lname == NULL) { 8177 fatal(gettext("Out of Memory.")); 8178 } 8179 sname = malloc(sizeof (char) * strlen(shortname) + 8180 strlen(".hdr") + 1); 8181 if (sname == NULL) { 8182 fatal(gettext("Out of Memory.")); 8183 } 8184 8185 (void) sprintf(sname, "%s.hdr", shortname); 8186 (void) sprintf(lname, "/dev/null/%s", sname); 8187 8188 if (strlcpy(dblock.dbuf.name, lname, sizeof (dblock.dbuf.name)) >= 8189 sizeof (dblock.dbuf.name)) { 8190 fatal(gettext( 8191 "Buffer overflow writing extended attribute file name")); 8192 } 8193 8194 /* 8195 * dump extended attr lookup info 8196 */ 8197 prepare_xattr(&attrbuf, longname, longattrname, typeflag, lp, &attrlen); 8198 write_ancillary(&dblock, attrbuf, attrlen, _XATTR_HDRTYPE); 8199 8200 (void) sprintf(lname, "/dev/null/%s", shortname); 8201 (void) strncpy(dblock.dbuf.name, sname, NAMSIZ); 8202 8203 /* 8204 * Set up filename for attribute 8205 */ 8206 8207 error = build_dblock(lname, tchar, '0', filetype, 8208 &stbuf, stbuf.st_dev, prefix); 8209 free(lname); 8210 free(sname); 8211 8212 return (error); 8213 } 8214 #endif 8215 8216 #if defined(O_XATTR) 8217 static int 8218 read_xattr_hdr(attr_data_t **attrinfo) 8219 { 8220 char buf[TBLOCK]; 8221 char *attrparent = NULL; 8222 blkcnt_t blocks; 8223 char *tp; 8224 off_t bytes; 8225 int comp_len, link_len; 8226 int namelen; 8227 int attrparentlen; 8228 int parentfilelen; 8229 8230 if (dblock.dbuf.typeflag != _XATTR_HDRTYPE) 8231 return (1); 8232 8233 bytes = stbuf.st_size; 8234 if ((xattrhead = calloc(1, (int)bytes)) == NULL) { 8235 (void) fprintf(stderr, gettext( 8236 "Insufficient memory for extended attribute\n")); 8237 return (1); 8238 } 8239 8240 tp = (char *)xattrhead; 8241 blocks = TBLOCKS(bytes); 8242 while (blocks-- > 0) { 8243 readtape(buf); 8244 if (bytes <= TBLOCK) { 8245 (void) memcpy(tp, buf, (size_t)bytes); 8246 break; 8247 } else { 8248 (void) memcpy(tp, buf, TBLOCK); 8249 tp += TBLOCK; 8250 } 8251 bytes -= TBLOCK; 8252 } 8253 8254 /* 8255 * Validate that we can handle header format 8256 */ 8257 if (strcmp(xattrhead->h_version, XATTR_ARCH_VERS) != 0) { 8258 (void) fprintf(stderr, 8259 gettext("Unknown extended attribute format encountered\n")); 8260 (void) fprintf(stderr, 8261 gettext("Disabling extended attribute parsing\n")); 8262 xattrbadhead = 1; 8263 return (0); 8264 } 8265 (void) sscanf(xattrhead->h_component_len, "%10d", &comp_len); 8266 (void) sscanf(xattrhead->h_link_component_len, "%10d", &link_len); 8267 xattrp = (struct xattr_buf *)(((char *)xattrhead) + 8268 sizeof (struct xattr_hdr)); 8269 (void) sscanf(xattrp->h_namesz, "%7d", &namelen); 8270 if (link_len > 0) 8271 xattr_linkp = (struct xattr_buf *) 8272 ((int)xattrp + (int)comp_len); 8273 else 8274 xattr_linkp = NULL; 8275 8276 /* 8277 * Gather the attribute path from the filename and attrnames section. 8278 * The filename and attrnames section can be composed of two or more 8279 * path segments separated by a null character. The first segment 8280 * is the path to the parent file that roots the entire sequence in 8281 * the normal name space. The remaining segments describes a path 8282 * rooted at the hidden extended attribute directory of the leaf file of 8283 * the previous segment, making it possible to name attributes on 8284 * attributes. 8285 */ 8286 parentfilelen = strlen(xattrp->h_names); 8287 xattrapath = xattrp->h_names + parentfilelen + 1; 8288 if ((strlen(xattrapath) + parentfilelen + 2) < namelen) { 8289 /* 8290 * The attrnames section contains a system attribute on an 8291 * attribute. Save the name of the attribute for use later, 8292 * and replace the null separating the attribute name from 8293 * the system attribute name with a '/' so that xattrapath can 8294 * be used to display messages with the full attribute path name 8295 * rooted at the hidden attribute directory of the base file 8296 * in normal name space. 8297 */ 8298 attrparent = strdup(xattrapath); 8299 attrparentlen = strlen(attrparent); 8300 xattrapath[attrparentlen] = '/'; 8301 } 8302 if ((fill_in_attr_info((attrparent == NULL) ? xattrapath : 8303 xattrapath + attrparentlen + 1, xattrapath, attrparent, 8304 -1, 0, attrinfo)) == 1) { 8305 free(attrparent); 8306 return (1); 8307 } 8308 8309 /* Gather link info */ 8310 if (xattr_linkp) { 8311 xattr_linkaname = xattr_linkp->h_names + 8312 strlen(xattr_linkp->h_names) + 1; 8313 } else { 8314 xattr_linkaname = NULL; 8315 } 8316 8317 return (0); 8318 } 8319 #else 8320 static int 8321 read_xattr_hdr(attr_data_t **attrinfo) 8322 { 8323 return (0); 8324 } 8325 #endif 8326 8327 /* 8328 * skip over extra slashes in string. 8329 * 8330 * For example: 8331 * /usr/tmp///// 8332 * 8333 * would return pointer at 8334 * /usr/tmp///// 8335 * ^ 8336 */ 8337 static char * 8338 skipslashes(char *string, char *start) 8339 { 8340 while ((string > start) && *(string - 1) == '/') { 8341 string--; 8342 } 8343 8344 return (string); 8345 } 8346 8347 /* 8348 * Return the parent directory of a given path. 8349 * 8350 * Examples: 8351 * /usr/tmp return /usr 8352 * /usr/tmp/file return /usr/tmp 8353 * / returns . 8354 * /usr returns / 8355 * file returns . 8356 * 8357 * dir is assumed to be at least as big as path. 8358 */ 8359 static void 8360 get_parent(char *path, char *dir) 8361 { 8362 char *s; 8363 char tmpdir[PATH_MAX + 1]; 8364 8365 if (strlen(path) > PATH_MAX) { 8366 fatal(gettext("pathname is too long")); 8367 } 8368 (void) strcpy(tmpdir, path); 8369 chop_endslashes(tmpdir); 8370 8371 if ((s = strrchr(tmpdir, '/')) == NULL) { 8372 (void) strcpy(dir, "."); 8373 } else { 8374 s = skipslashes(s, tmpdir); 8375 *s = '\0'; 8376 if (s == tmpdir) 8377 (void) strcpy(dir, "/"); 8378 else 8379 (void) strcpy(dir, tmpdir); 8380 } 8381 } 8382 8383 #if defined(O_XATTR) 8384 static char * 8385 get_component(char *path) 8386 { 8387 char *ptr; 8388 8389 ptr = strrchr(path, '/'); 8390 if (ptr == NULL) { 8391 return (path); 8392 } else { 8393 /* 8394 * Handle trailing slash 8395 */ 8396 if (*(ptr + 1) == '\0') 8397 return (ptr); 8398 else 8399 return (ptr + 1); 8400 } 8401 } 8402 #else 8403 static char * 8404 get_component(char *path) 8405 { 8406 return (path); 8407 } 8408 #endif 8409 8410 #if defined(O_XATTR) 8411 static int 8412 retry_open_attr(int pdirfd, int cwd, char *dirp, char *pattr, char *name, 8413 int oflag, mode_t mode) 8414 { 8415 int dirfd; 8416 int ofilefd = -1; 8417 struct timeval times[2]; 8418 mode_t newmode; 8419 struct stat parentstat; 8420 acl_t *aclp = NULL; 8421 int error; 8422 8423 /* 8424 * We couldn't get to attrdir. See if its 8425 * just a mode problem on the parent file. 8426 * for example: a mode such as r-xr--r-- 8427 * on a ufs file system without extended 8428 * system attribute support won't let us 8429 * create an attribute dir if it doesn't 8430 * already exist, and on a ufs file system 8431 * with extended system attribute support 8432 * won't let us open the attribute for 8433 * write. 8434 * 8435 * If file has a non-trivial ACL, then save it 8436 * off so that we can place it back on after doing 8437 * chmod's. 8438 */ 8439 if ((dirfd = openat(cwd, (pattr == NULL) ? dirp : pattr, 8440 O_RDONLY)) == -1) { 8441 return (-1); 8442 } 8443 if (fstat(dirfd, &parentstat) == -1) { 8444 (void) fprintf(stderr, gettext( 8445 "tar: cannot stat %sfile %s: %s\n"), 8446 (pdirfd == -1) ? "" : gettext("parent of "), 8447 (pdirfd == -1) ? dirp : name, strerror(errno)); 8448 return (-1); 8449 } 8450 if ((error = facl_get(dirfd, ACL_NO_TRIVIAL, &aclp)) != 0) { 8451 (void) fprintf(stderr, gettext( 8452 "tar: failed to retrieve ACL on %sfile %s: %s\n"), 8453 (pdirfd == -1) ? "" : gettext("parent of "), 8454 (pdirfd == -1) ? dirp : name, strerror(errno)); 8455 return (-1); 8456 } 8457 8458 newmode = S_IWUSR | parentstat.st_mode; 8459 if (fchmod(dirfd, newmode) == -1) { 8460 (void) fprintf(stderr, 8461 gettext( 8462 "tar: cannot fchmod %sfile %s to %o: %s\n"), 8463 (pdirfd == -1) ? "" : gettext("parent of "), 8464 (pdirfd == -1) ? dirp : name, newmode, strerror(errno)); 8465 if (aclp) 8466 acl_free(aclp); 8467 return (-1); 8468 } 8469 8470 8471 if (pdirfd == -1) { 8472 /* 8473 * We weren't able to create the attribute directory before. 8474 * Now try again. 8475 */ 8476 ofilefd = attropen(dirp, ".", oflag); 8477 } else { 8478 /* 8479 * We weren't able to create open the attribute before. 8480 * Now try again. 8481 */ 8482 ofilefd = openat(pdirfd, name, oflag, mode); 8483 } 8484 8485 /* 8486 * Put mode back to original 8487 */ 8488 if (fchmod(dirfd, parentstat.st_mode) == -1) { 8489 (void) fprintf(stderr, 8490 gettext("tar: cannot chmod %sfile %s to %o: %s\n"), 8491 (pdirfd == -1) ? "" : gettext("parent of "), 8492 (pdirfd == -1) ? dirp : name, newmode, strerror(errno)); 8493 } 8494 8495 if (aclp) { 8496 error = facl_set(dirfd, aclp); 8497 if (error) { 8498 (void) fprintf(stderr, 8499 gettext("tar: failed to set acl entries on " 8500 "%sfile %s\n"), 8501 (pdirfd == -1) ? "" : gettext("parent of "), 8502 (pdirfd == -1) ? dirp : name); 8503 } 8504 acl_free(aclp); 8505 } 8506 8507 /* 8508 * Put back time stamps 8509 */ 8510 8511 times[0].tv_sec = parentstat.st_atime; 8512 times[0].tv_usec = 0; 8513 times[1].tv_sec = parentstat.st_mtime; 8514 times[1].tv_usec = 0; 8515 8516 (void) futimesat(cwd, (pattr == NULL) ? dirp : pattr, times); 8517 8518 (void) close(dirfd); 8519 8520 return (ofilefd); 8521 } 8522 #endif 8523 8524 #if !defined(O_XATTR) 8525 static int 8526 openat64(int fd, const char *name, int oflag, mode_t cmode) 8527 { 8528 return (open64(name, oflag, cmode)); 8529 } 8530 8531 static int 8532 openat(int fd, const char *name, int oflag, mode_t cmode) 8533 { 8534 return (open(name, oflag, cmode)); 8535 } 8536 8537 static int 8538 fchownat(int fd, const char *name, uid_t owner, gid_t group, int flag) 8539 { 8540 if (flag == AT_SYMLINK_NOFOLLOW) 8541 return (lchown(name, owner, group)); 8542 else 8543 return (chown(name, owner, group)); 8544 } 8545 8546 static int 8547 renameat(int fromfd, char *old, int tofd, char *new) 8548 { 8549 return (rename(old, new)); 8550 } 8551 8552 static int 8553 futimesat(int fd, char *path, struct timeval times[2]) 8554 { 8555 return (utimes(path, times)); 8556 } 8557 8558 static int 8559 unlinkat(int dirfd, char *path, int flag) 8560 { 8561 if (flag == AT_REMOVEDIR) 8562 return (rmdir(path)); 8563 else 8564 return (unlink(path)); 8565 } 8566 8567 static int 8568 fstatat(int fd, char *path, struct stat *buf, int flag) 8569 { 8570 if (flag == AT_SYMLINK_NOFOLLOW) 8571 return (lstat(path, buf)); 8572 else 8573 return (stat(path, buf)); 8574 } 8575 8576 static int 8577 attropen(char *file, char *attr, int omode, mode_t cmode) 8578 { 8579 errno = ENOTSUP; 8580 return (-1); 8581 } 8582 #endif 8583 8584 static void 8585 chop_endslashes(char *path) 8586 { 8587 char *end, *ptr; 8588 8589 /* 8590 * Chop of slashes, but not if all we have is slashes 8591 * for example: //// 8592 * should make no changes, otherwise it will screw up 8593 * checkdir 8594 */ 8595 end = &path[strlen(path) -1]; 8596 if (*end == '/' && end != path) { 8597 ptr = skipslashes(end, path); 8598 if (ptr != NULL && ptr != path) { 8599 *ptr = '\0'; 8600 } 8601 } 8602 } 8603 /* Trusted Extensions */ 8604 8605 /* 8606 * append_ext_attr(): 8607 * 8608 * Append extended attributes and other information into the buffer 8609 * that gets written to the ancillary file. 8610 * 8611 * With option 'T', we create a tarfile which 8612 * has an ancillary file each corresponding archived file. 8613 * Each ancillary file contains 1 or more of the 8614 * following attributes: 8615 * 8616 * attribute type attribute process procedure 8617 * ---------------- ---------------- -------------------------- 8618 * DIR_TYPE = 'D' directory flag append if a directory 8619 * LBL_TYPE = 'L' SL[IL] or SL append ascii label 8620 * 8621 * 8622 */ 8623 static void 8624 append_ext_attr(char *shortname, char **secinfo, int *len) 8625 { 8626 bslabel_t b_slabel; /* binary sensitvity label */ 8627 char *ascii = NULL; /* ascii label */ 8628 8629 /* 8630 * For each attribute type, append it if it is 8631 * relevant to the file type. 8632 */ 8633 8634 /* 8635 * For attribute type DIR_TYPE, 8636 * append it to the following file type: 8637 * 8638 * S_IFDIR: directories 8639 */ 8640 8641 /* 8642 * For attribute type LBL_TYPE, 8643 * append it to the following file type: 8644 * 8645 * S_IFDIR: directories (including mld, sld) 8646 * S_IFLNK: symbolic link 8647 * S_IFREG: regular file but not hard link 8648 * S_IFIFO: FIFO file but not hard link 8649 * S_IFCHR: char special file but not hard link 8650 * S_IFBLK: block special file but not hard link 8651 */ 8652 switch (stbuf.st_mode & S_IFMT) { 8653 8654 case S_IFDIR: 8655 8656 /* 8657 * append DIR_TYPE 8658 */ 8659 (void) append_secattr(secinfo, len, 1, 8660 "\0", DIR_TYPE); 8661 8662 /* 8663 * Get and append attribute types LBL_TYPE. 8664 * For directories, LBL_TYPE contains SL. 8665 */ 8666 /* get binary sensitivity label */ 8667 if (getlabel(shortname, &b_slabel) != 0) { 8668 (void) fprintf(stderr, 8669 gettext("tar: can't get sensitvity label for " 8670 " %s, getlabel() error: %s\n"), 8671 shortname, strerror(errno)); 8672 } else { 8673 /* get ascii SL */ 8674 if (bsltos(&b_slabel, &ascii, 8675 0, 0) <= 0) { 8676 (void) fprintf(stderr, 8677 gettext("tar: can't get ascii SL for" 8678 " %s\n"), shortname); 8679 } else { 8680 /* append LBL_TYPE */ 8681 (void) append_secattr(secinfo, len, 8682 strlen(ascii) + 1, ascii, 8683 LBL_TYPE); 8684 8685 /* free storage */ 8686 if (ascii != NULL) { 8687 free(ascii); 8688 ascii = (char *)0; 8689 } 8690 } 8691 8692 } 8693 break; 8694 8695 case S_IFLNK: 8696 case S_IFREG: 8697 case S_IFIFO: 8698 case S_IFCHR: 8699 case S_IFBLK: 8700 8701 /* get binary sensitivity label */ 8702 if (getlabel(shortname, &b_slabel) != 0) { 8703 (void) fprintf(stderr, 8704 gettext("tar: can't get sensitivty label for %s, " 8705 "getlabel() error: %s\n"), 8706 shortname, strerror(errno)); 8707 } else { 8708 /* get ascii IL[SL] */ 8709 if (bsltos(&b_slabel, &ascii, 0, 0) <= 0) { 8710 (void) fprintf(stderr, 8711 gettext("tar: can't translate sensitivity " 8712 " label for %s\n"), shortname); 8713 } else { 8714 char *cmw_label; 8715 size_t cmw_length; 8716 8717 cmw_length = strlen("ADMIN_LOW [] ") + 8718 strlen(ascii); 8719 if ((cmw_label = malloc(cmw_length)) == NULL) { 8720 (void) fprintf(stderr, gettext( 8721 "Insufficient memory for label\n")); 8722 exit(1); 8723 } 8724 /* append LBL_TYPE */ 8725 (void) snprintf(cmw_label, cmw_length, 8726 "ADMIN_LOW [%s]", ascii); 8727 (void) append_secattr(secinfo, len, 8728 strlen(cmw_label) + 1, cmw_label, 8729 LBL_TYPE); 8730 8731 /* free storage */ 8732 if (ascii != NULL) { 8733 free(cmw_label); 8734 free(ascii); 8735 ascii = (char *)0; 8736 } 8737 } 8738 } 8739 break; 8740 8741 default: 8742 break; 8743 } /* end switch for LBL_TYPE */ 8744 8745 8746 /* DONE !! */ 8747 return; 8748 8749 } /* end of append_ext_attr */ 8750 8751 8752 /* 8753 * Name: extract_attr() 8754 * 8755 * Description: 8756 * Process attributes from the ancillary file due to 8757 * the T option. 8758 * 8759 * Call by doxtract() as part of the switch case structure. 8760 * Making this a separate routine because the nesting are too 8761 * deep in doxtract, thus, leaving very little space 8762 * on each line for instructions. 8763 * 8764 * With option 'T', we extract from a TS 8 or TS 2.5 ancillary file 8765 * 8766 * For option 'T', following are possible attributes in 8767 * a TS 8 ancillary file: (NOTE: No IL support) 8768 * 8769 * attribute type attribute process procedure 8770 * ---------------- ---------------- ------------------------- 8771 * # LBL_TYPE = 'L' SL construct binary label 8772 * # APRIV_TYPE = 'P' allowed priv construct privileges 8773 * # FPRIV_TYPE = 'p' forced priv construct privileges 8774 * # COMP_TYPE = 'C' path component construct real path 8775 * # DIR_TYPE = 'D' directory flag note it is a directory 8776 * $ UFSD_ACL = '1' ACL data construct ACL entries 8777 * ATTR_FLAG_TYPE = 'F' file attr flags construct binary flags 8778 * LK_COMP_TYPE = 'K' linked path comp construct linked real path 8779 * 8780 * note: # = attribute names common between TS 8 & TS 2.5 ancillary 8781 * files. 8782 * $ = ACL attribute is processed for the option 'p', it doesn't 8783 * need option 'T'. 8784 * 8785 * Trusted Extensions ignores APRIV_TYPE, FPRIV_TYPE, and ATTR_FLAG_TYPE 8786 * 8787 */ 8788 static void 8789 extract_attr(char **file_ptr, struct sec_attr *attr) 8790 { 8791 int reterr, err; 8792 char *dummy_buf; /* for attribute extract */ 8793 8794 dummy_buf = attr->attr_info; 8795 8796 switch (attr->attr_type) { 8797 8798 case DIR_TYPE: 8799 8800 dir_flag++; 8801 break; 8802 8803 case LBL_TYPE: 8804 8805 /* 8806 * LBL_TYPE is used to indicate SL for directory, and 8807 * CMW label for other file types. 8808 */ 8809 8810 if (!dir_flag) { /* not directory */ 8811 /* Skip over IL portion */ 8812 char *sl_ptr = strchr(dummy_buf, '['); 8813 8814 if (sl_ptr == NULL) 8815 err = 0; 8816 else 8817 err = stobsl(sl_ptr, &bs_label, 8818 NEW_LABEL, &reterr); 8819 } else { /* directory */ 8820 err = stobsl(dummy_buf, &bs_label, 8821 NEW_LABEL, &reterr); 8822 } 8823 if (err == 0) { 8824 (void) fprintf(stderr, gettext("tar: " 8825 "can't convert %s to binary label\n"), 8826 dummy_buf); 8827 bslundef(&bs_label); 8828 } else if (!blequal(&bs_label, &admin_low) && 8829 !blequal(&bs_label, &admin_high)) { 8830 bslabel_t *from_label; 8831 char *buf; 8832 char tempbuf[MAXPATHLEN]; 8833 8834 if (*orig_namep != '/') { 8835 /* got relative linked to path */ 8836 (void) getcwd(tempbuf, (sizeof (tempbuf))); 8837 (void) strncat(tempbuf, "/", MAXPATHLEN); 8838 } else 8839 *tempbuf = '\0'; 8840 8841 buf = real_path; 8842 (void) strncat(tempbuf, orig_namep, MAXPATHLEN); 8843 from_label = getlabelbypath(tempbuf); 8844 if (from_label != NULL) { 8845 if (blequal(from_label, &admin_low)) { 8846 if ((getpathbylabel(tempbuf, buf, 8847 MAXPATHLEN, &bs_label) == NULL)) { 8848 (void) fprintf(stderr, 8849 gettext("tar: " 8850 "can't get zone root path for " 8851 "%s\n"), tempbuf); 8852 } else 8853 rpath_flag = 1; 8854 } 8855 free(from_label); 8856 } 8857 } 8858 break; 8859 8860 case COMP_TYPE: 8861 8862 rebuild_comp_path(dummy_buf, file_ptr); 8863 break; 8864 8865 case LK_COMP_TYPE: 8866 8867 if (rebuild_lk_comp_path(dummy_buf, file_ptr) 8868 == 0) { 8869 lk_rpath_flag = 1; 8870 } else { 8871 (void) fprintf(stderr, gettext("tar: warning: link's " 8872 "target pathname might be invalid.\n")); 8873 lk_rpath_flag = 0; 8874 } 8875 break; 8876 case APRIV_TYPE: 8877 ignored_aprivs++; 8878 break; 8879 case FPRIV_TYPE: 8880 ignored_fprivs++; 8881 break; 8882 case ATTR_FLAG_TYPE: 8883 ignored_fattrs++; 8884 break; 8885 8886 default: 8887 8888 break; 8889 } 8890 8891 /* done */ 8892 return; 8893 8894 } /* end extract_attr */ 8895 8896 8897 8898 /* 8899 * Name: rebuild_comp_path() 8900 * 8901 * Description: 8902 * Take the string of components passed down by the calling 8903 * routine and parse the values and rebuild the path. 8904 * This routine no longer needs to produce a new real_path 8905 * string because it is produced when the 'L' LABEL_TYPE is 8906 * interpreted. So the only thing done here is to distinguish 8907 * between an SLD and an MLD entry. We only want one, so we 8908 * ignore the MLD entry by setting the mld_flag. 8909 * 8910 * return value: 8911 * none 8912 */ 8913 static void 8914 rebuild_comp_path(char *str, char **namep) 8915 { 8916 char *cp; 8917 8918 while (*str != '\0') { 8919 8920 switch (*str) { 8921 8922 case MLD_TYPE: 8923 8924 str++; 8925 if ((cp = strstr(str, ";;")) != NULL) { 8926 *cp = '\0'; 8927 str = cp + 2; 8928 *cp = ';'; 8929 } 8930 mld_flag = 1; 8931 break; 8932 8933 case SLD_TYPE: 8934 8935 str++; 8936 if ((cp = strstr(str, ";;")) != NULL) { 8937 *cp = '\0'; 8938 str = cp + 2; 8939 *cp = ';'; 8940 } 8941 mld_flag = 0; 8942 break; 8943 8944 case PATH_TYPE: 8945 8946 str++; 8947 if ((cp = strstr(str, ";;")) != NULL) { 8948 *cp = '\0'; 8949 str = cp + 2; 8950 *cp = ';'; 8951 } 8952 break; 8953 } 8954 } 8955 if (rpath_flag) 8956 *namep = real_path; 8957 return; 8958 8959 } /* end rebuild_comp_path() */ 8960 8961 /* 8962 * Name: rebuild_lk_comp_path() 8963 * 8964 * Description: 8965 * Take the string of components passed down by the calling 8966 * routine and parse the values and rebuild the path. 8967 * 8968 * return value: 8969 * 0 = succeeded 8970 * -1 = failed 8971 */ 8972 static int 8973 rebuild_lk_comp_path(char *str, char **namep) 8974 { 8975 char *cp; 8976 int reterr; 8977 bslabel_t bslabel; 8978 char *buf; 8979 char pbuf[MAXPATHLEN]; 8980 char *ptr1, *ptr2; 8981 int plen; 8982 int use_pbuf; 8983 char tempbuf[MAXPATHLEN]; 8984 int mismatch; 8985 bslabel_t *from_label; 8986 char zonename[ZONENAME_MAX]; 8987 zoneid_t zoneid; 8988 8989 /* init stuff */ 8990 use_pbuf = 0; 8991 mismatch = 0; 8992 8993 /* 8994 * For linked to pathname (LK_COMP_TYPE): 8995 * - If the linked to pathname is absolute (start with /), we 8996 * will use it as is. 8997 * - If it is a relative pathname then it is relative to 1 of 2 8998 * directories. For a hardlink, it is relative to the current 8999 * directory. For a symbolic link, it is relative to the 9000 * directory the symbolic link is in. For the symbolic link 9001 * case, set a flag to indicate we need to use the prefix of 9002 * the restored file's pathname with the linked to pathname. 9003 * 9004 * NOTE: At this point, we have no way to determine if we have 9005 * a hardlink or a symbolic link. We will compare the 1st 9006 * component in the prefix portion of the restore file's 9007 * pathname to the 1st component in the attribute data 9008 * (the linked pathname). If they are the same, we will assume 9009 * the link pathname to reconstruct is relative to the current 9010 * directory. Otherwise, we will set a flag indicate we need 9011 * to use a prefix with the reconstructed name. Need to compare 9012 * both the adorned and unadorned version before deciding a 9013 * mismatch. 9014 */ 9015 9016 buf = lk_real_path; 9017 if (*(str + 1) != '/') { /* got relative linked to path */ 9018 ptr1 = orig_namep; 9019 ptr2 = strrchr(ptr1, '/'); 9020 plen = ptr2 - ptr1; 9021 if (plen > 0) { 9022 pbuf[0] = '\0'; 9023 plen++; /* include '/' */ 9024 (void) strncpy(pbuf, ptr1, plen); 9025 *(pbuf + plen) = '\0'; 9026 ptr2 = strchr(pbuf, '/'); 9027 if (strncmp(pbuf, str + 1, ptr2 - pbuf) != 0) 9028 mismatch = 1; 9029 } 9030 9031 if (mismatch == 1) 9032 use_pbuf = 1; 9033 } 9034 9035 buf[0] = '\0'; 9036 9037 while (*str != '\0') { 9038 9039 switch (*str) { 9040 9041 case MLD_TYPE: 9042 9043 str++; 9044 if ((cp = strstr(str, ";;")) != NULL) { 9045 *cp = '\0'; 9046 9047 /* 9048 * Ignore attempts to backup over .MLD. 9049 */ 9050 if (strcmp(str, "../") != 0) 9051 (void) strncat(buf, str, MAXPATHLEN); 9052 str = cp + 2; 9053 *cp = ';'; 9054 } 9055 break; 9056 9057 case SLD_TYPE: 9058 9059 str++; 9060 if ((cp = strstr(str, ";;")) != NULL) { 9061 *cp = '\0'; 9062 9063 /* 9064 * Use the path name in the header if 9065 * error occurs when processing the 9066 * SLD type. 9067 */ 9068 9069 if (!stobsl(str, &bslabel, 9070 NO_CORRECTION, &reterr)) { 9071 (void) fprintf(stderr, gettext( 9072 "tar: can't translate to binary" 9073 "SL for SLD, stobsl() error:" 9074 " %s\n"), strerror(errno)); 9075 return (-1); 9076 } 9077 9078 str = cp + 2; 9079 *cp = ';'; 9080 9081 if (use_pbuf == 1) { 9082 if (*pbuf != '/') { 9083 /* relative linked to path */ 9084 9085 (void) getcwd(tempbuf, 9086 (sizeof (tempbuf))); 9087 (void) strncat(tempbuf, "/", 9088 MAXPATHLEN); 9089 (void) strncat(tempbuf, pbuf, 9090 MAXPATHLEN); 9091 } 9092 else 9093 (void) strcpy(tempbuf, pbuf); 9094 9095 } else if (*buf != '/') { 9096 /* got relative linked to path */ 9097 9098 (void) getcwd(tempbuf, 9099 (sizeof (tempbuf))); 9100 (void) strncat(tempbuf, "/", 9101 MAXPATHLEN); 9102 } else 9103 *tempbuf = '\0'; 9104 9105 (void) strncat(tempbuf, buf, MAXPATHLEN); 9106 *buf = '\0'; 9107 9108 if (blequal(&bslabel, &admin_high)) { 9109 bslabel = admin_low; 9110 } 9111 9112 9113 /* 9114 * Check for cross-zone symbolic links 9115 */ 9116 from_label = getlabelbypath(real_path); 9117 if (rpath_flag && (from_label != NULL) && 9118 !blequal(&bslabel, from_label)) { 9119 if ((zoneid = 9120 getzoneidbylabel(&bslabel)) == -1) { 9121 (void) fprintf(stderr, 9122 gettext("tar: can't get " 9123 "zone ID for %s\n"), 9124 tempbuf); 9125 return (-1); 9126 } 9127 if (zone_getattr(zoneid, ZONE_ATTR_NAME, 9128 &zonename, ZONENAME_MAX) == -1) { 9129 /* Badly configured zone info */ 9130 (void) fprintf(stderr, 9131 gettext("tar: can't get " 9132 "zonename for %s\n"), 9133 tempbuf); 9134 return (-1); 9135 } 9136 (void) strncpy(buf, AUTO_ZONE, 9137 MAXPATHLEN); 9138 (void) strncat(buf, "/", 9139 MAXPATHLEN); 9140 (void) strncat(buf, zonename, 9141 MAXPATHLEN); 9142 } 9143 if (from_label != NULL) 9144 free(from_label); 9145 (void) strncat(buf, tempbuf, MAXPATHLEN); 9146 break; 9147 } 9148 mld_flag = 0; 9149 break; 9150 9151 case PATH_TYPE: 9152 9153 str++; 9154 if ((cp = strstr(str, ";;")) != NULL) { 9155 *cp = '\0'; 9156 (void) strncat(buf, str, MAXPATHLEN); 9157 str = cp + 2; 9158 *cp = ';'; 9159 } 9160 break; 9161 9162 default: 9163 9164 (void) fprintf(stderr, gettext( 9165 "tar: error rebuilding path %s\n"), 9166 *namep); 9167 *buf = '\0'; 9168 str++; 9169 return (-1); 9170 } 9171 } 9172 9173 /* 9174 * Done for LK_COMP_TYPE 9175 */ 9176 9177 return (0); /* component path is rebuilt successfully */ 9178 9179 } /* end rebuild_lk_comp_path() */ 9180 9181 /* 9182 * Name: check_ext_attr() 9183 * 9184 * Description: 9185 * Check the extended attributes for a file being extracted. 9186 * The attributes being checked here are CMW labels. 9187 * ACLs are not set here because they are set by the 9188 * pflag in doxtract(). 9189 * 9190 * If the label doesn't match, return 0 9191 * else return 1 9192 */ 9193 static int 9194 check_ext_attr(char *filename) 9195 { 9196 bslabel_t currentlabel; /* label from zone */ 9197 9198 if (bltype(&bs_label, SUN_SL_UN)) { 9199 /* No label check possible */ 9200 return (0); 9201 } 9202 if (getlabel(filename, ¤tlabel) != 0) { 9203 (void) fprintf(stderr, 9204 gettext("tar: can't get label for " 9205 " %s, getlabel() error: %s\n"), 9206 filename, strerror(errno)); 9207 return (0); 9208 } else if ((blequal(¤tlabel, &bs_label)) == 0) { 9209 char *src_label = NULL; /* ascii label */ 9210 9211 /* get current src SL */ 9212 if (bsltos(&bs_label, &src_label, 0, 0) <= 0) { 9213 (void) fprintf(stderr, 9214 gettext("tar: can't interpret requested label for" 9215 " %s\n"), filename); 9216 } else { 9217 (void) fprintf(stderr, 9218 gettext("tar: can't apply label %s to %s\n"), 9219 src_label, filename); 9220 free(src_label); 9221 } 9222 (void) fprintf(stderr, 9223 gettext("tar: %s not restored\n"), filename); 9224 return (0); 9225 } 9226 return (1); 9227 9228 } /* end check_ext_attr */ 9229 9230 /* Compressing a tar file using compression method provided in 'opt' */ 9231 9232 static void 9233 compress_back() 9234 { 9235 pid_t pid; 9236 9237 if (vflag) { 9238 (void) fprintf(vfile, 9239 gettext("Compressing '%s' with '%s'...\n"), 9240 usefile, compress_opt); 9241 } 9242 if ((pid = fork()) == 0) { 9243 verify_compress_opt(compress_opt); 9244 (void) execlp(compress_opt, compress_opt, 9245 usefile, NULL); 9246 } else if (pid == -1) { 9247 vperror(1, "%s", gettext("Could not fork")); 9248 } 9249 wait_pid(pid); 9250 if (suffix == 0) { 9251 (void) rename(tfname, usefile); 9252 } 9253 } 9254 9255 /* The magic numbers from /etc/magic */ 9256 9257 #define GZIP_MAGIC "\037\213" 9258 #define BZIP_MAGIC "BZh" 9259 #define COMP_MAGIC "\037\235" 9260 #define XZ_MAGIC "\375\067\172\130\132\000" 9261 9262 void 9263 check_compression(void) 9264 { 9265 char magic[16]; 9266 FILE *fp; 9267 9268 if ((fp = fopen(usefile, "r")) != NULL) { 9269 (void) fread(magic, sizeof (char), 6, fp); 9270 (void) fclose(fp); 9271 } 9272 9273 if (memcmp(magic, GZIP_MAGIC, 2) == 0) { 9274 if (xflag || tflag) { 9275 compress_opt = compress_malloc(strlen(GZCAT) + 1); 9276 (void) strcpy(compress_opt, GZCAT); 9277 } else if (uflag || rflag) { 9278 compress_opt = compress_malloc(strlen(GZIP) + 1); 9279 (void) strcpy(compress_opt, GZIP); 9280 } 9281 } else if (memcmp(magic, BZIP_MAGIC, 2) == 0) { 9282 if (xflag || tflag) { 9283 compress_opt = compress_malloc(strlen(BZCAT) + 1); 9284 (void) strcpy(compress_opt, BZCAT); 9285 } else if (uflag || rflag) { 9286 compress_opt = compress_malloc(strlen(BZIP) + 1); 9287 (void) strcpy(compress_opt, BZIP); 9288 } 9289 } else if (memcmp(magic, COMP_MAGIC, 2) == 0) { 9290 if (xflag || tflag) { 9291 compress_opt = compress_malloc(strlen(ZCAT) + 1); 9292 (void) strcpy(compress_opt, ZCAT); 9293 } else if (uflag || rflag) { 9294 compress_opt = compress_malloc(strlen(COMPRESS) + 1); 9295 (void) strcpy(compress_opt, COMPRESS); 9296 } 9297 } else if (memcmp(magic, XZ_MAGIC, 6) == 0) { 9298 if (xflag || tflag) { 9299 compress_opt = compress_malloc(strlen(XZCAT) + 1); 9300 (void) strcpy(compress_opt, XZCAT); 9301 } else if (uflag || rflag) { 9302 compress_opt = compress_malloc(strlen(XZ) + 1); 9303 (void) strcpy(compress_opt, XZ); 9304 } 9305 } 9306 } 9307 9308 char * 9309 add_suffix() 9310 { 9311 (void) strcpy(tfname, usefile); 9312 if (strcmp(compress_opt, GZIP) == 0) { 9313 if ((suffix = gz_suffix()) == NULL) { 9314 strlcat(tfname, gsuffix[0], sizeof (tfname)); 9315 return (gsuffix[0]); 9316 } 9317 } else if (strcmp(compress_opt, COMPRESS) == 0) { 9318 if ((suffix = gz_suffix()) == NULL) { 9319 strlcat(tfname, gsuffix[6], sizeof (tfname)); 9320 return (gsuffix[6]); 9321 } 9322 } else if (strcmp(compress_opt, BZIP) == 0) { 9323 if ((suffix = bz_suffix()) == NULL) { 9324 strlcat(tfname, bsuffix[0], sizeof (tfname)); 9325 return (bsuffix[0]); 9326 } 9327 } else if (strcmp(compress_opt, XZ) == 0) { 9328 if ((suffix = xz_suffix()) == NULL) { 9329 strlcat(tfname, xsuffix[0], sizeof (tfname)); 9330 return (xsuffix[0]); 9331 } 9332 } 9333 return (NULL); 9334 } 9335 9336 /* Decompressing a tar file using compression method from the file type */ 9337 void 9338 decompress_file(void) 9339 { 9340 pid_t pid; 9341 char *added_suffix; 9342 9343 9344 added_suffix = add_suffix(); 9345 if (added_suffix != NULL) { 9346 (void) rename(usefile, tfname); 9347 } 9348 if ((pid = fork()) == 0) { 9349 if (vflag) { 9350 (void) fprintf(vfile, 9351 gettext("Decompressing '%s' with " 9352 "'%s'...\n"), usefile, compress_opt); 9353 } 9354 verify_compress_opt(compress_opt); 9355 (void) execlp(compress_opt, compress_opt, "-df", 9356 tfname, NULL); 9357 vperror(1, gettext("Could not exec %s"), compress_opt); 9358 } else if (pid == -1) { 9359 vperror(1, gettext("Could not fork")); 9360 } 9361 wait_pid(pid); 9362 if (suffix != NULL) { 9363 /* restore the file name - original file was without suffix */ 9364 *(usefile + strlen(usefile) - strlen(suffix)) = '\0'; 9365 } 9366 } 9367 9368 /* Set the archive for writing and then compress the archive */ 9369 pid_t 9370 compress_file(void) 9371 { 9372 int fd[2]; 9373 pid_t pid; 9374 9375 if (vflag) { 9376 (void) fprintf(vfile, gettext("Compressing '%s' with " 9377 "'%s'...\n"), usefile, compress_opt); 9378 } 9379 9380 if (pipe(fd) < 0) { 9381 vperror(1, gettext("Could not create pipe")); 9382 } 9383 if ((pid = fork()) > 0) { 9384 mt = fd[1]; 9385 (void) close(fd[0]); 9386 return (pid); 9387 } 9388 /* child */ 9389 (void) dup2(fd[0], STDIN_FILENO); 9390 (void) close(fd[1]); 9391 (void) dup2(mt, STDOUT_FILENO); 9392 verify_compress_opt(compress_opt); 9393 (void) execlp(compress_opt, compress_opt, NULL); 9394 vperror(1, gettext("Could not exec %s"), compress_opt); 9395 return (0); /*NOTREACHED*/ 9396 } 9397 9398 pid_t 9399 uncompress_file(void) 9400 { 9401 int fd[2]; 9402 pid_t pid; 9403 9404 if (vflag) { 9405 (void) fprintf(vfile, gettext("Decompressing '%s' with " 9406 "'%s'...\n"), usefile, compress_opt); 9407 } 9408 9409 if (pipe(fd) < 0) { 9410 vperror(1, gettext("Could not create pipe")); 9411 } 9412 if ((pid = fork()) > 0) { 9413 mt = fd[0]; 9414 (void) close(fd[1]); 9415 return (pid); 9416 } 9417 /* child */ 9418 (void) dup2(fd[1], STDOUT_FILENO); 9419 (void) close(fd[0]); 9420 (void) dup2(mt, STDIN_FILENO); 9421 verify_compress_opt(compress_opt); 9422 (void) execlp(compress_opt, compress_opt, NULL); 9423 vperror(1, gettext("Could not exec %s"), compress_opt); 9424 return (0); /*NOTREACHED*/ 9425 } 9426 9427 /* Checking suffix validity */ 9428 char * 9429 check_suffix(char **suf, int size) 9430 { 9431 int i; 9432 int slen; 9433 int nlen = strlen(usefile); 9434 9435 for (i = 0; i < size; i++) { 9436 slen = strlen(suf[i]); 9437 if (nlen < slen) 9438 return (NULL); 9439 if (strcmp(usefile + nlen - slen, suf[i]) == 0) 9440 return (suf[i]); 9441 } 9442 return (NULL); 9443 } 9444 9445 /* Checking valid 'bzip2' suffix */ 9446 char * 9447 bz_suffix(void) 9448 { 9449 return (check_suffix(bsuffix, BSUF)); 9450 } 9451 9452 /* Checking valid 'gzip' suffix */ 9453 char * 9454 gz_suffix(void) 9455 { 9456 return (check_suffix(gsuffix, GSUF)); 9457 } 9458 9459 /* Checking valid 'xz' suffix */ 9460 char * 9461 xz_suffix(void) 9462 { 9463 return (check_suffix(xsuffix, XSUF)); 9464 } 9465 9466 void * 9467 compress_malloc(size_t size) 9468 { 9469 void *opt; 9470 9471 if ((opt = malloc(size)) == NULL) { 9472 vperror(1, "%s", 9473 gettext("Could not allocate compress buffer\n")); 9474 } 9475 return (opt); 9476 } 9477 9478 void 9479 wait_pid(pid_t pid) 9480 { 9481 int status; 9482 9483 while (waitpid(pid, &status, 0) == -1 && errno == EINTR) 9484 ; 9485 } 9486 9487 static void 9488 verify_compress_opt(const char *t) 9489 { 9490 struct stat statbuf; 9491 9492 if (stat(t, &statbuf) == -1) 9493 vperror(1, "%s %s: %s\n", gettext("Could not stat"), 9494 t, strerror(errno)); 9495 } 9496 9497 static void 9498 detect_compress(void) 9499 { 9500 char *zsuf[] = {".Z"}; 9501 if (check_suffix(zsuf, 1) != NULL) { 9502 Zflag = 1; 9503 } else if (check_suffix(bsuffix, BSUF) != NULL) { 9504 jflag = 1; 9505 } else if (check_suffix(gsuffix, GSUF) != NULL) { 9506 zflag = 1; 9507 } else if (check_suffix(xsuffix, XSUF) != NULL) { 9508 Jflag = 1; 9509 } else { 9510 vperror(1, "%s\n", gettext("No compression method detected")); 9511 } 9512 } 9513