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", 0, 0);
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 }