17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
53a3e214eSceastha * Common Development and Distribution License (the "License").
63a3e214eSceastha * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
217c478bd9Sstevel@tonic-gate /*
2261694e45SRich Burridge * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
2333f5ff17SMilan Jurik * Copyright 2012 Milan Jurik. All rights reserved.
24b0ee9efaSGary Mills * Copyright (c) 2012 Gary Mills
257c478bd9Sstevel@tonic-gate */
267c478bd9Sstevel@tonic-gate
277c478bd9Sstevel@tonic-gate /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
287c478bd9Sstevel@tonic-gate /* All Rights Reserved */
297c478bd9Sstevel@tonic-gate
307c478bd9Sstevel@tonic-gate /*
31*6d3b960aSAndy Fiddaman * Copyright 2022 OmniOS Community Edition (OmniOSce) Association.
32*6d3b960aSAndy Fiddaman */
33*6d3b960aSAndy Fiddaman
34*6d3b960aSAndy Fiddaman /*
357c478bd9Sstevel@tonic-gate * Portions of this source code were derived from Berkeley 4.3 BSD
367c478bd9Sstevel@tonic-gate * under license from the Regents of the University of California.
377c478bd9Sstevel@tonic-gate */
387c478bd9Sstevel@tonic-gate
397c478bd9Sstevel@tonic-gate #include <stdio.h>
407c478bd9Sstevel@tonic-gate #include <sys/types.h>
417c478bd9Sstevel@tonic-gate #include <errno.h>
427c478bd9Sstevel@tonic-gate #include <unistd.h>
437c478bd9Sstevel@tonic-gate #include <stdlib.h>
447c478bd9Sstevel@tonic-gate #include <fcntl.h>
457c478bd9Sstevel@tonic-gate #include <memory.h>
467c478bd9Sstevel@tonic-gate #include <string.h>
477c478bd9Sstevel@tonic-gate #include <stdarg.h>
487c478bd9Sstevel@tonic-gate #include <sys/stat.h>
497c478bd9Sstevel@tonic-gate #include <sys/statvfs.h>
507c478bd9Sstevel@tonic-gate #include <sys/mkdev.h>
517c478bd9Sstevel@tonic-gate #include <sys/param.h>
527c478bd9Sstevel@tonic-gate #include <utime.h>
537c478bd9Sstevel@tonic-gate #include <pwd.h>
547c478bd9Sstevel@tonic-gate #include <grp.h>
557c478bd9Sstevel@tonic-gate #include <signal.h>
567c478bd9Sstevel@tonic-gate #include <ctype.h>
577c478bd9Sstevel@tonic-gate #include <locale.h>
587c478bd9Sstevel@tonic-gate #include <sys/ioctl.h>
597c478bd9Sstevel@tonic-gate #include <sys/mtio.h>
607c478bd9Sstevel@tonic-gate #include <sys/fdio.h>
617c478bd9Sstevel@tonic-gate #include "cpio.h"
627c478bd9Sstevel@tonic-gate #include <sys/acl.h>
637c478bd9Sstevel@tonic-gate #include <sys/time.h>
647c478bd9Sstevel@tonic-gate #include <sys/resource.h>
657c478bd9Sstevel@tonic-gate #include <fnmatch.h>
667c478bd9Sstevel@tonic-gate #include <libgen.h>
677c478bd9Sstevel@tonic-gate #include <libintl.h>
687c478bd9Sstevel@tonic-gate #include <dirent.h>
697c478bd9Sstevel@tonic-gate #include <limits.h>
70fa9e4066Sahrens #include <aclutils.h>
71ced83f9bSceastha #if defined(_PC_SATTR_ENABLED)
72ced83f9bSceastha #include <libnvpair.h>
73ced83f9bSceastha #include <attr.h>
74ced83f9bSceastha #include <libcmdutils.h>
75ced83f9bSceastha #endif /* _PC_SATTR_ENABLED */
76647ab8f4Sceastha #ifdef SOLARIS_PRIVS
77647ab8f4Sceastha #include <priv.h>
78647ab8f4Sceastha #endif /* SOLARIS_PRIVS */
797c478bd9Sstevel@tonic-gate
807c478bd9Sstevel@tonic-gate /*
817c478bd9Sstevel@tonic-gate * Special kludge for off_t being a signed quantity.
827c478bd9Sstevel@tonic-gate */
837c478bd9Sstevel@tonic-gate typedef ulong_t u_off_t;
847c478bd9Sstevel@tonic-gate
857c478bd9Sstevel@tonic-gate #define SECMODE 0xe080
867c478bd9Sstevel@tonic-gate
877c478bd9Sstevel@tonic-gate #define DEVNULL "/dev/null"
887c478bd9Sstevel@tonic-gate #define XATTRHDR ".hdr"
897c478bd9Sstevel@tonic-gate
907c478bd9Sstevel@tonic-gate #define NAMELEN 32
917c478bd9Sstevel@tonic-gate #define TYPELEN 16
927c478bd9Sstevel@tonic-gate #define PERMLEN 4
937c478bd9Sstevel@tonic-gate
947c478bd9Sstevel@tonic-gate #define FILE_COPIED 1
957c478bd9Sstevel@tonic-gate #define FILE_LINKED 2
967c478bd9Sstevel@tonic-gate #define FILE_PASS_ERR -1
977c478bd9Sstevel@tonic-gate
987c478bd9Sstevel@tonic-gate #define ARCHIVE_NORMAL 0
997c478bd9Sstevel@tonic-gate #define ARCHIVE_ACL 1
1007c478bd9Sstevel@tonic-gate #define ARCHIVE_XATTR 2
1015fbb8099SNobutomo Nakano #define ARCHIVE_SPARSE 3
1027c478bd9Sstevel@tonic-gate
103ced83f9bSceastha #ifndef VIEW_READONLY
104ced83f9bSceastha #define VIEW_READONLY "SUNWattr_ro"
105ced83f9bSceastha #endif
106ced83f9bSceastha
107ced83f9bSceastha #ifndef VIEW_READWRITE
108ced83f9bSceastha #define VIEW_READWRITE "SUNWattr_rw"
109ced83f9bSceastha #endif
110ced83f9bSceastha
111ced83f9bSceastha
1127c478bd9Sstevel@tonic-gate #define LSTAT(dir, path, statbuf) fstatat(dir, \
113ced83f9bSceastha get_component((Gen.g_attrnam_p == NULL) ? \
1147c478bd9Sstevel@tonic-gate path : Gen.g_attrnam_p), statbuf, AT_SYMLINK_NOFOLLOW)
1157c478bd9Sstevel@tonic-gate #define STAT(dir, path, statbuf) fstatat(dir, \
116ced83f9bSceastha get_component((Gen.g_attrnam_p == NULL) ? \
1177c478bd9Sstevel@tonic-gate path : Gen.g_attrnam_p), statbuf, 0)
1187c478bd9Sstevel@tonic-gate
1197c478bd9Sstevel@tonic-gate /*
120*6d3b960aSAndy Fiddaman * Convert from and to old dev_t formats.
121*6d3b960aSAndy Fiddaman */
122*6d3b960aSAndy Fiddaman #define SVR3_MAJOR(x) ((major_t)((dev_t)(x) >> ONBITSMINOR) & OMAXMAJ)
123*6d3b960aSAndy Fiddaman #define SVR3_MINOR(x) ((minor_t)((dev_t)(x) & OMAXMIN))
124*6d3b960aSAndy Fiddaman #define TO_SVR3(maj, min) \
125*6d3b960aSAndy Fiddaman ((((ushort_t)(maj) & OMAXMAJ) << ONBITSMINOR) | \
126*6d3b960aSAndy Fiddaman ((ushort_t)(min) & OMAXMIN))
127*6d3b960aSAndy Fiddaman
128*6d3b960aSAndy Fiddaman /*
1297c478bd9Sstevel@tonic-gate * These limits reflect the maximum size regular file that
1307c478bd9Sstevel@tonic-gate * can be archived, depending on the archive type. For archives
1317c478bd9Sstevel@tonic-gate * with character-format headers (odc, tar, ustar) we use
132944d83a0Schin * CHAR_OFFSET_MAX. For archives with SVR4 ASCII headers (-c, -H crc)
133944d83a0Schin * we store filesize in an 8-char hexadecimal string and use
134944d83a0Schin * ASC_OFFSET_MAX. Otherwise, we are limited to the size that will
135*6d3b960aSAndy Fiddaman * fit in a signed int value.
1367c478bd9Sstevel@tonic-gate */
137944d83a0Schin #define CHAR_OFFSET_MAX 077777777777ULL /* 11 octal digits */
138944d83a0Schin #define ASC_OFFSET_MAX 0XFFFFFFFF /* 8 hexadecimal digits */
139*6d3b960aSAndy Fiddaman #define BIN_OFFSET_MAX INT_MAX /* signed int max value */
1407c478bd9Sstevel@tonic-gate
141d2443e76Smarks #define POSIXMODES 07777
142d2443e76Smarks
1437c478bd9Sstevel@tonic-gate static char aclchar = ' ';
1447c478bd9Sstevel@tonic-gate
1457c478bd9Sstevel@tonic-gate static struct Lnk *add_lnk(struct Lnk **);
1467c478bd9Sstevel@tonic-gate static int bfill(void);
1477c478bd9Sstevel@tonic-gate static void bflush(void);
1487c478bd9Sstevel@tonic-gate static int chgreel(int dir);
1497c478bd9Sstevel@tonic-gate static int ckname(int);
1507c478bd9Sstevel@tonic-gate static void ckopts(long mask);
151*6d3b960aSAndy Fiddaman static uint_t cksum(char hdr, int byt_cnt, int *err);
1527c478bd9Sstevel@tonic-gate static int creat_hdr(void);
1537c478bd9Sstevel@tonic-gate static int creat_lnk(int dirfd, char *name1_p, char *name2_p);
1547c478bd9Sstevel@tonic-gate static int creat_spec(int dirfd);
1557c478bd9Sstevel@tonic-gate static int creat_tmp(char *nam_p);
1567c478bd9Sstevel@tonic-gate static void data_in(int proc_mode);
1577c478bd9Sstevel@tonic-gate static void data_out(void);
1587c478bd9Sstevel@tonic-gate static void data_pass(void);
1597c478bd9Sstevel@tonic-gate static void file_in(void);
1607c478bd9Sstevel@tonic-gate static int file_out(void);
1617c478bd9Sstevel@tonic-gate static int file_pass(void);
1627c478bd9Sstevel@tonic-gate static void flush_lnks(void);
1637c478bd9Sstevel@tonic-gate static int gethdr(void);
1647c478bd9Sstevel@tonic-gate static int getname(void);
1657c478bd9Sstevel@tonic-gate static void getpats(int largc, char **largv);
1667c478bd9Sstevel@tonic-gate static void ioerror(int dir);
1677c478bd9Sstevel@tonic-gate static int matched(void);
1687c478bd9Sstevel@tonic-gate static int missdir(char *nam_p);
1697c478bd9Sstevel@tonic-gate static long mklong(short v[]);
1707c478bd9Sstevel@tonic-gate static void mkshort(short sval[], long v);
1717c478bd9Sstevel@tonic-gate static int openout(int dirfd);
1727c478bd9Sstevel@tonic-gate static int read_hdr(int hdr);
1737c478bd9Sstevel@tonic-gate static void reclaim(struct Lnk *l_p);
1747c478bd9Sstevel@tonic-gate static void rstbuf(void);
1757c478bd9Sstevel@tonic-gate static void setpasswd(char *nam);
1767c478bd9Sstevel@tonic-gate static void rstfiles(int over, int dirfd);
1777c478bd9Sstevel@tonic-gate static void scan4trail(void);
1787c478bd9Sstevel@tonic-gate static void setup(int largc, char **largv);
1797c478bd9Sstevel@tonic-gate static void set_tym(int dirfd, char *nam_p, time_t atime, time_t mtime);
1807c478bd9Sstevel@tonic-gate static void sigint(int sig);
1817c478bd9Sstevel@tonic-gate static void swap(char *buf_p, int cnt);
1827c478bd9Sstevel@tonic-gate static void usage(void);
1837c478bd9Sstevel@tonic-gate static void verbose(char *nam_p);
1845fbb8099SNobutomo Nakano static void write_hdr(int arcflag, off_t len);
1857c478bd9Sstevel@tonic-gate static void write_trail(void);
1867c478bd9Sstevel@tonic-gate static int ustar_dir(void);
1877c478bd9Sstevel@tonic-gate static int ustar_spec(void);
1887c478bd9Sstevel@tonic-gate static struct stat *convert_to_old_stat(struct stat *, char *, char *);
1897c478bd9Sstevel@tonic-gate static void read_bar_vol_hdr(void);
1907c478bd9Sstevel@tonic-gate static void read_bar_file_hdr(void);
1917c478bd9Sstevel@tonic-gate static void setup_uncompress(FILE **);
1927c478bd9Sstevel@tonic-gate static void skip_bar_volhdr(void);
1937c478bd9Sstevel@tonic-gate static void bar_file_in(void);
1947c478bd9Sstevel@tonic-gate static int g_init(int *devtype, int *fdes);
1957c478bd9Sstevel@tonic-gate static int g_read(int, int, char *, unsigned);
1967c478bd9Sstevel@tonic-gate static int g_write(int, int, char *, unsigned);
1977c478bd9Sstevel@tonic-gate static int is_floppy(int);
1987c478bd9Sstevel@tonic-gate static int is_tape(int);
1995fbb8099SNobutomo Nakano static void write_ancillary(char *buf, size_t len, boolean_t padding);
2007c478bd9Sstevel@tonic-gate static int remove_dir(char *);
2017c478bd9Sstevel@tonic-gate static int save_cwd(void);
2027c478bd9Sstevel@tonic-gate static void rest_cwd(int cwd);
2037c478bd9Sstevel@tonic-gate
2047c478bd9Sstevel@tonic-gate static void xattrs_out(int (*func)());
2057c478bd9Sstevel@tonic-gate static void get_parent(char *path, char *dir);
2067c478bd9Sstevel@tonic-gate static void prepare_xattr_hdr(char **attrbuf, char *filename,
2077c478bd9Sstevel@tonic-gate char *attrname, char typeflag, struct Lnk *linkinfo, int *rlen);
2087c478bd9Sstevel@tonic-gate static char tartype(int type);
2097c478bd9Sstevel@tonic-gate static int openfile(int omode);
2107c478bd9Sstevel@tonic-gate static mode_t attrmode(char type);
2117c478bd9Sstevel@tonic-gate static char *get_component(char *path);
2127c478bd9Sstevel@tonic-gate static int open_dir(char *name);
2137c478bd9Sstevel@tonic-gate static int open_dirfd();
2147c478bd9Sstevel@tonic-gate static void close_dirfd();
2157c478bd9Sstevel@tonic-gate static void write_xattr_hdr();
2167c478bd9Sstevel@tonic-gate static char *skipslashes(char *string, char *start);
2177c478bd9Sstevel@tonic-gate static int read_xattr_hdr();
2187c478bd9Sstevel@tonic-gate static void chop_endslashes(char *path);
2197c478bd9Sstevel@tonic-gate
2207c478bd9Sstevel@tonic-gate
2217c478bd9Sstevel@tonic-gate /* helpful types */
2227c478bd9Sstevel@tonic-gate
2237c478bd9Sstevel@tonic-gate static
2247c478bd9Sstevel@tonic-gate struct passwd *Curpw_p, /* Current password entry for -t option */
2257c478bd9Sstevel@tonic-gate *Rpw_p, /* Password entry for -R option */
2267c478bd9Sstevel@tonic-gate *dpasswd;
2277c478bd9Sstevel@tonic-gate
2287c478bd9Sstevel@tonic-gate static
2297c478bd9Sstevel@tonic-gate struct group *Curgr_p, /* Current group entry for -t option */
2307c478bd9Sstevel@tonic-gate *dgroup;
2317c478bd9Sstevel@tonic-gate
2327c478bd9Sstevel@tonic-gate /* Data structure for buffered I/O. */
2337c478bd9Sstevel@tonic-gate
2347c478bd9Sstevel@tonic-gate static
2357c478bd9Sstevel@tonic-gate struct buf_info {
2367c478bd9Sstevel@tonic-gate char *b_base_p, /* Pointer to base of buffer */
2377c478bd9Sstevel@tonic-gate *b_out_p, /* Position to take bytes from buffer at */
2387c478bd9Sstevel@tonic-gate *b_in_p, /* Position to put bytes into buffer at */
2397c478bd9Sstevel@tonic-gate *b_end_p; /* Pointer to end of buffer */
240*6d3b960aSAndy Fiddaman int b_cnt, /* Count of unprocessed bytes */
2417c478bd9Sstevel@tonic-gate b_size; /* Size of buffer in bytes */
2427c478bd9Sstevel@tonic-gate } Buffr;
2437c478bd9Sstevel@tonic-gate
2447c478bd9Sstevel@tonic-gate /* Generic header format */
2457c478bd9Sstevel@tonic-gate
2467c478bd9Sstevel@tonic-gate static
2477c478bd9Sstevel@tonic-gate struct gen_hdr {
248*6d3b960aSAndy Fiddaman uint_t g_magic, /* Magic number field */
2497c478bd9Sstevel@tonic-gate g_ino, /* Inode number of file */
2507c478bd9Sstevel@tonic-gate g_mode, /* Mode of file */
2517c478bd9Sstevel@tonic-gate g_uid, /* Uid of file */
2527c478bd9Sstevel@tonic-gate g_gid, /* Gid of file */
2537c478bd9Sstevel@tonic-gate g_nlink, /* Number of links */
2547c478bd9Sstevel@tonic-gate g_mtime; /* Modification time */
2557c478bd9Sstevel@tonic-gate off_t g_filesz; /* Length of file */
256*6d3b960aSAndy Fiddaman dev_t g_dev, /* File system of file */
257*6d3b960aSAndy Fiddaman g_rdev; /* Major/minor numbers of special files */
258*6d3b960aSAndy Fiddaman uint_t g_namesz, /* Length of filename */
2597c478bd9Sstevel@tonic-gate g_cksum; /* Checksum of file */
2607c478bd9Sstevel@tonic-gate char g_gname[32],
2617c478bd9Sstevel@tonic-gate g_uname[32],
2627c478bd9Sstevel@tonic-gate g_version[2],
2637c478bd9Sstevel@tonic-gate g_tmagic[6],
2647c478bd9Sstevel@tonic-gate g_typeflag;
2657c478bd9Sstevel@tonic-gate char *g_tname,
2667c478bd9Sstevel@tonic-gate *g_prefix,
2677c478bd9Sstevel@tonic-gate *g_nam_p, /* Filename */
268ced83f9bSceastha *g_attrparent_p, /* attribute parent */
269ced83f9bSceastha *g_attrpath_p, /* attribute path */
2707c478bd9Sstevel@tonic-gate *g_attrnam_p, /* attribute */
2717c478bd9Sstevel@tonic-gate *g_attrfnam_p, /* Real file name attr belongs to */
2727c478bd9Sstevel@tonic-gate *g_linktoattrfnam_p, /* file linked attribute belongs to */
2737c478bd9Sstevel@tonic-gate *g_linktoattrnam_p, /* attribute g_attrnam_p is linked to */
2747c478bd9Sstevel@tonic-gate *g_dirpath; /* dirname currently opened */
2757c478bd9Sstevel@tonic-gate int g_dirfd; /* directory file descriptor */
2767c478bd9Sstevel@tonic-gate int g_passdirfd; /* directory fd to pass to */
277ced83f9bSceastha int g_rw_sysattr; /* read-write system attribute */
278ced83f9bSceastha int g_baseparent_fd; /* base file's parent fd */
2795fbb8099SNobutomo Nakano holes_info_t *g_holes; /* sparse file information */
2807c478bd9Sstevel@tonic-gate
2817c478bd9Sstevel@tonic-gate } Gen, *G_p;
2827c478bd9Sstevel@tonic-gate
2837c478bd9Sstevel@tonic-gate /* Data structure for handling multiply-linked files */
2847c478bd9Sstevel@tonic-gate static
2857c478bd9Sstevel@tonic-gate char prebuf[PRESIZ+1],
2867c478bd9Sstevel@tonic-gate nambuf[NAMSIZ+1],
2877c478bd9Sstevel@tonic-gate fullnam[MAXNAM+1];
2887c478bd9Sstevel@tonic-gate
2897c478bd9Sstevel@tonic-gate
2907c478bd9Sstevel@tonic-gate static
2917c478bd9Sstevel@tonic-gate struct Lnk {
2927c478bd9Sstevel@tonic-gate short L_cnt, /* Number of links encountered */
2937c478bd9Sstevel@tonic-gate L_data; /* Data has been encountered if 1 */
2947c478bd9Sstevel@tonic-gate struct gen_hdr L_gen; /* gen_hdr information for this file */
2957c478bd9Sstevel@tonic-gate struct Lnk *L_nxt_p, /* Next file in list */
2967c478bd9Sstevel@tonic-gate *L_bck_p, /* Previous file in list */
2977c478bd9Sstevel@tonic-gate *L_lnk_p; /* Next link for this file */
2987c478bd9Sstevel@tonic-gate } Lnk_hd;
2997c478bd9Sstevel@tonic-gate
3007c478bd9Sstevel@tonic-gate static
3017c478bd9Sstevel@tonic-gate struct hdr_cpio Hdr;
3027c478bd9Sstevel@tonic-gate
3037c478bd9Sstevel@tonic-gate /*
3047c478bd9Sstevel@tonic-gate * -------------------------------------------------------------------------
3057c478bd9Sstevel@tonic-gate * Stuff needed to pre-view the name stream
3067c478bd9Sstevel@tonic-gate *
3077c478bd9Sstevel@tonic-gate * issymlink is used to remember that the current file is a symlink between
3087c478bd9Sstevel@tonic-gate * getname() and file_pass(); the former trashes this information immediately
3097c478bd9Sstevel@tonic-gate * when -L is specified.
3107c478bd9Sstevel@tonic-gate */
3117c478bd9Sstevel@tonic-gate
3127c478bd9Sstevel@tonic-gate static
3137c478bd9Sstevel@tonic-gate int issymlink = 0;
3147c478bd9Sstevel@tonic-gate
3157c478bd9Sstevel@tonic-gate static
3167c478bd9Sstevel@tonic-gate FILE *In_p = stdin; /* Where the input comes from */
3177c478bd9Sstevel@tonic-gate
3187c478bd9Sstevel@tonic-gate typedef struct sl_info
3197c478bd9Sstevel@tonic-gate {
3207c478bd9Sstevel@tonic-gate struct sl_info *llink; /* Left subtree ptr (tree depth in *sl_head) */
3217c478bd9Sstevel@tonic-gate struct sl_info *rlink; /* Right subtree ptr */
3227c478bd9Sstevel@tonic-gate int bal; /* Subtree balance factor */
323*6d3b960aSAndy Fiddaman uint_t sl_count; /* Number of symlinks */
324ced83f9bSceastha int sl_ftype; /* file type of inode */
3257c478bd9Sstevel@tonic-gate ino_t sl_ino; /* Inode of file */
3267c478bd9Sstevel@tonic-gate ino_t sl_ino2; /* alternate inode for -Hodc */
3277c478bd9Sstevel@tonic-gate } sl_info_t;
3287c478bd9Sstevel@tonic-gate
329ced83f9bSceastha typedef struct data_in
330ced83f9bSceastha {
3315fbb8099SNobutomo Nakano int data_in_errno;
3324e621e6cSNobutomo Nakano char data_in_swapfile;
3334e621e6cSNobutomo Nakano char data_in_proc_mode;
3344e621e6cSNobutomo Nakano char data_in_rd_eof;
3354e621e6cSNobutomo Nakano char data_in_wr_part;
3364e621e6cSNobutomo Nakano char data_in_compress_flag;
337ced83f9bSceastha long data_in_cksumval;
338ced83f9bSceastha FILE *data_in_pipef;
339ced83f9bSceastha } data_in_t;
340ced83f9bSceastha
3417c478bd9Sstevel@tonic-gate /*
3427c478bd9Sstevel@tonic-gate * The following structure maintains a hash entry for the
3437c478bd9Sstevel@tonic-gate * balancing trees which are allocated for each device nodes.
3447c478bd9Sstevel@tonic-gate */
3457c478bd9Sstevel@tonic-gate typedef struct sl_info_link
3467c478bd9Sstevel@tonic-gate {
3477c478bd9Sstevel@tonic-gate dev_t dev;
3487c478bd9Sstevel@tonic-gate sl_info_t *head;
3497c478bd9Sstevel@tonic-gate struct sl_info_link *next;
3507c478bd9Sstevel@tonic-gate } sl_info_link_t;
3517c478bd9Sstevel@tonic-gate
3527c478bd9Sstevel@tonic-gate #define SL_INFO_ALLOC_CHUNK 1024
3537c478bd9Sstevel@tonic-gate #define NDEVHENTRY 0x40
3547c478bd9Sstevel@tonic-gate #define DEV_HASHKEY(x) ((x) & (NDEVHENTRY -1))
3557c478bd9Sstevel@tonic-gate
3567c478bd9Sstevel@tonic-gate /*
3577c478bd9Sstevel@tonic-gate * For remapping dev,inode for -Hodc archives.
3587c478bd9Sstevel@tonic-gate */
3597c478bd9Sstevel@tonic-gate
3607c478bd9Sstevel@tonic-gate typedef struct sl_remap
3617c478bd9Sstevel@tonic-gate {
3627c478bd9Sstevel@tonic-gate dev_t dev; /* device */
3637c478bd9Sstevel@tonic-gate int inode_count; /* # inodes seen on dev */
3647c478bd9Sstevel@tonic-gate struct sl_remap *next; /* next in the chain */
3657c478bd9Sstevel@tonic-gate } sl_remap_t;
3667c478bd9Sstevel@tonic-gate
3677c478bd9Sstevel@tonic-gate /* forward declarations */
3687c478bd9Sstevel@tonic-gate
3697c478bd9Sstevel@tonic-gate static sl_info_t *sl_info_alloc(void);
370ced83f9bSceastha static sl_info_t *sl_insert(dev_t, ino_t, int);
371*6d3b960aSAndy Fiddaman static uint_t sl_numlinks(dev_t, ino_t, int);
3727c478bd9Sstevel@tonic-gate static void sl_preview_synonyms(void);
373ced83f9bSceastha static void sl_remember_tgt(const struct stat *, int, int);
374ced83f9bSceastha static sl_info_t *sl_search(dev_t, ino_t, int);
3757c478bd9Sstevel@tonic-gate static sl_info_t *sl_devhash_lookup(dev_t);
3767c478bd9Sstevel@tonic-gate static void sl_devhash_insert(dev_t, sl_info_t *);
3777c478bd9Sstevel@tonic-gate
378ced83f9bSceastha extern int sl_compare(ino_t, int, ino_t, int);
379ced83f9bSceastha #define sl_compare(lino, lftype, rino, rftype) (lino < rino ? -1 : \
380ced83f9bSceastha (lino > rino ? 1 : (lftype < rftype ? -1 : \
381ced83f9bSceastha (lftype > rftype ? 1 : 0))))
3827c478bd9Sstevel@tonic-gate
3837c478bd9Sstevel@tonic-gate /* global storage */
3847c478bd9Sstevel@tonic-gate
3857c478bd9Sstevel@tonic-gate static sl_remap_t *sl_remap_head = NULL; /* head of the inode-remap list */
3867c478bd9Sstevel@tonic-gate static sl_info_link_t *sl_devhash[NDEVHENTRY]; /* hash table */
3877c478bd9Sstevel@tonic-gate
3887c478bd9Sstevel@tonic-gate /*
3897c478bd9Sstevel@tonic-gate * -------------------------------------------------------------------------
3907c478bd9Sstevel@tonic-gate */
3917c478bd9Sstevel@tonic-gate
3927c478bd9Sstevel@tonic-gate static
3937c478bd9Sstevel@tonic-gate struct stat ArchSt, /* stat(2) information of the archive */
3947c478bd9Sstevel@tonic-gate SrcSt, /* stat(2) information of source file */
3957c478bd9Sstevel@tonic-gate DesSt, /* stat(2) of destination file */
3967c478bd9Sstevel@tonic-gate *OldSt = NULL; /* stat info converted to svr32 format */
3977c478bd9Sstevel@tonic-gate
3987c478bd9Sstevel@tonic-gate /*
3997c478bd9Sstevel@tonic-gate * bin_mag: Used to validate a binary magic number,
4007c478bd9Sstevel@tonic-gate * by combining to bytes into an unsigned short.
4017c478bd9Sstevel@tonic-gate */
4027c478bd9Sstevel@tonic-gate
4037c478bd9Sstevel@tonic-gate static
4047c478bd9Sstevel@tonic-gate union bin_mag {
4057c478bd9Sstevel@tonic-gate unsigned char b_byte[2];
4067c478bd9Sstevel@tonic-gate ushort_t b_half;
4077c478bd9Sstevel@tonic-gate } Binmag;
4087c478bd9Sstevel@tonic-gate
4097c478bd9Sstevel@tonic-gate static
4107c478bd9Sstevel@tonic-gate union tblock *Thdr_p; /* TAR header pointer */
4117c478bd9Sstevel@tonic-gate
4127c478bd9Sstevel@tonic-gate static union b_block *bar_Vhdr;
4137c478bd9Sstevel@tonic-gate static struct gen_hdr Gen_bar_vol;
4147c478bd9Sstevel@tonic-gate
4157c478bd9Sstevel@tonic-gate /*
4167c478bd9Sstevel@tonic-gate * swpbuf: Used in swap() to swap bytes within a halfword,
4177c478bd9Sstevel@tonic-gate * halfwords within a word, or to reverse the order of the
4187c478bd9Sstevel@tonic-gate * bytes within a word. Also used in mklong() and mkshort().
4197c478bd9Sstevel@tonic-gate */
4207c478bd9Sstevel@tonic-gate
4217c478bd9Sstevel@tonic-gate static
4227c478bd9Sstevel@tonic-gate union swpbuf {
4237c478bd9Sstevel@tonic-gate unsigned char s_byte[4];
4247c478bd9Sstevel@tonic-gate ushort_t s_half[2];
425*6d3b960aSAndy Fiddaman uint_t s_word;
4267c478bd9Sstevel@tonic-gate } *Swp_p;
4277c478bd9Sstevel@tonic-gate
4287c478bd9Sstevel@tonic-gate static
429ced83f9bSceastha char *myname, /* program name */
430ced83f9bSceastha Adir, /* Flags object as a directory */
4317c478bd9Sstevel@tonic-gate Hiddendir, /* Processing hidden attribute directory */
4327c478bd9Sstevel@tonic-gate Aspec, /* Flags object as a special file */
4337c478bd9Sstevel@tonic-gate Do_rename, /* Indicates rename() is to be used */
4347c478bd9Sstevel@tonic-gate Time[50], /* Array to hold date and time */
4357c478bd9Sstevel@tonic-gate Ttyname[] = "/dev/tty", /* Controlling console */
4367c478bd9Sstevel@tonic-gate T_lname[MAXPATHLEN], /* Array to hold links name for tar */
4377c478bd9Sstevel@tonic-gate *Buf_p, /* Buffer for file system I/O */
4387c478bd9Sstevel@tonic-gate *Full_p, /* Pointer to full pathname */
4397c478bd9Sstevel@tonic-gate *Efil_p, /* -E pattern file string */
4407c478bd9Sstevel@tonic-gate *Eom_p = "Change to part %d and press RETURN key. [q] ",
4417c478bd9Sstevel@tonic-gate *Fullnam_p, /* Full pathname */
4427c478bd9Sstevel@tonic-gate *Attrfile_p, /* attribute file */
4437c478bd9Sstevel@tonic-gate *Hdr_p, /* -H header type string */
4447c478bd9Sstevel@tonic-gate *IOfil_p, /* -I/-O input/output archive string */
4457c478bd9Sstevel@tonic-gate *Lnkend_p, /* Pointer to end of Lnknam_p */
4467c478bd9Sstevel@tonic-gate *Lnknam_p, /* Buffer for linking files with -p option */
4477c478bd9Sstevel@tonic-gate *Nam_p, /* Array to hold filename */
4487c478bd9Sstevel@tonic-gate *Savenam_p, /* copy of filename xattr belongs to */
4497c478bd9Sstevel@tonic-gate *Own_p, /* New owner login id string */
4507c478bd9Sstevel@tonic-gate *Renam_p, /* Buffer for renaming files */
451ced83f9bSceastha *Renam_attr_p, /* Buffer for renaming attr with sys attrs */
4527c478bd9Sstevel@tonic-gate *Renametmp_p, /* Tmp Buffer for renaming files */
4537c478bd9Sstevel@tonic-gate *Symlnk_p, /* Buffer for holding symbolic link name */
4547c478bd9Sstevel@tonic-gate *Over_p, /* Holds temporary filename when overwriting */
4557c478bd9Sstevel@tonic-gate **Pat_pp = 0, /* Pattern strings */
4567c478bd9Sstevel@tonic-gate bar_linkflag, /* flag to indicate if the file is a link */
4577c478bd9Sstevel@tonic-gate bar_linkname[MAXPATHLEN]; /* store the name of the link */
4587c478bd9Sstevel@tonic-gate
4597c478bd9Sstevel@tonic-gate static
4607c478bd9Sstevel@tonic-gate int Append = 0, /* Flag set while searching to end of archive */
4617c478bd9Sstevel@tonic-gate Archive, /* File descriptor of the archive */
462da6c28aaSamw Buf_error = 0, /* I/O error occurred during buffer fill */
4635fbb8099SNobutomo Nakano Compress_sparse = 0, /* Compress sparse files */
4647c478bd9Sstevel@tonic-gate Def_mode = 0777, /* Default file/directory protection modes */
4657c478bd9Sstevel@tonic-gate Device, /* Device type being accessed (used with libgenIO) */
4667c478bd9Sstevel@tonic-gate Error_cnt = 0, /* Cumulative count of I/O errors */
4677c478bd9Sstevel@tonic-gate Finished = 1, /* Indicates that a file transfer has completed */
4687c478bd9Sstevel@tonic-gate Hdrsz = ASCSZ, /* Fixed length portion of the header */
4697c478bd9Sstevel@tonic-gate Hdr_type, /* Flag to indicate type of header selected */
4707c478bd9Sstevel@tonic-gate Ifile, /* File des. of file being archived */
4717c478bd9Sstevel@tonic-gate Ofile, /* File des. of file being extracted from archive */
4727c478bd9Sstevel@tonic-gate Use_old_stat = 0, /* Create an old style -Hodc hdr (small dev's) */
4737c478bd9Sstevel@tonic-gate Onecopy = 0, /* Flags old vs. new link handling */
4747c478bd9Sstevel@tonic-gate Pad_val = 0, /* Indicates the number of bytes to pad (if any) */
4757c478bd9Sstevel@tonic-gate PageSize = 0, /* The native page size, used for figuring block size */
4767c478bd9Sstevel@tonic-gate Volcnt = 1, /* Number of archive volumes processed */
4777c478bd9Sstevel@tonic-gate Verbcnt = 0, /* Count of number of dots '.' output */
4787c478bd9Sstevel@tonic-gate Eomflag = 0,
4797c478bd9Sstevel@tonic-gate Dflag = 0,
4807c478bd9Sstevel@tonic-gate Atflag = 0, /* Archive/restore extended attributes */
481ced83f9bSceastha SysAtflag = 0, /* Archive/restore extended system attributes */
4827c478bd9Sstevel@tonic-gate Compressed, /* Flag to indicate if the bar archive is compressed */
483647ab8f4Sceastha Bar_vol_num = 0, /* Volume number count for bar archive */
484ced83f9bSceastha privileged = 0, /* Flag set if running with higher privileges */
485ced83f9bSceastha attr_baseparent_fd = -1; /* attribute's base file descriptor */
4867c478bd9Sstevel@tonic-gate
4877c478bd9Sstevel@tonic-gate
4887c478bd9Sstevel@tonic-gate static
489f48205beScasper gid_t Lastgid = (gid_t)-1; /* Used with -t & -v to record current gid */
4907c478bd9Sstevel@tonic-gate
4917c478bd9Sstevel@tonic-gate static
492f48205beScasper uid_t Lastuid = (uid_t)-1; /* Used with -t & -v to record current uid */
4937c478bd9Sstevel@tonic-gate
4947c478bd9Sstevel@tonic-gate static
4957c478bd9Sstevel@tonic-gate long Args, /* Mask of selected options */
4967c478bd9Sstevel@tonic-gate Max_namesz = CPATH; /* Maximum size of pathnames/filenames */
4977c478bd9Sstevel@tonic-gate
4987c478bd9Sstevel@tonic-gate static
4997c478bd9Sstevel@tonic-gate int Bufsize = BUFSZ; /* Default block size */
5007c478bd9Sstevel@tonic-gate
5017c478bd9Sstevel@tonic-gate
502*6d3b960aSAndy Fiddaman static ulong_t Blocks; /* full blocks transferred */
503*6d3b960aSAndy Fiddaman static ulong_t SBlocks; /* cumulative char count from short reads */
5047c478bd9Sstevel@tonic-gate
5057c478bd9Sstevel@tonic-gate
5067c478bd9Sstevel@tonic-gate static off_t Max_offset = BIN_OFFSET_MAX; /* largest file size */
5077c478bd9Sstevel@tonic-gate static off_t Max_filesz; /* from getrlimit */
5087c478bd9Sstevel@tonic-gate
509*6d3b960aSAndy Fiddaman static uint_t Savedev;
510ced83f9bSceastha
5117c478bd9Sstevel@tonic-gate static
5127c478bd9Sstevel@tonic-gate FILE *Ef_p, /* File pointer of pattern input file */
5137c478bd9Sstevel@tonic-gate *Err_p = stderr, /* File pointer for error reporting */
5147c478bd9Sstevel@tonic-gate *Out_p = stdout, /* File pointer for non-archive output */
5157c478bd9Sstevel@tonic-gate *Rtty_p, /* Input file pointer for interactive rename */
5167c478bd9Sstevel@tonic-gate *Wtty_p; /* Output file ptr for interactive rename */
5177c478bd9Sstevel@tonic-gate
5187c478bd9Sstevel@tonic-gate static
5197c478bd9Sstevel@tonic-gate ushort_t Ftype = S_IFMT; /* File type mask */
5207c478bd9Sstevel@tonic-gate
5217c478bd9Sstevel@tonic-gate /* ACL support */
5227c478bd9Sstevel@tonic-gate static struct sec_attr {
5237c478bd9Sstevel@tonic-gate char attr_type;
5247c478bd9Sstevel@tonic-gate char attr_len[7];
5257c478bd9Sstevel@tonic-gate char attr_info[1];
5267c478bd9Sstevel@tonic-gate } *attr;
5277c478bd9Sstevel@tonic-gate
5287c478bd9Sstevel@tonic-gate static int Pflag = 0; /* flag indicates that acl is preserved */
529fa9e4066Sahrens static int acl_is_set = 0; /* True if an acl was set on the file */
530fa9e4066Sahrens
531fa9e4066Sahrens acl_t *aclp;
5327c478bd9Sstevel@tonic-gate
533ced83f9bSceastha #if defined(O_XATTR)
534ced83f9bSceastha typedef enum {
535ced83f9bSceastha ATTR_OK,
536ced83f9bSceastha ATTR_SKIP,
537ced83f9bSceastha ATTR_CHDIR_ERR,
538ced83f9bSceastha ATTR_OPEN_ERR,
539ced83f9bSceastha ATTR_XATTR_ERR,
540ced83f9bSceastha ATTR_SATTR_ERR
541ced83f9bSceastha } attr_status_t;
542ced83f9bSceastha #endif
543ced83f9bSceastha
544ced83f9bSceastha #if defined(O_XATTR)
545ced83f9bSceastha typedef enum {
546ced83f9bSceastha ARC_CREATE,
547ced83f9bSceastha ARC_RESTORE
548ced83f9bSceastha } arc_action_t;
549ced83f9bSceastha #endif
550ced83f9bSceastha
551ced83f9bSceastha
5527c478bd9Sstevel@tonic-gate /*
5537c478bd9Sstevel@tonic-gate *
5547c478bd9Sstevel@tonic-gate * cpio has been changed to support extended attributes.
5557c478bd9Sstevel@tonic-gate *
5567c478bd9Sstevel@tonic-gate * As part of this change cpio has been changed to use the new *at() syscalls
5577c478bd9Sstevel@tonic-gate * such as openat, fchownat(), unlinkat()...
5587c478bd9Sstevel@tonic-gate *
5597c478bd9Sstevel@tonic-gate * This was done so that attributes can be handled with as few code changes
5607c478bd9Sstevel@tonic-gate * as possible.
5617c478bd9Sstevel@tonic-gate *
5627c478bd9Sstevel@tonic-gate * What this means is that cpio now opens the directory that a file or directory
5637c478bd9Sstevel@tonic-gate * resides in and then performs *at() functions to manipulate the entry.
5647c478bd9Sstevel@tonic-gate *
5657c478bd9Sstevel@tonic-gate * For example a new file is now created like this:
5667c478bd9Sstevel@tonic-gate *
5677c478bd9Sstevel@tonic-gate * dfd = open(<some dir path>)
5687c478bd9Sstevel@tonic-gate * fd = openat(dfd, <name>,....);
5697c478bd9Sstevel@tonic-gate *
5707c478bd9Sstevel@tonic-gate * or in the case of an extended attribute
5717c478bd9Sstevel@tonic-gate *
5727c478bd9Sstevel@tonic-gate * dfd = attropen(<pathname>, ".", ....)
5737c478bd9Sstevel@tonic-gate *
5747c478bd9Sstevel@tonic-gate * Once we have a directory file descriptor all of the *at() functions can
5757c478bd9Sstevel@tonic-gate * be applied to it.
5767c478bd9Sstevel@tonic-gate *
5777c478bd9Sstevel@tonic-gate * unlinkat(dfd, <component name>,...)
5787c478bd9Sstevel@tonic-gate * fchownat(dfd, <component name>,..)
5797c478bd9Sstevel@tonic-gate *
5807c478bd9Sstevel@tonic-gate * This works for both normal namespace files and extended attribute file
5817c478bd9Sstevel@tonic-gate *
5827c478bd9Sstevel@tonic-gate */
5837c478bd9Sstevel@tonic-gate
5847c478bd9Sstevel@tonic-gate /*
5857c478bd9Sstevel@tonic-gate * Extended attribute layout
5867c478bd9Sstevel@tonic-gate *
5877c478bd9Sstevel@tonic-gate * Extended attributes are stored in two pieces.
5887c478bd9Sstevel@tonic-gate * 1. An attribute header which has information about
5897c478bd9Sstevel@tonic-gate * what file the attribute is for and what the attribute
5907c478bd9Sstevel@tonic-gate * is named.
5917c478bd9Sstevel@tonic-gate * 2. The attribute record itself. Stored as a normal file type
5927c478bd9Sstevel@tonic-gate * of entry.
5937c478bd9Sstevel@tonic-gate * Both the header and attribute record have special modes/typeflags
5947c478bd9Sstevel@tonic-gate * associated with them.
5957c478bd9Sstevel@tonic-gate *
5967c478bd9Sstevel@tonic-gate * The names of the header in the archive look like:
5977c478bd9Sstevel@tonic-gate * /dev/null/attr.hdr
5987c478bd9Sstevel@tonic-gate *
5997c478bd9Sstevel@tonic-gate * The name of the attribute looks like:
6007c478bd9Sstevel@tonic-gate * /dev/null/attr.
6017c478bd9Sstevel@tonic-gate *
6027c478bd9Sstevel@tonic-gate * This is done so that an archiver that doesn't understand these formats
6037c478bd9Sstevel@tonic-gate * can just dispose of the attribute records unless the user chooses to
6047c478bd9Sstevel@tonic-gate * rename them via cpio -r or pax -i
6057c478bd9Sstevel@tonic-gate *
6067c478bd9Sstevel@tonic-gate * The format is composed of a fixed size header followed
6077c478bd9Sstevel@tonic-gate * by a variable sized xattr_buf. If the attribute is a hard link
6087c478bd9Sstevel@tonic-gate * to another attribute, then another xattr_buf section is included
6097c478bd9Sstevel@tonic-gate * for the link.
6107c478bd9Sstevel@tonic-gate *
6117c478bd9Sstevel@tonic-gate * The xattr_buf is used to define the necessary "pathing" steps
6127c478bd9Sstevel@tonic-gate * to get to the extended attribute. This is necessary to support
6137c478bd9Sstevel@tonic-gate * a fully recursive attribute model where an attribute may itself
6147c478bd9Sstevel@tonic-gate * have an attribute.
6157c478bd9Sstevel@tonic-gate *
6167c478bd9Sstevel@tonic-gate * The basic layout looks like this.
6177c478bd9Sstevel@tonic-gate *
6187c478bd9Sstevel@tonic-gate * --------------------------------
6197c478bd9Sstevel@tonic-gate * | |
6207c478bd9Sstevel@tonic-gate * | xattr_hdr |
6217c478bd9Sstevel@tonic-gate * | |
6227c478bd9Sstevel@tonic-gate * --------------------------------
6237c478bd9Sstevel@tonic-gate * --------------------------------
6247c478bd9Sstevel@tonic-gate * | |
6257c478bd9Sstevel@tonic-gate * | xattr_buf |
6267c478bd9Sstevel@tonic-gate * | |
6277c478bd9Sstevel@tonic-gate * --------------------------------
6287c478bd9Sstevel@tonic-gate * --------------------------------
6297c478bd9Sstevel@tonic-gate * | |
6307c478bd9Sstevel@tonic-gate * | (optional link info) |
6317c478bd9Sstevel@tonic-gate * | |
6327c478bd9Sstevel@tonic-gate * --------------------------------
6337c478bd9Sstevel@tonic-gate * --------------------------------
6347c478bd9Sstevel@tonic-gate * | |
6357c478bd9Sstevel@tonic-gate * | attribute itself |
6367c478bd9Sstevel@tonic-gate * | stored as normal tar |
6377c478bd9Sstevel@tonic-gate * | or cpio data with |
6387c478bd9Sstevel@tonic-gate * | special mode or |
6397c478bd9Sstevel@tonic-gate * | typeflag |
6407c478bd9Sstevel@tonic-gate * | |
6417c478bd9Sstevel@tonic-gate * --------------------------------
6427c478bd9Sstevel@tonic-gate *
6437c478bd9Sstevel@tonic-gate */
6447c478bd9Sstevel@tonic-gate
6457c478bd9Sstevel@tonic-gate /*
6467c478bd9Sstevel@tonic-gate * Extended attributes structures
6477c478bd9Sstevel@tonic-gate *
6487c478bd9Sstevel@tonic-gate * xattrhead is the complete extended attribute header, as read of off
6497c478bd9Sstevel@tonic-gate * disk/tape. It includes the variable xattr_buf portion.
6507c478bd9Sstevel@tonic-gate *
6517c478bd9Sstevel@tonic-gate * xattrp is basically an offset into xattrhead that points to the
6527c478bd9Sstevel@tonic-gate * "pathing" section which defines how to get to the attribute.
6537c478bd9Sstevel@tonic-gate *
6547c478bd9Sstevel@tonic-gate * xattr_linkp is identical to xattrp except that it is used for linked
6557c478bd9Sstevel@tonic-gate * attributes. It provides the pathing steps to get to the linked
6567c478bd9Sstevel@tonic-gate * attribute.
6577c478bd9Sstevel@tonic-gate *
6587c478bd9Sstevel@tonic-gate * These structures are updated when an extended attribute header is read off
6597c478bd9Sstevel@tonic-gate * of disk/tape.
6607c478bd9Sstevel@tonic-gate */
6617c478bd9Sstevel@tonic-gate static struct xattr_hdr *xattrhead;
6627c478bd9Sstevel@tonic-gate static struct xattr_buf *xattrp;
6637c478bd9Sstevel@tonic-gate static struct xattr_buf *xattr_linkp;
6647c478bd9Sstevel@tonic-gate static int xattrbadhead; /* is extended attribute header bad? */
6657c478bd9Sstevel@tonic-gate
666fa9e4066Sahrens static int append_secattr(char **, int *, acl_t *);
6677c478bd9Sstevel@tonic-gate
6687c478bd9Sstevel@tonic-gate /*
6697c478bd9Sstevel@tonic-gate * Note regarding cpio and changes to ensure cpio doesn't try to second
6707c478bd9Sstevel@tonic-gate * guess whether it runs with sufficient privileges or not:
6717c478bd9Sstevel@tonic-gate *
6727c478bd9Sstevel@tonic-gate * cpio has been changed so that it doesn't carry a second implementation of
6737c478bd9Sstevel@tonic-gate * the kernel's policy with respect to privileges. Instead of attempting
6747c478bd9Sstevel@tonic-gate * to restore uid and gid from an archive only if cpio is run as uid 0,
675647ab8f4Sceastha * cpio now *always* tries to restore the uid and gid from the archive
676647ab8f4Sceastha * except when the -R option is specified. When the -R is specified,
677647ab8f4Sceastha * the uid and gid of the restored file will be changed to those of the
678647ab8f4Sceastha * login id specified. In addition, chown(), set_tym(), and chmod() should
679647ab8f4Sceastha * only be executed once during archive extraction, and to ensure
680647ab8f4Sceastha * setuid/setgid bits are restored properly, chown() should always be
681647ab8f4Sceastha * executed before chmod().
6827c478bd9Sstevel@tonic-gate *
6837c478bd9Sstevel@tonic-gate * Note regarding debugging mechanism for cpio:
6847c478bd9Sstevel@tonic-gate *
6857c478bd9Sstevel@tonic-gate * The following mechanism is provided to allow us to debug cpio in complicated
6867c478bd9Sstevel@tonic-gate * situations, like when it is part of a pipe. The idea is that you compile
6877c478bd9Sstevel@tonic-gate * with -DWAITAROUND defined, and then add the "-z" command line option to the
6887c478bd9Sstevel@tonic-gate * target cpio invocation. If stderr is available, it will tell you to which
6897c478bd9Sstevel@tonic-gate * pid to attach the debugger; otherwise, use ps to find it. Attach to the
6907c478bd9Sstevel@tonic-gate * process from the debugger, and, *PRESTO*, you are there!
6917c478bd9Sstevel@tonic-gate *
6927c478bd9Sstevel@tonic-gate * Simply assign "waitaround = 0" once you attach to the process, and then
6937c478bd9Sstevel@tonic-gate * proceed from there as usual.
6947c478bd9Sstevel@tonic-gate */
6957c478bd9Sstevel@tonic-gate
6967c478bd9Sstevel@tonic-gate #ifdef WAITAROUND
6977c478bd9Sstevel@tonic-gate int waitaround = 0; /* wait for rendezvous with the debugger */
6987c478bd9Sstevel@tonic-gate #endif
6997c478bd9Sstevel@tonic-gate
7007c478bd9Sstevel@tonic-gate #define EXIT_CODE (Error_cnt > 255 ? 255 : Error_cnt)
7017c478bd9Sstevel@tonic-gate
7027c478bd9Sstevel@tonic-gate /*
7037c478bd9Sstevel@tonic-gate * main: Call setup() to process options and perform initializations,
7047c478bd9Sstevel@tonic-gate * and then select either copy in (-i), copy out (-o), or pass (-p) action.
7057c478bd9Sstevel@tonic-gate */
7067c478bd9Sstevel@tonic-gate
707944d83a0Schin int
main(int argc,char ** argv)7087c478bd9Sstevel@tonic-gate main(int argc, char **argv)
7097c478bd9Sstevel@tonic-gate {
7107c478bd9Sstevel@tonic-gate int i;
7117c478bd9Sstevel@tonic-gate int passret;
7127c478bd9Sstevel@tonic-gate
7137c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, "");
7147c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
7157c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
7167c478bd9Sstevel@tonic-gate #endif
7177c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN);
7187c478bd9Sstevel@tonic-gate
7197c478bd9Sstevel@tonic-gate (void) memset(&Gen, 0, sizeof (Gen));
720ced83f9bSceastha myname = e_strdup(E_EXIT, basename(argv[0]));
7217c478bd9Sstevel@tonic-gate setup(argc, argv);
7227c478bd9Sstevel@tonic-gate
7237c478bd9Sstevel@tonic-gate if (signal(SIGINT, sigint) == SIG_IGN)
7247c478bd9Sstevel@tonic-gate (void) signal(SIGINT, SIG_IGN);
7257c478bd9Sstevel@tonic-gate switch (Args & (OCi | OCo | OCp)) {
7267c478bd9Sstevel@tonic-gate case OCi: /* COPY IN */
7277c478bd9Sstevel@tonic-gate Hdr_type = NONE;
728ced83f9bSceastha if (Atflag || SysAtflag) {
729ced83f9bSceastha /*
730ced83f9bSceastha * Save the current working directory, so
731ced83f9bSceastha * we can change back here after cd'ing into
732ced83f9bSceastha * the attribute directory when processing
733ced83f9bSceastha * attributes.
734ced83f9bSceastha */
735ced83f9bSceastha if ((attr_baseparent_fd = save_cwd()) < 0) {
736ced83f9bSceastha msg(EXT, "Unable to open current directory.");
737ced83f9bSceastha }
738ced83f9bSceastha }
7397c478bd9Sstevel@tonic-gate while ((i = gethdr()) != 0) {
7407c478bd9Sstevel@tonic-gate Gen.g_dirfd = -1;
7417c478bd9Sstevel@tonic-gate if (i == 1) {
7427c478bd9Sstevel@tonic-gate file_in();
7437c478bd9Sstevel@tonic-gate /*
7447c478bd9Sstevel@tonic-gate * Any ACL info for this file would or should
7457c478bd9Sstevel@tonic-gate * have been used after file_in(); clear out
7467c478bd9Sstevel@tonic-gate * aclp so it is is not erroneously used on
7477c478bd9Sstevel@tonic-gate * the next file.
7487c478bd9Sstevel@tonic-gate */
7497c478bd9Sstevel@tonic-gate if (aclp != NULL) {
750fa9e4066Sahrens acl_free(aclp);
7517c478bd9Sstevel@tonic-gate aclp = NULL;
7527c478bd9Sstevel@tonic-gate }
753fa9e4066Sahrens acl_is_set = 0;
7547c478bd9Sstevel@tonic-gate }
7557c478bd9Sstevel@tonic-gate (void) memset(&Gen, 0, sizeof (Gen));
7567c478bd9Sstevel@tonic-gate }
7577c478bd9Sstevel@tonic-gate /* Do not count "extra" "read-ahead" buffered data */
7587c478bd9Sstevel@tonic-gate if (Buffr.b_cnt > Bufsize)
759*6d3b960aSAndy Fiddaman Blocks -= (Buffr.b_cnt / Bufsize);
7607c478bd9Sstevel@tonic-gate break;
7617c478bd9Sstevel@tonic-gate case OCo: /* COPY OUT */
7627c478bd9Sstevel@tonic-gate if (Args & OCA) {
7637c478bd9Sstevel@tonic-gate scan4trail();
7647c478bd9Sstevel@tonic-gate }
7657c478bd9Sstevel@tonic-gate
7667c478bd9Sstevel@tonic-gate Gen.g_dirfd = -1;
7677c478bd9Sstevel@tonic-gate Gen.g_dirpath = NULL;
7687c478bd9Sstevel@tonic-gate sl_preview_synonyms();
7697c478bd9Sstevel@tonic-gate
7707c478bd9Sstevel@tonic-gate while ((i = getname()) != 0) {
7717c478bd9Sstevel@tonic-gate if (i == 1) {
7727c478bd9Sstevel@tonic-gate (void) file_out();
773ced83f9bSceastha if (Atflag || SysAtflag) {
7747c478bd9Sstevel@tonic-gate if (Gen.g_dirfd != -1) {
7757c478bd9Sstevel@tonic-gate (void) close(Gen.g_dirfd);
7767c478bd9Sstevel@tonic-gate }
7777c478bd9Sstevel@tonic-gate Gen.g_dirfd = -1;
7787c478bd9Sstevel@tonic-gate xattrs_out(file_out);
7797c478bd9Sstevel@tonic-gate }
7807c478bd9Sstevel@tonic-gate }
7817c478bd9Sstevel@tonic-gate if (aclp != NULL) {
782fa9e4066Sahrens acl_free(aclp);
7837c478bd9Sstevel@tonic-gate aclp = NULL;
784fa9e4066Sahrens acl_is_set = 0;
7857c478bd9Sstevel@tonic-gate }
7867c478bd9Sstevel@tonic-gate }
7877c478bd9Sstevel@tonic-gate write_trail();
7887c478bd9Sstevel@tonic-gate break;
7897c478bd9Sstevel@tonic-gate case OCp: /* PASS */
7907c478bd9Sstevel@tonic-gate sl_preview_synonyms();
7917c478bd9Sstevel@tonic-gate
7927c478bd9Sstevel@tonic-gate Gen.g_dirfd = -1;
7937c478bd9Sstevel@tonic-gate Gen.g_passdirfd = -1;
7947c478bd9Sstevel@tonic-gate Gen.g_dirpath = NULL;
7955fbb8099SNobutomo Nakano Compress_sparse = 1;
7967c478bd9Sstevel@tonic-gate while (getname()) {
7977c478bd9Sstevel@tonic-gate /*
7987c478bd9Sstevel@tonic-gate * If file is a fully qualified path then
7997c478bd9Sstevel@tonic-gate * file_pass will strip off the leading '/'
8007c478bd9Sstevel@tonic-gate * and we need to save off the unstripped
8017c478bd9Sstevel@tonic-gate * name for attribute traversal.
8027c478bd9Sstevel@tonic-gate */
803ced83f9bSceastha if (Atflag || SysAtflag) {
8047c478bd9Sstevel@tonic-gate (void) strcpy(Savenam_p, Gen.g_nam_p);
8057c478bd9Sstevel@tonic-gate }
8067c478bd9Sstevel@tonic-gate passret = file_pass();
8077c478bd9Sstevel@tonic-gate if (aclp != NULL) {
808fa9e4066Sahrens acl_free(aclp);
8097c478bd9Sstevel@tonic-gate aclp = NULL;
810fa9e4066Sahrens acl_is_set = 0;
8117c478bd9Sstevel@tonic-gate }
8127c478bd9Sstevel@tonic-gate if (Gen.g_passdirfd != -1)
8137c478bd9Sstevel@tonic-gate (void) close(Gen.g_passdirfd);
8147c478bd9Sstevel@tonic-gate Gen.g_passdirfd = -1;
815ced83f9bSceastha if (Atflag || SysAtflag) {
8167c478bd9Sstevel@tonic-gate if (Gen.g_dirfd != -1) {
8177c478bd9Sstevel@tonic-gate (void) close(Gen.g_dirfd);
8187c478bd9Sstevel@tonic-gate }
8197c478bd9Sstevel@tonic-gate Gen.g_dirfd = -1;
8207c478bd9Sstevel@tonic-gate if (passret != FILE_LINKED) {
8217c478bd9Sstevel@tonic-gate Gen.g_nam_p = Savenam_p;
8227c478bd9Sstevel@tonic-gate xattrs_out(file_pass);
8237c478bd9Sstevel@tonic-gate }
8247c478bd9Sstevel@tonic-gate }
8257c478bd9Sstevel@tonic-gate }
8267c478bd9Sstevel@tonic-gate break;
8277c478bd9Sstevel@tonic-gate default:
8287c478bd9Sstevel@tonic-gate msg(EXT, "Impossible action.");
8297c478bd9Sstevel@tonic-gate }
8307c478bd9Sstevel@tonic-gate if (Ofile > 0) {
8317c478bd9Sstevel@tonic-gate if (close(Ofile) != 0)
8327c478bd9Sstevel@tonic-gate msg(EXTN, "close error");
8337c478bd9Sstevel@tonic-gate }
8347c478bd9Sstevel@tonic-gate if (Archive > 0) {
8357c478bd9Sstevel@tonic-gate if (close(Archive) != 0)
8367c478bd9Sstevel@tonic-gate msg(EXTN, "close error");
8377c478bd9Sstevel@tonic-gate }
838b0ee9efaSGary Mills if ((Args & OCq) == 0) {
839*6d3b960aSAndy Fiddaman Blocks = (ulong_t)(Blocks * Bufsize + SBlocks +
840b0ee9efaSGary Mills 0x1FF) >> 9;
841*6d3b960aSAndy Fiddaman msg(EPOST, "%ld blocks", Blocks);
842b0ee9efaSGary Mills }
8437c478bd9Sstevel@tonic-gate if (Error_cnt)
8447c478bd9Sstevel@tonic-gate msg(EPOST, "%d error(s)", Error_cnt);
8457c478bd9Sstevel@tonic-gate return (EXIT_CODE);
8467c478bd9Sstevel@tonic-gate }
8477c478bd9Sstevel@tonic-gate
8487c478bd9Sstevel@tonic-gate /*
8497c478bd9Sstevel@tonic-gate * add_lnk: Add a linked file's header to the linked file data structure, by
8507c478bd9Sstevel@tonic-gate * either adding it to the end of an existing sub-list or starting
8517c478bd9Sstevel@tonic-gate * a new sub-list. Each sub-list saves the links to a given file.
8527c478bd9Sstevel@tonic-gate *
8537c478bd9Sstevel@tonic-gate * Directly returns a pointer to the new entry; returns a pointer to the head
8547c478bd9Sstevel@tonic-gate * of the sub-list in which that entry is located through the argument.
8557c478bd9Sstevel@tonic-gate */
8567c478bd9Sstevel@tonic-gate
8577c478bd9Sstevel@tonic-gate static struct Lnk *
add_lnk(struct Lnk ** sublist_return)8587c478bd9Sstevel@tonic-gate add_lnk(struct Lnk **sublist_return)
8597c478bd9Sstevel@tonic-gate {
8607c478bd9Sstevel@tonic-gate struct Lnk *new_entry, *sublist;
8617c478bd9Sstevel@tonic-gate
8627c478bd9Sstevel@tonic-gate for (sublist = Lnk_hd.L_nxt_p;
8637c478bd9Sstevel@tonic-gate sublist != &Lnk_hd;
8647c478bd9Sstevel@tonic-gate sublist = sublist->L_nxt_p) {
8657c478bd9Sstevel@tonic-gate if (sublist->L_gen.g_ino == G_p->g_ino &&
8667c478bd9Sstevel@tonic-gate sublist->L_gen.g_dev == G_p->g_dev) {
8677c478bd9Sstevel@tonic-gate /* found */
8687c478bd9Sstevel@tonic-gate break;
8697c478bd9Sstevel@tonic-gate }
8707c478bd9Sstevel@tonic-gate }
8717c478bd9Sstevel@tonic-gate
8727c478bd9Sstevel@tonic-gate new_entry = e_zalloc(E_EXIT, sizeof (struct Lnk));
8737c478bd9Sstevel@tonic-gate
8747c478bd9Sstevel@tonic-gate new_entry->L_lnk_p = NULL;
8757c478bd9Sstevel@tonic-gate new_entry->L_gen = *G_p; /* structure copy */
8767c478bd9Sstevel@tonic-gate
8777c478bd9Sstevel@tonic-gate new_entry->L_gen.g_nam_p = e_zalloc(E_EXIT, (size_t)G_p->g_namesz);
8787c478bd9Sstevel@tonic-gate
8797c478bd9Sstevel@tonic-gate (void) strcpy(new_entry->L_gen.g_nam_p, G_p->g_nam_p);
8807c478bd9Sstevel@tonic-gate
8817c478bd9Sstevel@tonic-gate if (sublist == &Lnk_hd) {
8827c478bd9Sstevel@tonic-gate /* start new sub-list */
8837c478bd9Sstevel@tonic-gate new_entry->L_nxt_p = &Lnk_hd;
8847c478bd9Sstevel@tonic-gate new_entry->L_bck_p = Lnk_hd.L_bck_p;
8857c478bd9Sstevel@tonic-gate Lnk_hd.L_bck_p = new_entry->L_bck_p->L_nxt_p = new_entry;
8867c478bd9Sstevel@tonic-gate new_entry->L_lnk_p = NULL;
8877c478bd9Sstevel@tonic-gate new_entry->L_cnt = 1;
8887c478bd9Sstevel@tonic-gate new_entry->L_data = Onecopy ? 0 : 1;
8897c478bd9Sstevel@tonic-gate sublist = new_entry;
8907c478bd9Sstevel@tonic-gate } else {
8917c478bd9Sstevel@tonic-gate /* add to existing sub-list */
8927c478bd9Sstevel@tonic-gate struct Lnk *ptr;
8937c478bd9Sstevel@tonic-gate
8947c478bd9Sstevel@tonic-gate sublist->L_cnt++;
8957c478bd9Sstevel@tonic-gate
8967c478bd9Sstevel@tonic-gate for (ptr = sublist;
8977c478bd9Sstevel@tonic-gate ptr->L_lnk_p != NULL;
8987c478bd9Sstevel@tonic-gate ptr = ptr->L_lnk_p) {
8997c478bd9Sstevel@tonic-gate ptr->L_gen.g_filesz = G_p->g_filesz;
9007c478bd9Sstevel@tonic-gate }
9017c478bd9Sstevel@tonic-gate
9027c478bd9Sstevel@tonic-gate ptr->L_gen.g_filesz = G_p->g_filesz;
9037c478bd9Sstevel@tonic-gate ptr->L_lnk_p = new_entry;
9047c478bd9Sstevel@tonic-gate }
9057c478bd9Sstevel@tonic-gate
9067c478bd9Sstevel@tonic-gate *sublist_return = sublist;
9077c478bd9Sstevel@tonic-gate return (new_entry);
9087c478bd9Sstevel@tonic-gate }
9097c478bd9Sstevel@tonic-gate
9107c478bd9Sstevel@tonic-gate /*
9117c478bd9Sstevel@tonic-gate * bfill: Read req_cnt bytes (out of filelen bytes) from the I/O buffer,
9127c478bd9Sstevel@tonic-gate * moving them to rd_buf_p. When there are no bytes left in the I/O buffer,
9137c478bd9Sstevel@tonic-gate * Fillbuf is set and the I/O buffer is filled. The variable dist is the
9147c478bd9Sstevel@tonic-gate * distance to lseek if an I/O error is encountered with the -k option set
9157c478bd9Sstevel@tonic-gate * (converted to a multiple of Bufsize).
9167c478bd9Sstevel@tonic-gate */
9177c478bd9Sstevel@tonic-gate
9187c478bd9Sstevel@tonic-gate static int
bfill(void)9197c478bd9Sstevel@tonic-gate bfill(void)
9207c478bd9Sstevel@tonic-gate {
9210b9a5158SToomas Soome int i = 0, rv = 0;
9227c478bd9Sstevel@tonic-gate static int eof = 0;
9237c478bd9Sstevel@tonic-gate
9247c478bd9Sstevel@tonic-gate if (!Dflag) {
9257c478bd9Sstevel@tonic-gate while ((Buffr.b_end_p - Buffr.b_in_p) >= Bufsize) {
9267c478bd9Sstevel@tonic-gate errno = 0;
9277c478bd9Sstevel@tonic-gate if ((rv = g_read(Device, Archive, Buffr.b_in_p, Bufsize)) < 0) {
9287c478bd9Sstevel@tonic-gate if (((Buffr.b_end_p - Buffr.b_in_p) >= Bufsize) &&
9297c478bd9Sstevel@tonic-gate (Eomflag == 0)) {
9307c478bd9Sstevel@tonic-gate Eomflag = 1;
9317c478bd9Sstevel@tonic-gate return (1);
9327c478bd9Sstevel@tonic-gate }
9337c478bd9Sstevel@tonic-gate if (errno == ENOSPC) {
9347c478bd9Sstevel@tonic-gate (void) chgreel(INPUT);
9357c478bd9Sstevel@tonic-gate if (Hdr_type == BAR) {
9367c478bd9Sstevel@tonic-gate skip_bar_volhdr();
9377c478bd9Sstevel@tonic-gate }
9387c478bd9Sstevel@tonic-gate continue;
9397c478bd9Sstevel@tonic-gate } else if (Args & OCk) {
9407c478bd9Sstevel@tonic-gate if (i++ > MX_SEEKS)
9417c478bd9Sstevel@tonic-gate msg(EXT, "Cannot recover.");
9427c478bd9Sstevel@tonic-gate if (lseek(Archive, Bufsize, SEEK_REL) < 0)
9437c478bd9Sstevel@tonic-gate msg(EXTN, "Cannot lseek()");
9447c478bd9Sstevel@tonic-gate Error_cnt++;
9457c478bd9Sstevel@tonic-gate Buf_error++;
9467c478bd9Sstevel@tonic-gate rv = 0;
9477c478bd9Sstevel@tonic-gate continue;
9487c478bd9Sstevel@tonic-gate } else
9497c478bd9Sstevel@tonic-gate ioerror(INPUT);
9507c478bd9Sstevel@tonic-gate } /* (rv = g_read(Device, Archive ... */
9517c478bd9Sstevel@tonic-gate if (Hdr_type != BAR || rv == Bufsize) {
9527c478bd9Sstevel@tonic-gate Buffr.b_in_p += rv;
953*6d3b960aSAndy Fiddaman Buffr.b_cnt += rv;
9547c478bd9Sstevel@tonic-gate }
9557c478bd9Sstevel@tonic-gate if (rv == Bufsize) {
9567c478bd9Sstevel@tonic-gate eof = 0;
9577c478bd9Sstevel@tonic-gate Blocks++;
9587c478bd9Sstevel@tonic-gate } else if (rv == 0) {
9597c478bd9Sstevel@tonic-gate if (!eof) {
9607c478bd9Sstevel@tonic-gate eof = 1;
9617c478bd9Sstevel@tonic-gate break;
9627c478bd9Sstevel@tonic-gate }
9637c478bd9Sstevel@tonic-gate (void) chgreel(INPUT);
9647c478bd9Sstevel@tonic-gate eof = 0; /* reset the eof after chgreel */
9657c478bd9Sstevel@tonic-gate
9667c478bd9Sstevel@tonic-gate /*
9677c478bd9Sstevel@tonic-gate * if spans multiple volume, skip the volume header of
9687c478bd9Sstevel@tonic-gate * the next volume so that the file currently being
9697c478bd9Sstevel@tonic-gate * extracted can continue to be extracted.
9707c478bd9Sstevel@tonic-gate */
9717c478bd9Sstevel@tonic-gate if (Hdr_type == BAR) {
9727c478bd9Sstevel@tonic-gate skip_bar_volhdr();
9737c478bd9Sstevel@tonic-gate }
9747c478bd9Sstevel@tonic-gate
9757c478bd9Sstevel@tonic-gate continue;
9767c478bd9Sstevel@tonic-gate } else {
9777c478bd9Sstevel@tonic-gate eof = 0;
978*6d3b960aSAndy Fiddaman SBlocks += (ulong_t)rv;
9797c478bd9Sstevel@tonic-gate }
9807c478bd9Sstevel@tonic-gate } /* (Buffr.b_end_p - Buffr.b_in_p) <= Bufsize */
9817c478bd9Sstevel@tonic-gate
9827c478bd9Sstevel@tonic-gate } else { /* Dflag */
9837c478bd9Sstevel@tonic-gate errno = 0;
9847c478bd9Sstevel@tonic-gate if ((rv = g_read(Device, Archive, Buffr.b_in_p, Bufsize)) < 0) {
9857c478bd9Sstevel@tonic-gate return (-1);
9867c478bd9Sstevel@tonic-gate } /* (rv = g_read(Device, Archive ... */
9877c478bd9Sstevel@tonic-gate Buffr.b_in_p += rv;
988*6d3b960aSAndy Fiddaman Buffr.b_cnt += rv;
9897c478bd9Sstevel@tonic-gate if (rv == Bufsize) {
9907c478bd9Sstevel@tonic-gate eof = 0;
9917c478bd9Sstevel@tonic-gate Blocks++;
9927c478bd9Sstevel@tonic-gate } else if (!rv) {
9937c478bd9Sstevel@tonic-gate if (!eof) {
9947c478bd9Sstevel@tonic-gate eof = 1;
9957c478bd9Sstevel@tonic-gate return (rv);
9967c478bd9Sstevel@tonic-gate }
9977c478bd9Sstevel@tonic-gate return (-1);
9987c478bd9Sstevel@tonic-gate } else {
9997c478bd9Sstevel@tonic-gate eof = 0;
1000*6d3b960aSAndy Fiddaman SBlocks += (ulong_t)rv;
10017c478bd9Sstevel@tonic-gate }
10027c478bd9Sstevel@tonic-gate }
10037c478bd9Sstevel@tonic-gate return (rv);
10047c478bd9Sstevel@tonic-gate }
10057c478bd9Sstevel@tonic-gate
10067c478bd9Sstevel@tonic-gate /*
10077c478bd9Sstevel@tonic-gate * bflush: Move wr_cnt bytes from data_p into the I/O buffer. When the
10087c478bd9Sstevel@tonic-gate * I/O buffer is full, Flushbuf is set and the buffer is written out.
10097c478bd9Sstevel@tonic-gate */
10107c478bd9Sstevel@tonic-gate
10117c478bd9Sstevel@tonic-gate static void
bflush(void)10127c478bd9Sstevel@tonic-gate bflush(void)
10137c478bd9Sstevel@tonic-gate {
10147c478bd9Sstevel@tonic-gate int rv;
10157c478bd9Sstevel@tonic-gate
10167c478bd9Sstevel@tonic-gate while (Buffr.b_cnt >= Bufsize) {
10177c478bd9Sstevel@tonic-gate errno = 0;
10187c478bd9Sstevel@tonic-gate if ((rv = g_write(Device, Archive, Buffr.b_out_p,
10197c478bd9Sstevel@tonic-gate Bufsize)) < 0) {
10207c478bd9Sstevel@tonic-gate if (errno == ENOSPC && !Dflag)
10217c478bd9Sstevel@tonic-gate rv = chgreel(OUTPUT);
10227c478bd9Sstevel@tonic-gate else
10237c478bd9Sstevel@tonic-gate ioerror(OUTPUT);
10247c478bd9Sstevel@tonic-gate }
10257c478bd9Sstevel@tonic-gate Buffr.b_out_p += rv;
1026*6d3b960aSAndy Fiddaman Buffr.b_cnt -= rv;
10277c478bd9Sstevel@tonic-gate if (rv == Bufsize)
10287c478bd9Sstevel@tonic-gate Blocks++;
10297c478bd9Sstevel@tonic-gate else if (rv > 0)
1030*6d3b960aSAndy Fiddaman SBlocks += (ulong_t)rv;
10317c478bd9Sstevel@tonic-gate }
10327c478bd9Sstevel@tonic-gate rstbuf();
10337c478bd9Sstevel@tonic-gate }
10347c478bd9Sstevel@tonic-gate
10357c478bd9Sstevel@tonic-gate /*
10367c478bd9Sstevel@tonic-gate * chgreel: Determine if end-of-medium has been reached. If it has,
10377c478bd9Sstevel@tonic-gate * close the current medium and prompt the user for the next medium.
10387c478bd9Sstevel@tonic-gate */
10397c478bd9Sstevel@tonic-gate
10407c478bd9Sstevel@tonic-gate static int
chgreel(int dir)10417c478bd9Sstevel@tonic-gate chgreel(int dir)
10427c478bd9Sstevel@tonic-gate {
10437c478bd9Sstevel@tonic-gate int lastchar, tryagain, askagain, rv;
10447c478bd9Sstevel@tonic-gate int tmpdev;
10457c478bd9Sstevel@tonic-gate char str[APATH];
10467c478bd9Sstevel@tonic-gate struct stat statb;
10477c478bd9Sstevel@tonic-gate
10487c478bd9Sstevel@tonic-gate rv = 0;
10497c478bd9Sstevel@tonic-gate if (fstat(Archive, &statb) < 0)
10507c478bd9Sstevel@tonic-gate msg(EXTN, "Error during stat() of archive");
10517c478bd9Sstevel@tonic-gate if ((statb.st_mode & S_IFMT) != S_IFCHR) {
10527c478bd9Sstevel@tonic-gate if (dir == INPUT) {
10537c478bd9Sstevel@tonic-gate msg(EXT, "%s%s\n",
10547c478bd9Sstevel@tonic-gate "Can't read input: end of file encountered ",
10557c478bd9Sstevel@tonic-gate "prior to expected end of archive.");
10567c478bd9Sstevel@tonic-gate }
10577c478bd9Sstevel@tonic-gate }
10587c478bd9Sstevel@tonic-gate msg(EPOST, "\007End of medium on \"%s\".", dir ? "output" : "input");
10597c478bd9Sstevel@tonic-gate if (is_floppy(Archive))
10607c478bd9Sstevel@tonic-gate (void) ioctl(Archive, FDEJECT, NULL);
10617c478bd9Sstevel@tonic-gate if ((close(Archive) != 0) && (dir == OUTPUT))
10627c478bd9Sstevel@tonic-gate msg(EXTN, "close error");
10637c478bd9Sstevel@tonic-gate Archive = 0;
10647c478bd9Sstevel@tonic-gate Volcnt++;
10657c478bd9Sstevel@tonic-gate for (;;) {
1066ced83f9bSceastha if (Rtty_p == NULL)
10677c478bd9Sstevel@tonic-gate Rtty_p = fopen(Ttyname, "r");
10687c478bd9Sstevel@tonic-gate do { /* tryagain */
10697c478bd9Sstevel@tonic-gate if (IOfil_p) {
10707c478bd9Sstevel@tonic-gate do {
10715fbb8099SNobutomo Nakano msg(EPOST, Eom_p, Volcnt);
10727c478bd9Sstevel@tonic-gate if (!Rtty_p || fgets(str, sizeof (str),
1073ced83f9bSceastha Rtty_p) == NULL)
10747c478bd9Sstevel@tonic-gate msg(EXT, "Cannot read tty.");
10757c478bd9Sstevel@tonic-gate askagain = 0;
10767c478bd9Sstevel@tonic-gate switch (*str) {
10777c478bd9Sstevel@tonic-gate case '\n':
10787c478bd9Sstevel@tonic-gate (void) strcpy(str, IOfil_p);
10797c478bd9Sstevel@tonic-gate break;
10807c478bd9Sstevel@tonic-gate case 'q':
10817c478bd9Sstevel@tonic-gate exit(EXIT_CODE);
10827c478bd9Sstevel@tonic-gate default:
10837c478bd9Sstevel@tonic-gate askagain = 1;
10847c478bd9Sstevel@tonic-gate }
10857c478bd9Sstevel@tonic-gate } while (askagain);
10867c478bd9Sstevel@tonic-gate } else {
10877c478bd9Sstevel@tonic-gate
10887c478bd9Sstevel@tonic-gate if (Hdr_type == BAR)
10897c478bd9Sstevel@tonic-gate Bar_vol_num++;
10907c478bd9Sstevel@tonic-gate
10917c478bd9Sstevel@tonic-gate msg(EPOST,
10927c478bd9Sstevel@tonic-gate "To continue, type device/file name when "
10937c478bd9Sstevel@tonic-gate "ready.");
10947c478bd9Sstevel@tonic-gate if (!Rtty_p || fgets(str, sizeof (str),
1095ced83f9bSceastha Rtty_p) == NULL)
10967c478bd9Sstevel@tonic-gate msg(EXT, "Cannot read tty.");
10977c478bd9Sstevel@tonic-gate lastchar = strlen(str) - 1;
10987c478bd9Sstevel@tonic-gate if (*(str + lastchar) == '\n') /* remove '\n' */
10997c478bd9Sstevel@tonic-gate *(str + lastchar) = '\0';
11007c478bd9Sstevel@tonic-gate if (!*str)
11017c478bd9Sstevel@tonic-gate exit(EXIT_CODE);
11027c478bd9Sstevel@tonic-gate }
11037c478bd9Sstevel@tonic-gate tryagain = 0;
11047c478bd9Sstevel@tonic-gate if ((Archive = open(str, dir)) < 0) {
11057c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot open \"%s\"", str);
11067c478bd9Sstevel@tonic-gate tryagain = 1;
11077c478bd9Sstevel@tonic-gate }
11087c478bd9Sstevel@tonic-gate } while (tryagain);
11097c478bd9Sstevel@tonic-gate (void) g_init(&tmpdev, &Archive);
11107c478bd9Sstevel@tonic-gate if (tmpdev != Device)
11117c478bd9Sstevel@tonic-gate msg(EXT, "Cannot change media types in mid-stream.");
11127c478bd9Sstevel@tonic-gate if (dir == INPUT)
11137c478bd9Sstevel@tonic-gate break;
11147c478bd9Sstevel@tonic-gate else { /* dir == OUTPUT */
11157c478bd9Sstevel@tonic-gate errno = 0;
11167c478bd9Sstevel@tonic-gate if ((rv = g_write(Device, Archive, Buffr.b_out_p,
11177c478bd9Sstevel@tonic-gate Bufsize)) == Bufsize)
11187c478bd9Sstevel@tonic-gate break;
11197c478bd9Sstevel@tonic-gate else
11207c478bd9Sstevel@tonic-gate msg(ERR,
11217c478bd9Sstevel@tonic-gate "Unable to write this medium, try "
11227c478bd9Sstevel@tonic-gate "another.");
11237c478bd9Sstevel@tonic-gate }
11247c478bd9Sstevel@tonic-gate } /* ;; */
11257c478bd9Sstevel@tonic-gate Eomflag = 0;
11267c478bd9Sstevel@tonic-gate return (rv);
11277c478bd9Sstevel@tonic-gate }
11287c478bd9Sstevel@tonic-gate
11297c478bd9Sstevel@tonic-gate /*
11307c478bd9Sstevel@tonic-gate * ckname: Check filenames against user specified patterns,
11317c478bd9Sstevel@tonic-gate * and/or ask the user for new name when -r is used.
11327c478bd9Sstevel@tonic-gate */
11337c478bd9Sstevel@tonic-gate
11347c478bd9Sstevel@tonic-gate static int
ckname(int flag)11357c478bd9Sstevel@tonic-gate ckname(int flag)
11367c478bd9Sstevel@tonic-gate {
1137ced83f9bSceastha int lastchar;
1138ced83f9bSceastha size_t rename_bufsz = Max_namesz + 1;
11397c478bd9Sstevel@tonic-gate
11407c478bd9Sstevel@tonic-gate if (Hdr_type != TAR && Hdr_type != USTAR && Hdr_type != BAR) {
11417c478bd9Sstevel@tonic-gate /* Re-visit tar size issues later */
11427c478bd9Sstevel@tonic-gate if (G_p->g_namesz - 1 > Max_namesz) {
11437c478bd9Sstevel@tonic-gate msg(ERR, "Name exceeds maximum length - skipped.");
11447c478bd9Sstevel@tonic-gate return (F_SKIP);
11457c478bd9Sstevel@tonic-gate }
11467c478bd9Sstevel@tonic-gate }
11477c478bd9Sstevel@tonic-gate
11487c478bd9Sstevel@tonic-gate if (Pat_pp && !matched())
11497c478bd9Sstevel@tonic-gate return (F_SKIP);
1150ced83f9bSceastha
1151ced83f9bSceastha /* rename interactively */
1152ced83f9bSceastha if ((Args & OCr) && !Adir && !G_p->g_rw_sysattr) {
11537c478bd9Sstevel@tonic-gate (void) fprintf(Wtty_p, gettext("Rename \"%s%s%s\"? "),
1154ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? G_p->g_nam_p : Renam_p,
1155ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : gettext(" Attribute "),
1156ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : G_p->g_attrnam_p);
11577c478bd9Sstevel@tonic-gate (void) fflush(Wtty_p);
1158ced83f9bSceastha if (fgets(Renametmp_p, rename_bufsz, Rtty_p) == NULL)
11597c478bd9Sstevel@tonic-gate msg(EXT, "Cannot read tty.");
11607c478bd9Sstevel@tonic-gate if (feof(Rtty_p))
11617c478bd9Sstevel@tonic-gate exit(EXIT_CODE);
11627c478bd9Sstevel@tonic-gate lastchar = strlen(Renametmp_p) - 1;
11637c478bd9Sstevel@tonic-gate
11647c478bd9Sstevel@tonic-gate /* remove trailing '\n' */
11657c478bd9Sstevel@tonic-gate if (*(Renametmp_p + lastchar) == '\n')
11667c478bd9Sstevel@tonic-gate *(Renametmp_p + lastchar) = '\0';
11677c478bd9Sstevel@tonic-gate if (*Renametmp_p == '\0') {
11687c478bd9Sstevel@tonic-gate msg(POST, "%s%s%s Skipped.",
1169ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? G_p->g_nam_p :
1170ced83f9bSceastha G_p->g_attrfnam_p,
1171ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
1172ced83f9bSceastha gettext(" Attribute "),
1173ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : G_p->g_attrnam_p);
1174ced83f9bSceastha if (G_p->g_attrparent_p == NULL) {
11757c478bd9Sstevel@tonic-gate *G_p->g_nam_p = '\0';
1176ced83f9bSceastha }
1177ced83f9bSceastha if (Renam_attr_p) {
1178ced83f9bSceastha *Renam_attr_p = '\0';
1179ced83f9bSceastha }
11807c478bd9Sstevel@tonic-gate return (F_SKIP);
11817c478bd9Sstevel@tonic-gate } else if (strcmp(Renametmp_p, ".") != 0) {
1182ced83f9bSceastha if (G_p->g_attrnam_p == NULL) {
1183ced83f9bSceastha if (strlen(Renametmp_p) > strlen(
1184ced83f9bSceastha G_p->g_nam_p)) {
11857c478bd9Sstevel@tonic-gate if ((G_p->g_nam_p != &nambuf[0]) &&
1186ced83f9bSceastha (G_p->g_nam_p != &fullnam[0])) {
11877c478bd9Sstevel@tonic-gate free(G_p->g_nam_p);
1188ced83f9bSceastha G_p->g_nam_p = e_zalloc(E_EXIT,
1189ced83f9bSceastha rename_bufsz);
11907c478bd9Sstevel@tonic-gate }
1191ced83f9bSceastha }
1192ced83f9bSceastha if (Renam_attr_p) {
1193ced83f9bSceastha *Renam_attr_p = '\0';
1194ced83f9bSceastha }
1195ced83f9bSceastha if ((strlcpy(Renam_p, Renametmp_p,
1196ced83f9bSceastha rename_bufsz) > rename_bufsz) ||
1197ced83f9bSceastha (strlcpy(G_p->g_nam_p, Renametmp_p,
1198ced83f9bSceastha rename_bufsz) > rename_bufsz)) {
1199ced83f9bSceastha msg(EXTN, "buffer overflow");
1200ced83f9bSceastha }
1201ced83f9bSceastha } else {
1202ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
12037c478bd9Sstevel@tonic-gate free(G_p->g_attrnam_p);
12047c478bd9Sstevel@tonic-gate G_p->g_attrnam_p = e_strdup(E_EXIT,
12057c478bd9Sstevel@tonic-gate Renametmp_p);
12067c478bd9Sstevel@tonic-gate (void) strcpy(G_p->g_nam_p, Renam_p);
1207ced83f9bSceastha if (Renam_attr_p) {
1208ced83f9bSceastha if (strlcpy(Renam_attr_p,
1209ced83f9bSceastha Renametmp_p, rename_bufsz) >
1210ced83f9bSceastha rename_bufsz) {
1211ced83f9bSceastha msg(EXTN,
1212ced83f9bSceastha "buffer overflow");
12137c478bd9Sstevel@tonic-gate }
1214ced83f9bSceastha }
1215ced83f9bSceastha }
1216ced83f9bSceastha }
1217ced83f9bSceastha } else {
1218ced83f9bSceastha if (G_p->g_attrnam_p == NULL) {
1219ced83f9bSceastha *Renam_p = '\0';
1220ced83f9bSceastha }
1221ced83f9bSceastha if (Renam_attr_p) {
1222ced83f9bSceastha *Renam_attr_p = '\0';
1223ced83f9bSceastha }
12247c478bd9Sstevel@tonic-gate }
12257c478bd9Sstevel@tonic-gate }
12267c478bd9Sstevel@tonic-gate if (flag != 0 || Onecopy == 0) {
12277c478bd9Sstevel@tonic-gate VERBOSE((Args & OCt), G_p->g_nam_p);
12287c478bd9Sstevel@tonic-gate }
12297c478bd9Sstevel@tonic-gate if (Args & OCt)
12307c478bd9Sstevel@tonic-gate return (F_SKIP);
12317c478bd9Sstevel@tonic-gate return (F_EXTR);
12327c478bd9Sstevel@tonic-gate }
12337c478bd9Sstevel@tonic-gate
12347c478bd9Sstevel@tonic-gate /*
12357c478bd9Sstevel@tonic-gate * ckopts: Check the validity of all command line options.
12367c478bd9Sstevel@tonic-gate */
12377c478bd9Sstevel@tonic-gate
12387c478bd9Sstevel@tonic-gate static void
ckopts(long mask)12397c478bd9Sstevel@tonic-gate ckopts(long mask)
12407c478bd9Sstevel@tonic-gate {
12417c478bd9Sstevel@tonic-gate int oflag;
12427c478bd9Sstevel@tonic-gate char *t_p;
12437c478bd9Sstevel@tonic-gate long errmsk;
1244647ab8f4Sceastha uid_t Euid = geteuid(); /* Effective uid of invoker */
1245647ab8f4Sceastha #ifdef SOLARIS_PRIVS
1246647ab8f4Sceastha priv_set_t *privset;
12473a3e214eSceastha priv_set_t *zones_privset;
1248647ab8f4Sceastha #endif /* SOLARIS_PRIVS */
12497c478bd9Sstevel@tonic-gate
12507c478bd9Sstevel@tonic-gate if (mask & OCi) {
12517c478bd9Sstevel@tonic-gate errmsk = mask & INV_MSK4i;
12527c478bd9Sstevel@tonic-gate } else if (mask & OCo) {
12537c478bd9Sstevel@tonic-gate errmsk = mask & INV_MSK4o;
12547c478bd9Sstevel@tonic-gate } else if (mask & OCp) {
12557c478bd9Sstevel@tonic-gate errmsk = mask & INV_MSK4p;
12567c478bd9Sstevel@tonic-gate } else {
12577c478bd9Sstevel@tonic-gate msg(ERR, "One of -i, -o or -p must be specified.");
12587c478bd9Sstevel@tonic-gate errmsk = 0;
12597c478bd9Sstevel@tonic-gate }
12607c478bd9Sstevel@tonic-gate
12617c478bd9Sstevel@tonic-gate if (errmsk) {
12627c478bd9Sstevel@tonic-gate /* if non-zero, invalid options were specified */
12637c478bd9Sstevel@tonic-gate Error_cnt++;
12647c478bd9Sstevel@tonic-gate }
12657c478bd9Sstevel@tonic-gate
12667c478bd9Sstevel@tonic-gate if ((mask & OCa) && (mask & OCm) && ((mask & OCi) ||
12677c478bd9Sstevel@tonic-gate (mask & OCo))) {
12687c478bd9Sstevel@tonic-gate msg(ERR, "-a and -m are mutually exclusive.");
12697c478bd9Sstevel@tonic-gate }
12707c478bd9Sstevel@tonic-gate
12715fbb8099SNobutomo Nakano if ((mask & OCc) && (mask & OCH) &&
12725fbb8099SNobutomo Nakano (strcmp("odc", Hdr_p) != 0 && strcmp("odc_sparse", Hdr_p) != 0)) {
12737c478bd9Sstevel@tonic-gate msg(ERR, "-c and -H are mutually exclusive.");
12747c478bd9Sstevel@tonic-gate }
12757c478bd9Sstevel@tonic-gate
12767c478bd9Sstevel@tonic-gate if ((mask & OCv) && (mask & OCV)) {
12777c478bd9Sstevel@tonic-gate msg(ERR, "-v and -V are mutually exclusive.");
12787c478bd9Sstevel@tonic-gate }
12797c478bd9Sstevel@tonic-gate
12807c478bd9Sstevel@tonic-gate if ((mask & OCt) && (mask & OCV)) {
12817c478bd9Sstevel@tonic-gate msg(ERR, "-t and -V are mutually exclusive.");
12827c478bd9Sstevel@tonic-gate }
12837c478bd9Sstevel@tonic-gate
12847c478bd9Sstevel@tonic-gate if ((mask & OCB) && (mask & OCC)) {
12857c478bd9Sstevel@tonic-gate msg(ERR, "-B and -C are mutually exclusive.");
12867c478bd9Sstevel@tonic-gate }
12877c478bd9Sstevel@tonic-gate
12887c478bd9Sstevel@tonic-gate if ((mask & OCH) && (mask & OC6)) {
12897c478bd9Sstevel@tonic-gate msg(ERR, "-H and -6 are mutually exclusive.");
12907c478bd9Sstevel@tonic-gate }
12917c478bd9Sstevel@tonic-gate
12927c478bd9Sstevel@tonic-gate if ((mask & OCM) && !((mask & OCI) || (mask & OCO))) {
12937c478bd9Sstevel@tonic-gate msg(ERR, "-M not meaningful without -O or -I.");
12947c478bd9Sstevel@tonic-gate }
12957c478bd9Sstevel@tonic-gate
12967c478bd9Sstevel@tonic-gate if ((mask & OCA) && !(mask & OCO)) {
12977c478bd9Sstevel@tonic-gate msg(ERR, "-A requires the -O option.");
12987c478bd9Sstevel@tonic-gate }
12997c478bd9Sstevel@tonic-gate
13007c478bd9Sstevel@tonic-gate if (Bufsize <= 0) {
13017c478bd9Sstevel@tonic-gate msg(ERR, "Illegal size given for -C option.");
13027c478bd9Sstevel@tonic-gate }
13037c478bd9Sstevel@tonic-gate
13047c478bd9Sstevel@tonic-gate if (mask & OCH) {
13057c478bd9Sstevel@tonic-gate t_p = Hdr_p;
13067c478bd9Sstevel@tonic-gate
13074c719f3bSToomas Soome while (*t_p != '\0') {
13087c478bd9Sstevel@tonic-gate if (isupper(*t_p)) {
13097c478bd9Sstevel@tonic-gate *t_p = 'a' + (*t_p - 'A');
13107c478bd9Sstevel@tonic-gate }
13117c478bd9Sstevel@tonic-gate
13127c478bd9Sstevel@tonic-gate t_p++;
13137c478bd9Sstevel@tonic-gate }
13147c478bd9Sstevel@tonic-gate
13157c478bd9Sstevel@tonic-gate if (!(strcmp("odc", Hdr_p))) {
13167c478bd9Sstevel@tonic-gate Hdr_type = CHR;
13177c478bd9Sstevel@tonic-gate Max_namesz = CPATH;
13187c478bd9Sstevel@tonic-gate Onecopy = 0;
13197c478bd9Sstevel@tonic-gate Use_old_stat = 1;
13205fbb8099SNobutomo Nakano } else if (!(strcmp("odc_sparse", Hdr_p))) {
13215fbb8099SNobutomo Nakano Hdr_type = CHR;
13225fbb8099SNobutomo Nakano Max_namesz = CPATH;
13235fbb8099SNobutomo Nakano Onecopy = 0;
13245fbb8099SNobutomo Nakano Use_old_stat = 1;
13255fbb8099SNobutomo Nakano Compress_sparse = 1;
13265fbb8099SNobutomo Nakano } else if (!(strcmp("ascii_sparse", Hdr_p))) {
13275fbb8099SNobutomo Nakano Hdr_type = ASC;
13285fbb8099SNobutomo Nakano Max_namesz = APATH;
13295fbb8099SNobutomo Nakano Onecopy = 1;
13305fbb8099SNobutomo Nakano Compress_sparse = 1;
13317c478bd9Sstevel@tonic-gate } else if (!(strcmp("crc", Hdr_p))) {
13327c478bd9Sstevel@tonic-gate Hdr_type = CRC;
13337c478bd9Sstevel@tonic-gate Max_namesz = APATH;
13347c478bd9Sstevel@tonic-gate Onecopy = 1;
13357c478bd9Sstevel@tonic-gate } else if (!(strcmp("tar", Hdr_p))) {
13367c478bd9Sstevel@tonic-gate if (Args & OCo) {
13377c478bd9Sstevel@tonic-gate Hdr_type = USTAR;
13387c478bd9Sstevel@tonic-gate Max_namesz = HNAMLEN - 1;
13397c478bd9Sstevel@tonic-gate } else {
13407c478bd9Sstevel@tonic-gate Hdr_type = TAR;
13417c478bd9Sstevel@tonic-gate Max_namesz = TNAMLEN - 1;
13427c478bd9Sstevel@tonic-gate }
13437c478bd9Sstevel@tonic-gate Onecopy = 0;
13447c478bd9Sstevel@tonic-gate } else if (!(strcmp("ustar", Hdr_p))) {
13457c478bd9Sstevel@tonic-gate Hdr_type = USTAR;
13467c478bd9Sstevel@tonic-gate Max_namesz = HNAMLEN - 1;
13477c478bd9Sstevel@tonic-gate Onecopy = 0;
13487c478bd9Sstevel@tonic-gate } else if (!(strcmp("bar", Hdr_p))) {
13497c478bd9Sstevel@tonic-gate if ((Args & OCo) || (Args & OCp)) {
13507c478bd9Sstevel@tonic-gate msg(ERR,
13517c478bd9Sstevel@tonic-gate "Header type bar can only be used with -i");
13527c478bd9Sstevel@tonic-gate }
13537c478bd9Sstevel@tonic-gate
13547c478bd9Sstevel@tonic-gate if (Args & OCP) {
13557c478bd9Sstevel@tonic-gate msg(ERR,
13567c478bd9Sstevel@tonic-gate "Can't preserve using bar header");
13577c478bd9Sstevel@tonic-gate }
13587c478bd9Sstevel@tonic-gate
13597c478bd9Sstevel@tonic-gate Hdr_type = BAR;
13607c478bd9Sstevel@tonic-gate Max_namesz = TNAMLEN - 1;
13617c478bd9Sstevel@tonic-gate Onecopy = 0;
13627c478bd9Sstevel@tonic-gate } else {
13637c478bd9Sstevel@tonic-gate msg(ERR, "Invalid header \"%s\" specified", Hdr_p);
13647c478bd9Sstevel@tonic-gate }
13657c478bd9Sstevel@tonic-gate }
13667c478bd9Sstevel@tonic-gate
13677c478bd9Sstevel@tonic-gate if (mask & OCr) {
13687c478bd9Sstevel@tonic-gate Rtty_p = fopen(Ttyname, "r");
13697c478bd9Sstevel@tonic-gate Wtty_p = fopen(Ttyname, "w");
13707c478bd9Sstevel@tonic-gate
1371ced83f9bSceastha if (Rtty_p == NULL || Wtty_p == NULL) {
13727c478bd9Sstevel@tonic-gate msg(ERR, "Cannot rename, \"%s\" missing", Ttyname);
13737c478bd9Sstevel@tonic-gate }
13747c478bd9Sstevel@tonic-gate }
13757c478bd9Sstevel@tonic-gate
1376ced83f9bSceastha if ((mask & OCE) && (Ef_p = fopen(Efil_p, "r")) == NULL) {
13777c478bd9Sstevel@tonic-gate msg(ERR, "Cannot open \"%s\" to read patterns", Efil_p);
13787c478bd9Sstevel@tonic-gate }
13797c478bd9Sstevel@tonic-gate
13807c478bd9Sstevel@tonic-gate if ((mask & OCI) && (Archive = open(IOfil_p, O_RDONLY)) < 0) {
13817c478bd9Sstevel@tonic-gate msg(ERR, "Cannot open \"%s\" for input", IOfil_p);
13827c478bd9Sstevel@tonic-gate }
13837c478bd9Sstevel@tonic-gate
13847c478bd9Sstevel@tonic-gate if (mask & OCO) {
13857c478bd9Sstevel@tonic-gate if (mask & OCA) {
13867c478bd9Sstevel@tonic-gate if ((Archive = open(IOfil_p, O_RDWR)) < 0) {
13877c478bd9Sstevel@tonic-gate msg(ERR,
13887c478bd9Sstevel@tonic-gate "Cannot open \"%s\" for append",
13897c478bd9Sstevel@tonic-gate IOfil_p);
13907c478bd9Sstevel@tonic-gate }
13917c478bd9Sstevel@tonic-gate } else {
13927c478bd9Sstevel@tonic-gate oflag = (O_WRONLY | O_CREAT | O_TRUNC);
13937c478bd9Sstevel@tonic-gate
13947c478bd9Sstevel@tonic-gate if ((Archive = open(IOfil_p, oflag, 0777)) < 0) {
13957c478bd9Sstevel@tonic-gate msg(ERR,
13967c478bd9Sstevel@tonic-gate "Cannot open \"%s\" for output",
13977c478bd9Sstevel@tonic-gate IOfil_p);
13987c478bd9Sstevel@tonic-gate }
13997c478bd9Sstevel@tonic-gate }
14007c478bd9Sstevel@tonic-gate }
14017c478bd9Sstevel@tonic-gate
1402647ab8f4Sceastha #ifdef SOLARIS_PRIVS
1403647ab8f4Sceastha if ((privset = priv_allocset()) == NULL) {
1404647ab8f4Sceastha msg(ERR, "Unable to allocate privilege set");
1405647ab8f4Sceastha } else if (getppriv(PRIV_EFFECTIVE, privset) != 0) {
1406647ab8f4Sceastha msg(ERR, "Unable to obtain privilege set");
1407647ab8f4Sceastha } else {
14083a3e214eSceastha zones_privset = priv_str_to_set("zone", "", NULL);
14093a3e214eSceastha if (zones_privset != NULL) {
14103a3e214eSceastha privileged = (priv_issubset(zones_privset,
14113a3e214eSceastha privset) == B_TRUE);
14123a3e214eSceastha priv_freeset(zones_privset);
14133a3e214eSceastha } else {
14143a3e214eSceastha msg(ERR, "Unable to map privilege to privilege set");
14153a3e214eSceastha }
1416647ab8f4Sceastha }
1417647ab8f4Sceastha if (privset != NULL) {
1418647ab8f4Sceastha priv_freeset(privset);
1419647ab8f4Sceastha }
1420647ab8f4Sceastha #else
1421647ab8f4Sceastha privileged = (Euid == 0);
1422647ab8f4Sceastha #endif /* SOLARIS_PRIVS */
1423647ab8f4Sceastha
14247c478bd9Sstevel@tonic-gate if (mask & OCR) {
1425ced83f9bSceastha if ((Rpw_p = getpwnam(Own_p)) == NULL) {
14267c478bd9Sstevel@tonic-gate msg(ERR, "\"%s\" is not a valid user id", Own_p);
1427647ab8f4Sceastha } else if ((Euid != Rpw_p->pw_uid) && !privileged) {
1428647ab8f4Sceastha msg(ERR, "R option only valid for super-user or "
1429647ab8f4Sceastha "id matches login id of user executing cpio");
14307c478bd9Sstevel@tonic-gate }
14317c478bd9Sstevel@tonic-gate }
14327c478bd9Sstevel@tonic-gate
14337c478bd9Sstevel@tonic-gate if ((mask & OCo) && !(mask & OCO)) {
14347c478bd9Sstevel@tonic-gate Out_p = stderr;
14357c478bd9Sstevel@tonic-gate }
14367c478bd9Sstevel@tonic-gate
14377c478bd9Sstevel@tonic-gate if ((mask & OCp) && ((mask & (OCB|OCC)) == 0)) {
14387c478bd9Sstevel@tonic-gate /*
14397c478bd9Sstevel@tonic-gate * We are in pass mode with no block size specified. Use the
14407c478bd9Sstevel@tonic-gate * larger of the native page size and 8192.
14417c478bd9Sstevel@tonic-gate */
14427c478bd9Sstevel@tonic-gate
14437c478bd9Sstevel@tonic-gate Bufsize = (PageSize > 8192) ? PageSize : 8192;
14447c478bd9Sstevel@tonic-gate }
14457c478bd9Sstevel@tonic-gate }
14467c478bd9Sstevel@tonic-gate
14477c478bd9Sstevel@tonic-gate /*
14487c478bd9Sstevel@tonic-gate * cksum: Calculate the simple checksum of a file (CRC) or header
14497c478bd9Sstevel@tonic-gate * (TARTYP (TAR and USTAR)). For -o and the CRC header, the file is opened and
14507c478bd9Sstevel@tonic-gate * the checksum is calculated. For -i and the CRC header, the checksum
14517c478bd9Sstevel@tonic-gate * is calculated as each block is transferred from the archive I/O buffer
14527c478bd9Sstevel@tonic-gate * to the file system I/O buffer. The TARTYP (TAR and USTAR) headers calculate
14537c478bd9Sstevel@tonic-gate * the simple checksum of the header (with the checksum field of the
14547c478bd9Sstevel@tonic-gate * header initialized to all spaces (\040).
14557c478bd9Sstevel@tonic-gate */
14567c478bd9Sstevel@tonic-gate
1457*6d3b960aSAndy Fiddaman static uint_t
cksum(char hdr,int byt_cnt,int * err)14587c478bd9Sstevel@tonic-gate cksum(char hdr, int byt_cnt, int *err)
14597c478bd9Sstevel@tonic-gate {
14607c478bd9Sstevel@tonic-gate char *crc_p, *end_p;
14617c478bd9Sstevel@tonic-gate int cnt;
1462*6d3b960aSAndy Fiddaman uint_t checksum = 0, have;
14637c478bd9Sstevel@tonic-gate off_t lcnt;
14647c478bd9Sstevel@tonic-gate
14657c478bd9Sstevel@tonic-gate if (err != NULL)
14667c478bd9Sstevel@tonic-gate *err = 0;
14677c478bd9Sstevel@tonic-gate switch (hdr) {
14687c478bd9Sstevel@tonic-gate case CRC:
14697c478bd9Sstevel@tonic-gate if (Args & OCi) { /* do running checksum */
14707c478bd9Sstevel@tonic-gate end_p = Buffr.b_out_p + byt_cnt;
14717c478bd9Sstevel@tonic-gate for (crc_p = Buffr.b_out_p; crc_p < end_p; crc_p++)
1472*6d3b960aSAndy Fiddaman checksum += (uint_t)*crc_p;
14737c478bd9Sstevel@tonic-gate break;
14747c478bd9Sstevel@tonic-gate }
14757c478bd9Sstevel@tonic-gate /* OCo - do checksum of file */
14767c478bd9Sstevel@tonic-gate lcnt = G_p->g_filesz;
14777c478bd9Sstevel@tonic-gate
14787c478bd9Sstevel@tonic-gate while (lcnt > 0) {
14797c478bd9Sstevel@tonic-gate have = (lcnt < Bufsize) ? lcnt : Bufsize;
14807c478bd9Sstevel@tonic-gate errno = 0;
14817c478bd9Sstevel@tonic-gate if (read(Ifile, Buf_p, have) != have) {
14827c478bd9Sstevel@tonic-gate msg(ERR, "Error computing checksum.");
14837c478bd9Sstevel@tonic-gate if (err != NULL)
14847c478bd9Sstevel@tonic-gate *err = 1;
14857c478bd9Sstevel@tonic-gate break;
14867c478bd9Sstevel@tonic-gate }
14877c478bd9Sstevel@tonic-gate end_p = Buf_p + have;
14887c478bd9Sstevel@tonic-gate for (crc_p = Buf_p; crc_p < end_p; crc_p++)
14897c478bd9Sstevel@tonic-gate checksum += (long)*crc_p;
14907c478bd9Sstevel@tonic-gate lcnt -= have;
14917c478bd9Sstevel@tonic-gate }
14927c478bd9Sstevel@tonic-gate if (lseek(Ifile, (off_t)0, SEEK_ABS) < 0)
14937c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot reset file after checksum");
14947c478bd9Sstevel@tonic-gate break;
14957c478bd9Sstevel@tonic-gate case TARTYP: /* TAR and USTAR */
14967c478bd9Sstevel@tonic-gate crc_p = Thdr_p->tbuf.t_cksum;
14977c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < TCRCLEN; cnt++) {
14987c478bd9Sstevel@tonic-gate *crc_p = '\040';
14997c478bd9Sstevel@tonic-gate crc_p++;
15007c478bd9Sstevel@tonic-gate }
15017c478bd9Sstevel@tonic-gate crc_p = (char *)Thdr_p;
15027c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < TARSZ; cnt++) {
15037c478bd9Sstevel@tonic-gate /*
15047c478bd9Sstevel@tonic-gate * tar uses unsigned checksum, so we must use unsigned
15057c478bd9Sstevel@tonic-gate * here in order to be able to read tar archives.
15067c478bd9Sstevel@tonic-gate */
15077c478bd9Sstevel@tonic-gate checksum += (long)((unsigned char)(*crc_p));
15087c478bd9Sstevel@tonic-gate crc_p++;
15097c478bd9Sstevel@tonic-gate }
15107c478bd9Sstevel@tonic-gate break;
15117c478bd9Sstevel@tonic-gate default:
15127c478bd9Sstevel@tonic-gate msg(EXT, "Impossible header type.");
15137c478bd9Sstevel@tonic-gate } /* hdr */
15147c478bd9Sstevel@tonic-gate return (checksum);
15157c478bd9Sstevel@tonic-gate }
15167c478bd9Sstevel@tonic-gate
15177c478bd9Sstevel@tonic-gate /*
15187c478bd9Sstevel@tonic-gate * creat_hdr: Fill in the generic header structure with the specific
15197c478bd9Sstevel@tonic-gate * header information based on the value of Hdr_type.
15207c478bd9Sstevel@tonic-gate *
15217c478bd9Sstevel@tonic-gate * return (1) if this process was successful, and (0) otherwise.
15227c478bd9Sstevel@tonic-gate */
15237c478bd9Sstevel@tonic-gate
15247c478bd9Sstevel@tonic-gate static int
creat_hdr(void)15257c478bd9Sstevel@tonic-gate creat_hdr(void)
15267c478bd9Sstevel@tonic-gate {
15277c478bd9Sstevel@tonic-gate ushort_t ftype;
15287c478bd9Sstevel@tonic-gate int fullnamesize;
15297c478bd9Sstevel@tonic-gate dev_t dev;
15307c478bd9Sstevel@tonic-gate ino_t ino;
15317c478bd9Sstevel@tonic-gate
15327c478bd9Sstevel@tonic-gate ftype = SrcSt.st_mode & Ftype;
15337c478bd9Sstevel@tonic-gate Adir = (ftype == S_IFDIR);
1534cdd68f5aSceastha Aspec = (ftype == S_IFBLK || ftype == S_IFCHR || ftype == S_IFIFO ||
1535cdd68f5aSceastha ftype == S_IFSOCK);
15367c478bd9Sstevel@tonic-gate switch (Hdr_type) {
15377c478bd9Sstevel@tonic-gate case BIN:
15387c478bd9Sstevel@tonic-gate Gen.g_magic = CMN_BIN;
15397c478bd9Sstevel@tonic-gate break;
15407c478bd9Sstevel@tonic-gate case CHR:
15417c478bd9Sstevel@tonic-gate Gen.g_magic = CMN_BIN;
15427c478bd9Sstevel@tonic-gate break;
15437c478bd9Sstevel@tonic-gate case ASC:
15447c478bd9Sstevel@tonic-gate Gen.g_magic = CMN_ASC;
15457c478bd9Sstevel@tonic-gate break;
15467c478bd9Sstevel@tonic-gate case CRC:
15477c478bd9Sstevel@tonic-gate Gen.g_magic = CMN_CRC;
15487c478bd9Sstevel@tonic-gate break;
15497c478bd9Sstevel@tonic-gate case USTAR:
15507c478bd9Sstevel@tonic-gate /*
15517c478bd9Sstevel@tonic-gate * If the length of the full name is greater than 256,
15527c478bd9Sstevel@tonic-gate * print out a message and return.
15537c478bd9Sstevel@tonic-gate */
15547c478bd9Sstevel@tonic-gate if ((fullnamesize = strlen(Gen.g_nam_p)) > MAXNAM) {
15557c478bd9Sstevel@tonic-gate msg(ERR,
15567c478bd9Sstevel@tonic-gate "%s: file name too long", Gen.g_nam_p);
15577c478bd9Sstevel@tonic-gate return (0);
15587c478bd9Sstevel@tonic-gate } else if (fullnamesize > NAMSIZ) {
15597c478bd9Sstevel@tonic-gate /*
15607c478bd9Sstevel@tonic-gate * The length of the full name is greater than
15617c478bd9Sstevel@tonic-gate * 100, so we must split the filename from the
15627c478bd9Sstevel@tonic-gate * path
15637c478bd9Sstevel@tonic-gate */
15647c478bd9Sstevel@tonic-gate char namebuff[NAMSIZ+1];
15657c478bd9Sstevel@tonic-gate char prebuff[PRESIZ+1];
15667c478bd9Sstevel@tonic-gate char *lastslash;
15677c478bd9Sstevel@tonic-gate int presize, namesize;
15687c478bd9Sstevel@tonic-gate
15697c478bd9Sstevel@tonic-gate (void) memset(namebuff, '\0',
15707c478bd9Sstevel@tonic-gate sizeof (namebuff));
15717c478bd9Sstevel@tonic-gate (void) memset(prebuff, '\0', sizeof (prebuff));
15727c478bd9Sstevel@tonic-gate
15737c478bd9Sstevel@tonic-gate lastslash = strrchr(Gen.g_nam_p, '/');
15747c478bd9Sstevel@tonic-gate
15757c478bd9Sstevel@tonic-gate if (lastslash != NULL) {
15767c478bd9Sstevel@tonic-gate namesize = strlen(++lastslash);
15777c478bd9Sstevel@tonic-gate presize = fullnamesize - namesize - 1;
15787c478bd9Sstevel@tonic-gate } else {
15797c478bd9Sstevel@tonic-gate namesize = fullnamesize;
15807c478bd9Sstevel@tonic-gate lastslash = Gen.g_nam_p;
15817c478bd9Sstevel@tonic-gate presize = 0;
15827c478bd9Sstevel@tonic-gate }
15837c478bd9Sstevel@tonic-gate
15847c478bd9Sstevel@tonic-gate /*
15857c478bd9Sstevel@tonic-gate * If the filename is greater than 100 we can't
15867c478bd9Sstevel@tonic-gate * archive the file
15877c478bd9Sstevel@tonic-gate */
15887c478bd9Sstevel@tonic-gate if (namesize > NAMSIZ) {
15897c478bd9Sstevel@tonic-gate msg(ERR,
15907c478bd9Sstevel@tonic-gate "%s: filename is greater than %d",
15917c478bd9Sstevel@tonic-gate lastslash, NAMSIZ);
15927c478bd9Sstevel@tonic-gate return (0);
15937c478bd9Sstevel@tonic-gate }
15947c478bd9Sstevel@tonic-gate (void) strncpy(&namebuff[0], lastslash,
15957c478bd9Sstevel@tonic-gate namesize);
15967c478bd9Sstevel@tonic-gate /*
15977c478bd9Sstevel@tonic-gate * If the prefix is greater than 155 we can't
15987c478bd9Sstevel@tonic-gate * archive the file.
15997c478bd9Sstevel@tonic-gate */
16007c478bd9Sstevel@tonic-gate if (presize > PRESIZ) {
16017c478bd9Sstevel@tonic-gate msg(ERR,
16027c478bd9Sstevel@tonic-gate "%s: prefix is greater than %d",
16037c478bd9Sstevel@tonic-gate Gen.g_nam_p, PRESIZ);
16047c478bd9Sstevel@tonic-gate return (0);
16057c478bd9Sstevel@tonic-gate }
16067c478bd9Sstevel@tonic-gate (void) strncpy(&prebuff[0], Gen.g_nam_p,
16077c478bd9Sstevel@tonic-gate presize);
16087c478bd9Sstevel@tonic-gate
16097c478bd9Sstevel@tonic-gate Gen.g_tname = e_zalloc(E_EXIT, namesize + 1);
16107c478bd9Sstevel@tonic-gate (void) strcpy(Gen.g_tname, namebuff);
16117c478bd9Sstevel@tonic-gate
16127c478bd9Sstevel@tonic-gate Gen.g_prefix = e_zalloc(E_EXIT, presize + 1);
16137c478bd9Sstevel@tonic-gate (void) strcpy(Gen.g_prefix, prebuff);
16147c478bd9Sstevel@tonic-gate } else {
16157c478bd9Sstevel@tonic-gate Gen.g_tname = Gen.g_nam_p;
16167c478bd9Sstevel@tonic-gate }
16177c478bd9Sstevel@tonic-gate (void) strcpy(Gen.g_tmagic, "ustar");
1618*6d3b960aSAndy Fiddaman (void) memcpy(Gen.g_version, "00", 2);
16197c478bd9Sstevel@tonic-gate
16207c478bd9Sstevel@tonic-gate dpasswd = getpwuid(SrcSt.st_uid);
1621ced83f9bSceastha if (dpasswd == NULL) {
16227c478bd9Sstevel@tonic-gate msg(EPOST,
16237c478bd9Sstevel@tonic-gate "cpio: could not get passwd information "
16247c478bd9Sstevel@tonic-gate "for %s%s%s",
1625ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
16267c478bd9Sstevel@tonic-gate Gen.g_nam_p : Gen.g_attrfnam_p,
1627ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
1628ced83f9bSceastha "" : Gen.g_rw_sysattr ?
1629ced83f9bSceastha gettext(" System Attribute ") :
1630ced83f9bSceastha gettext(" Attribute "),
1631ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
16327c478bd9Sstevel@tonic-gate "" : Gen.g_attrnam_p);
16337c478bd9Sstevel@tonic-gate /* make name null string */
16347c478bd9Sstevel@tonic-gate Gen.g_uname[0] = '\0';
16357c478bd9Sstevel@tonic-gate } else {
16367c478bd9Sstevel@tonic-gate (void) strncpy(&Gen.g_uname[0],
16377c478bd9Sstevel@tonic-gate dpasswd->pw_name, 32);
16387c478bd9Sstevel@tonic-gate }
16397c478bd9Sstevel@tonic-gate dgroup = getgrgid(SrcSt.st_gid);
1640ced83f9bSceastha if (dgroup == NULL) {
16417c478bd9Sstevel@tonic-gate msg(EPOST,
16427c478bd9Sstevel@tonic-gate "cpio: could not get group information "
16435fbb8099SNobutomo Nakano "for %s%s%s",
1644ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
16457c478bd9Sstevel@tonic-gate Gen.g_nam_p : Gen.g_attrfnam_p,
1646ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
1647ced83f9bSceastha "" : Gen.g_rw_sysattr ?
1648ced83f9bSceastha gettext(" System Attribute ") :
1649ced83f9bSceastha gettext(" Attribute "),
1650ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
16517c478bd9Sstevel@tonic-gate "" : Gen.g_attrnam_p);
16527c478bd9Sstevel@tonic-gate /* make name null string */
16537c478bd9Sstevel@tonic-gate Gen.g_gname[0] = '\0';
16547c478bd9Sstevel@tonic-gate } else {
16557c478bd9Sstevel@tonic-gate (void) strncpy(&Gen.g_gname[0],
16567c478bd9Sstevel@tonic-gate dgroup->gr_name, 32);
16577c478bd9Sstevel@tonic-gate }
16587c478bd9Sstevel@tonic-gate Gen.g_typeflag = tartype(ftype);
16597c478bd9Sstevel@tonic-gate /* FALLTHROUGH */
16607c478bd9Sstevel@tonic-gate case TAR:
16617c478bd9Sstevel@tonic-gate (void) memset(T_lname, '\0', sizeof (T_lname));
16627c478bd9Sstevel@tonic-gate break;
16637c478bd9Sstevel@tonic-gate default:
16647c478bd9Sstevel@tonic-gate msg(EXT, "Impossible header type.");
16657c478bd9Sstevel@tonic-gate }
16667c478bd9Sstevel@tonic-gate
1667ced83f9bSceastha if (Use_old_stat && (Gen.g_attrnam_p != NULL)) {
1668ced83f9bSceastha /*
1669ced83f9bSceastha * When processing extended attributes, creat_hdr()
1670ced83f9bSceastha * can get called multiple times which means that
1671ced83f9bSceastha * SrcSt.st.st_dev would have gotten converted to
1672ced83f9bSceastha * -Hodc format. We should always use the original
1673ced83f9bSceastha * device here as we need to be able to match on
1674ced83f9bSceastha * the original device id from the file that was
1675ced83f9bSceastha * previewed in sl_preview_synonyms().
1676ced83f9bSceastha */
1677ced83f9bSceastha dev = Savedev;
1678ced83f9bSceastha } else {
16797c478bd9Sstevel@tonic-gate dev = SrcSt.st_dev;
1680ced83f9bSceastha }
16817c478bd9Sstevel@tonic-gate ino = SrcSt.st_ino;
16827c478bd9Sstevel@tonic-gate
16837c478bd9Sstevel@tonic-gate if (Use_old_stat) {
16847c478bd9Sstevel@tonic-gate SrcSt = *OldSt;
16857c478bd9Sstevel@tonic-gate }
16867c478bd9Sstevel@tonic-gate
16877c478bd9Sstevel@tonic-gate Gen.g_namesz = strlen(Gen.g_nam_p) + 1;
16887c478bd9Sstevel@tonic-gate Gen.g_uid = SrcSt.st_uid;
16897c478bd9Sstevel@tonic-gate Gen.g_gid = SrcSt.st_gid;
16907c478bd9Sstevel@tonic-gate Gen.g_dev = SrcSt.st_dev;
16917c478bd9Sstevel@tonic-gate
16927c478bd9Sstevel@tonic-gate if (Use_old_stat) {
16937c478bd9Sstevel@tonic-gate /* -Hodc */
16947c478bd9Sstevel@tonic-gate
1695ced83f9bSceastha sl_info_t *p = sl_search(dev, ino, ftype);
16967c478bd9Sstevel@tonic-gate Gen.g_ino = p ? p->sl_ino2 : -1;
16977c478bd9Sstevel@tonic-gate
1698*6d3b960aSAndy Fiddaman if (Gen.g_ino == UINT_MAX) {
16997c478bd9Sstevel@tonic-gate msg(ERR, "%s%s%s: cannot be archived - inode too big "
17007c478bd9Sstevel@tonic-gate "for -Hodc format",
1701ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
17027c478bd9Sstevel@tonic-gate Gen.g_nam_p : Gen.g_attrfnam_p,
1703ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? "" : Gen.g_rw_sysattr ?
1704ced83f9bSceastha gettext(" System Attribute ") :
1705ced83f9bSceastha gettext(" Attribute "),
1706ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? "" : Gen.g_attrnam_p);
17077c478bd9Sstevel@tonic-gate return (0);
17087c478bd9Sstevel@tonic-gate }
17097c478bd9Sstevel@tonic-gate } else {
17107c478bd9Sstevel@tonic-gate Gen.g_ino = SrcSt.st_ino;
17117c478bd9Sstevel@tonic-gate }
17127c478bd9Sstevel@tonic-gate
17137c478bd9Sstevel@tonic-gate Gen.g_mode = SrcSt.st_mode;
17147c478bd9Sstevel@tonic-gate Gen.g_mtime = SrcSt.st_mtime;
1715ced83f9bSceastha Gen.g_nlink = Adir ? SrcSt.st_nlink : sl_numlinks(dev, ino, ftype);
17167c478bd9Sstevel@tonic-gate
17177c478bd9Sstevel@tonic-gate if (ftype == S_IFREG || ftype == S_IFLNK)
17187c478bd9Sstevel@tonic-gate Gen.g_filesz = (off_t)SrcSt.st_size;
17197c478bd9Sstevel@tonic-gate else
17207c478bd9Sstevel@tonic-gate Gen.g_filesz = (off_t)0;
17217c478bd9Sstevel@tonic-gate Gen.g_rdev = SrcSt.st_rdev;
17227c478bd9Sstevel@tonic-gate return (1);
17237c478bd9Sstevel@tonic-gate }
17247c478bd9Sstevel@tonic-gate
17257c478bd9Sstevel@tonic-gate /*
17267c478bd9Sstevel@tonic-gate * creat_lnk: Create a link from the existing name1_p to name2_p.
17277c478bd9Sstevel@tonic-gate */
17287c478bd9Sstevel@tonic-gate
17297c478bd9Sstevel@tonic-gate static
17307c478bd9Sstevel@tonic-gate int
creat_lnk(int dirfd,char * name1_p,char * name2_p)17317c478bd9Sstevel@tonic-gate creat_lnk(int dirfd, char *name1_p, char *name2_p)
17327c478bd9Sstevel@tonic-gate {
17337c478bd9Sstevel@tonic-gate int cnt = 0;
17347c478bd9Sstevel@tonic-gate
17357c478bd9Sstevel@tonic-gate do {
17367c478bd9Sstevel@tonic-gate errno = 0;
17377c478bd9Sstevel@tonic-gate if (!link(name1_p, name2_p)) {
17387c478bd9Sstevel@tonic-gate if (aclp != NULL) {
1739fa9e4066Sahrens acl_free(aclp);
17407c478bd9Sstevel@tonic-gate aclp = NULL;
1741fa9e4066Sahrens acl_is_set = 0;
17427c478bd9Sstevel@tonic-gate }
17437c478bd9Sstevel@tonic-gate cnt = 0;
17447c478bd9Sstevel@tonic-gate break;
1745647ab8f4Sceastha } else if ((errno == EEXIST) && (cnt == 0)) {
17467c478bd9Sstevel@tonic-gate struct stat lsb1;
17477c478bd9Sstevel@tonic-gate struct stat lsb2;
17487c478bd9Sstevel@tonic-gate
17497c478bd9Sstevel@tonic-gate /*
17507c478bd9Sstevel@tonic-gate * Check to see if we are trying to link this
17517c478bd9Sstevel@tonic-gate * file to itself. If so, count the effort as
17527c478bd9Sstevel@tonic-gate * successful. If the two files are different,
17537c478bd9Sstevel@tonic-gate * or if either lstat is unsuccessful, proceed
17547c478bd9Sstevel@tonic-gate * as we would have otherwise; the appropriate
17557c478bd9Sstevel@tonic-gate * error will be reported subsequently.
17567c478bd9Sstevel@tonic-gate */
17577c478bd9Sstevel@tonic-gate
17587c478bd9Sstevel@tonic-gate if (lstat(name1_p, &lsb1) != 0) {
17597c478bd9Sstevel@tonic-gate msg(ERR, "Cannot lstat source file %s",
17607c478bd9Sstevel@tonic-gate name1_p);
17617c478bd9Sstevel@tonic-gate } else {
17627c478bd9Sstevel@tonic-gate if (lstat(name2_p, &lsb2) != 0) {
17637c478bd9Sstevel@tonic-gate msg(ERR, "Cannot lstat "
1764647ab8f4Sceastha "destination file %s", name2_p);
17657c478bd9Sstevel@tonic-gate } else {
1766647ab8f4Sceastha if (lsb1.st_dev == lsb2.st_dev &&
1767647ab8f4Sceastha lsb1.st_ino == lsb2.st_ino) {
1768647ab8f4Sceastha VERBOSE((Args & (OCv | OCV)),
17697c478bd9Sstevel@tonic-gate name2_p);
17707c478bd9Sstevel@tonic-gate return (0);
17717c478bd9Sstevel@tonic-gate }
17727c478bd9Sstevel@tonic-gate }
17737c478bd9Sstevel@tonic-gate }
17747c478bd9Sstevel@tonic-gate
17757c478bd9Sstevel@tonic-gate if (!(Args & OCu) && G_p->g_mtime <= DesSt.st_mtime)
1776647ab8f4Sceastha msg(ERR, "Existing \"%s\" same age or newer",
17777c478bd9Sstevel@tonic-gate name2_p);
17787c478bd9Sstevel@tonic-gate else if (unlinkat(dirfd, get_component(name2_p), 0) < 0)
17797c478bd9Sstevel@tonic-gate msg(ERRN, "Error cannot unlink \"%s\"",
17807c478bd9Sstevel@tonic-gate name2_p);
17817c478bd9Sstevel@tonic-gate }
17827c478bd9Sstevel@tonic-gate cnt++;
17837c478bd9Sstevel@tonic-gate } while ((cnt < 2) && missdir(name2_p) == 0);
17847c478bd9Sstevel@tonic-gate if (!cnt) {
17857c478bd9Sstevel@tonic-gate char *newname;
17867c478bd9Sstevel@tonic-gate char *fromname;
17877c478bd9Sstevel@tonic-gate char *attrname;
17887c478bd9Sstevel@tonic-gate
17897c478bd9Sstevel@tonic-gate newname = name2_p;
17907c478bd9Sstevel@tonic-gate fromname = name1_p;
17917c478bd9Sstevel@tonic-gate attrname = Gen.g_attrnam_p;
17927c478bd9Sstevel@tonic-gate if (attrname) {
17937c478bd9Sstevel@tonic-gate if (Args & OCp) {
17947c478bd9Sstevel@tonic-gate newname = fromname = Fullnam_p;
17957c478bd9Sstevel@tonic-gate } else {
17967c478bd9Sstevel@tonic-gate newname = Gen.g_attrfnam_p;
17977c478bd9Sstevel@tonic-gate }
17987c478bd9Sstevel@tonic-gate }
17997c478bd9Sstevel@tonic-gate if (Args & OCv) {
18007c478bd9Sstevel@tonic-gate (void) fprintf(Err_p,
18017c478bd9Sstevel@tonic-gate gettext("%s%s%s linked to %s%s%s\n"), newname,
1802ced83f9bSceastha (attrname == NULL) ? "" : gettext(" attribute "),
1803ced83f9bSceastha (attrname == NULL) ? "" : attrname,
1804ced83f9bSceastha (attrname == NULL) ? fromname : newname,
1805ced83f9bSceastha (attrname == NULL) ? "" : gettext(" attribute "),
1806ced83f9bSceastha (attrname == NULL) ? "" : name1_p);
1807ced83f9bSceastha } else {
18087c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), newname);
1809ced83f9bSceastha }
18107c478bd9Sstevel@tonic-gate } else if (cnt == 1)
18117c478bd9Sstevel@tonic-gate msg(ERRN,
18127c478bd9Sstevel@tonic-gate "Unable to create directory for \"%s\"", name2_p);
18137c478bd9Sstevel@tonic-gate else if (cnt == 2)
18147c478bd9Sstevel@tonic-gate msg(ERRN,
18157c478bd9Sstevel@tonic-gate "Cannot link \"%s\" and \"%s\"", name1_p, name2_p);
18167c478bd9Sstevel@tonic-gate return (cnt);
18177c478bd9Sstevel@tonic-gate }
18187c478bd9Sstevel@tonic-gate
18197c478bd9Sstevel@tonic-gate /*
18207c478bd9Sstevel@tonic-gate * creat_spec:
18217c478bd9Sstevel@tonic-gate * Create one of the following:
18227c478bd9Sstevel@tonic-gate * directory
18237c478bd9Sstevel@tonic-gate * character special file
18247c478bd9Sstevel@tonic-gate * block special file
18257c478bd9Sstevel@tonic-gate * fifo
1826cdd68f5aSceastha * socket
18277c478bd9Sstevel@tonic-gate */
18287c478bd9Sstevel@tonic-gate
18297c478bd9Sstevel@tonic-gate static int
creat_spec(int dirfd)18307c478bd9Sstevel@tonic-gate creat_spec(int dirfd)
18317c478bd9Sstevel@tonic-gate {
18327c478bd9Sstevel@tonic-gate char *nam_p;
18337c478bd9Sstevel@tonic-gate int cnt, result, rv = 0;
18347c478bd9Sstevel@tonic-gate char *curdir;
18357c478bd9Sstevel@tonic-gate char *lastslash;
18367c478bd9Sstevel@tonic-gate
18377c478bd9Sstevel@tonic-gate Do_rename = 0; /* creat_tmp() may reset this */
18387c478bd9Sstevel@tonic-gate
18397c478bd9Sstevel@tonic-gate if (Args & OCp) {
18407c478bd9Sstevel@tonic-gate nam_p = Fullnam_p;
18417c478bd9Sstevel@tonic-gate } else {
18427c478bd9Sstevel@tonic-gate nam_p = G_p->g_nam_p;
18437c478bd9Sstevel@tonic-gate }
18447c478bd9Sstevel@tonic-gate
18457c478bd9Sstevel@tonic-gate /*
18467c478bd9Sstevel@tonic-gate * Is this the extraction of the hidden attribute directory?
1847ced83f9bSceastha * If we are processing the hidden attribute directory of an
1848ced83f9bSceastha * attribute, then just return as modes and times cannot be set.
1849ced83f9bSceastha * Otherwise, if we are processing a hidden attribute, just set
1850ced83f9bSceastha * the mode/times correctly and return.
18517c478bd9Sstevel@tonic-gate */
18527c478bd9Sstevel@tonic-gate
18537c478bd9Sstevel@tonic-gate if (Hiddendir) {
1854ced83f9bSceastha if (G_p->g_attrparent_p == NULL) {
1855647ab8f4Sceastha if (Args & OCR) {
1856647ab8f4Sceastha if (fchownat(dirfd, ".", Rpw_p->pw_uid,
1857647ab8f4Sceastha Rpw_p->pw_gid, 0) != 0) {
1858647ab8f4Sceastha msg(ERRN,
1859ced83f9bSceastha "Cannot chown() \"attribute "
1860ced83f9bSceastha "directory of file %s\"",
1861ced83f9bSceastha G_p->g_attrfnam_p);
1862647ab8f4Sceastha }
1863647ab8f4Sceastha } else if ((fchownat(dirfd, ".", G_p->g_uid,
1864647ab8f4Sceastha G_p->g_gid, 0) != 0) && privileged) {
18657c478bd9Sstevel@tonic-gate msg(ERRN,
18667c478bd9Sstevel@tonic-gate "Cannot chown() \"attribute directory of "
18677c478bd9Sstevel@tonic-gate "file %s\"", G_p->g_attrfnam_p);
18687c478bd9Sstevel@tonic-gate }
18697c478bd9Sstevel@tonic-gate
18707c478bd9Sstevel@tonic-gate if (fchmod(dirfd, G_p->g_mode) != 0) {
18717c478bd9Sstevel@tonic-gate msg(ERRN,
18727c478bd9Sstevel@tonic-gate "Cannot chmod() \"attribute directory of "
18737c478bd9Sstevel@tonic-gate "file %s\"", G_p->g_attrfnam_p);
18747c478bd9Sstevel@tonic-gate }
18757c478bd9Sstevel@tonic-gate
1876fa9e4066Sahrens acl_is_set = 0;
18777c478bd9Sstevel@tonic-gate if (Pflag && aclp != NULL) {
1878fa9e4066Sahrens if (facl_set(dirfd, aclp) < 0) {
18797c478bd9Sstevel@tonic-gate msg(ERRN,
18807c478bd9Sstevel@tonic-gate "failed to set acl on attribute"
1881ced83f9bSceastha " directory of %s ",
1882ced83f9bSceastha G_p->g_attrfnam_p);
18837c478bd9Sstevel@tonic-gate } else {
1884fa9e4066Sahrens acl_is_set = 1;
18857c478bd9Sstevel@tonic-gate }
1886fa9e4066Sahrens acl_free(aclp);
18877c478bd9Sstevel@tonic-gate aclp = NULL;
18887c478bd9Sstevel@tonic-gate }
1889ced83f9bSceastha }
18907c478bd9Sstevel@tonic-gate
18917c478bd9Sstevel@tonic-gate return (1);
18927c478bd9Sstevel@tonic-gate }
18937c478bd9Sstevel@tonic-gate
18947c478bd9Sstevel@tonic-gate result = stat(nam_p, &DesSt);
18957c478bd9Sstevel@tonic-gate
18967c478bd9Sstevel@tonic-gate if (ustar_dir() || Adir) {
18977c478bd9Sstevel@tonic-gate /*
18987c478bd9Sstevel@tonic-gate * The archive file is a directory.
18997c478bd9Sstevel@tonic-gate * Skip "." and ".."
19007c478bd9Sstevel@tonic-gate */
19017c478bd9Sstevel@tonic-gate
19027c478bd9Sstevel@tonic-gate curdir = strrchr(nam_p, '.');
19037c478bd9Sstevel@tonic-gate
19044c719f3bSToomas Soome if (curdir != NULL && curdir[1] == '\0') {
19057c478bd9Sstevel@tonic-gate lastslash = strrchr(nam_p, '/');
19067c478bd9Sstevel@tonic-gate
19077c478bd9Sstevel@tonic-gate if (lastslash != NULL) {
19087c478bd9Sstevel@tonic-gate lastslash++;
19097c478bd9Sstevel@tonic-gate } else {
19107c478bd9Sstevel@tonic-gate lastslash = nam_p;
19117c478bd9Sstevel@tonic-gate }
19127c478bd9Sstevel@tonic-gate
19137c478bd9Sstevel@tonic-gate if (!(strcmp(lastslash, ".")) ||
19147c478bd9Sstevel@tonic-gate !(strcmp(lastslash, ".."))) {
19157c478bd9Sstevel@tonic-gate return (1);
19167c478bd9Sstevel@tonic-gate }
19177c478bd9Sstevel@tonic-gate }
19187c478bd9Sstevel@tonic-gate
19197c478bd9Sstevel@tonic-gate if (result == 0) {
19207c478bd9Sstevel@tonic-gate /* A file by the same name exists. */
19217c478bd9Sstevel@tonic-gate
19227c478bd9Sstevel@tonic-gate /* Take care of ACLs */
1923fa9e4066Sahrens acl_is_set = 0;
19247c478bd9Sstevel@tonic-gate
19257c478bd9Sstevel@tonic-gate if (Pflag && aclp != NULL) {
1926fa9e4066Sahrens if (acl_set(nam_p, aclp) < 0) {
19277c478bd9Sstevel@tonic-gate msg(ERRN,
19287c478bd9Sstevel@tonic-gate "\"%s\": failed to set acl",
19297c478bd9Sstevel@tonic-gate nam_p);
19307c478bd9Sstevel@tonic-gate } else {
1931fa9e4066Sahrens acl_is_set = 1;
19327c478bd9Sstevel@tonic-gate }
19337c478bd9Sstevel@tonic-gate
1934fa9e4066Sahrens acl_free(aclp);
19357c478bd9Sstevel@tonic-gate aclp = NULL;
19367c478bd9Sstevel@tonic-gate }
19377c478bd9Sstevel@tonic-gate if (Args & OCd) {
19387c478bd9Sstevel@tonic-gate /*
19397c478bd9Sstevel@tonic-gate * We are creating directories. Keep the
19407c478bd9Sstevel@tonic-gate * existing file.
19417c478bd9Sstevel@tonic-gate */
19427c478bd9Sstevel@tonic-gate
19437c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, dirfd);
19447c478bd9Sstevel@tonic-gate }
19457c478bd9Sstevel@tonic-gate
19467c478bd9Sstevel@tonic-gate /* Report success. */
19477c478bd9Sstevel@tonic-gate
19487c478bd9Sstevel@tonic-gate return (1);
19497c478bd9Sstevel@tonic-gate }
19507c478bd9Sstevel@tonic-gate } else {
19517c478bd9Sstevel@tonic-gate /* The archive file is not a directory. */
19527c478bd9Sstevel@tonic-gate
19537c478bd9Sstevel@tonic-gate if (result == 0) {
19547c478bd9Sstevel@tonic-gate /*
19557c478bd9Sstevel@tonic-gate * A file by the same name exists. Move it to a
19567c478bd9Sstevel@tonic-gate * temporary file.
19577c478bd9Sstevel@tonic-gate */
19587c478bd9Sstevel@tonic-gate
19597c478bd9Sstevel@tonic-gate if (creat_tmp(nam_p) < 0) {
19607c478bd9Sstevel@tonic-gate /*
19617c478bd9Sstevel@tonic-gate * We weren't able to create the temp file.
19627c478bd9Sstevel@tonic-gate * Report failure.
19637c478bd9Sstevel@tonic-gate */
19647c478bd9Sstevel@tonic-gate
19657c478bd9Sstevel@tonic-gate return (0);
19667c478bd9Sstevel@tonic-gate }
19677c478bd9Sstevel@tonic-gate }
19687c478bd9Sstevel@tonic-gate }
19697c478bd9Sstevel@tonic-gate
19707c478bd9Sstevel@tonic-gate /*
19717c478bd9Sstevel@tonic-gate * This pile tries to create the file directly, and, if there is a
19727c478bd9Sstevel@tonic-gate * problem, creates missing directories, and then tries to create the
19737c478bd9Sstevel@tonic-gate * file again. Two strikes and you're out.
19747c478bd9Sstevel@tonic-gate */
19757c478bd9Sstevel@tonic-gate
19767c478bd9Sstevel@tonic-gate cnt = 0;
19777c478bd9Sstevel@tonic-gate
19787c478bd9Sstevel@tonic-gate do {
19797c478bd9Sstevel@tonic-gate if (ustar_dir() || Adir) {
19807c478bd9Sstevel@tonic-gate /* The archive file is a directory. */
19817c478bd9Sstevel@tonic-gate
19827c478bd9Sstevel@tonic-gate result = mkdir(nam_p, G_p->g_mode);
19837c478bd9Sstevel@tonic-gate } else if (ustar_spec() || Aspec) {
19847c478bd9Sstevel@tonic-gate /*
19857c478bd9Sstevel@tonic-gate * The archive file is block special,
1986cdd68f5aSceastha * char special, socket, or a fifo.
1987cdd68f5aSceastha * Note that, for a socket, the third
1988cdd68f5aSceastha * parameter to mknod() is ignored.
19897c478bd9Sstevel@tonic-gate */
19907c478bd9Sstevel@tonic-gate result = mknod(nam_p, (int)G_p->g_mode,
19917c478bd9Sstevel@tonic-gate (int)G_p->g_rdev);
19927c478bd9Sstevel@tonic-gate }
19937c478bd9Sstevel@tonic-gate
19947c478bd9Sstevel@tonic-gate if (result >= 0) {
19957c478bd9Sstevel@tonic-gate /*
19967c478bd9Sstevel@tonic-gate * The file creation succeeded. Take care of the ACLs.
19977c478bd9Sstevel@tonic-gate */
19987c478bd9Sstevel@tonic-gate
1999fa9e4066Sahrens acl_is_set = 0;
20007c478bd9Sstevel@tonic-gate
20017c478bd9Sstevel@tonic-gate if (Pflag && aclp != NULL) {
2002fa9e4066Sahrens if (acl_set(nam_p, aclp) < 0) {
20037c478bd9Sstevel@tonic-gate msg(ERRN,
20047c478bd9Sstevel@tonic-gate "\"%s\": failed to set acl", nam_p);
20057c478bd9Sstevel@tonic-gate } else {
2006fa9e4066Sahrens acl_is_set = 1;
20077c478bd9Sstevel@tonic-gate }
20087c478bd9Sstevel@tonic-gate
2009fa9e4066Sahrens acl_free(aclp);
20107c478bd9Sstevel@tonic-gate aclp = NULL;
20117c478bd9Sstevel@tonic-gate }
20127c478bd9Sstevel@tonic-gate
20137c478bd9Sstevel@tonic-gate cnt = 0;
20147c478bd9Sstevel@tonic-gate break;
20157c478bd9Sstevel@tonic-gate }
20167c478bd9Sstevel@tonic-gate
20177c478bd9Sstevel@tonic-gate cnt++;
20187c478bd9Sstevel@tonic-gate } while (cnt < 2 && missdir(nam_p) == 0);
20197c478bd9Sstevel@tonic-gate
20207c478bd9Sstevel@tonic-gate switch (cnt) {
20217c478bd9Sstevel@tonic-gate case 0:
20227c478bd9Sstevel@tonic-gate rv = 1;
20237c478bd9Sstevel@tonic-gate rstfiles(U_OVER, dirfd);
20247c478bd9Sstevel@tonic-gate break;
20257c478bd9Sstevel@tonic-gate
20267c478bd9Sstevel@tonic-gate case 1:
20277c478bd9Sstevel@tonic-gate msg(ERRN,
20287c478bd9Sstevel@tonic-gate "Cannot create directory for \"%s\"", nam_p);
20297c478bd9Sstevel@tonic-gate
20307c478bd9Sstevel@tonic-gate if (*Over_p == '\0') {
20317c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, dirfd);
20327c478bd9Sstevel@tonic-gate }
20337c478bd9Sstevel@tonic-gate
20347c478bd9Sstevel@tonic-gate break;
20357c478bd9Sstevel@tonic-gate
20367c478bd9Sstevel@tonic-gate case 2:
20377c478bd9Sstevel@tonic-gate if (ustar_dir() || Adir) {
20387c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot create directory \"%s\"", nam_p);
20397c478bd9Sstevel@tonic-gate } else if (ustar_spec() || Aspec) {
20407c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot mknod() \"%s\"", nam_p);
20417c478bd9Sstevel@tonic-gate }
20427c478bd9Sstevel@tonic-gate
20437c478bd9Sstevel@tonic-gate if (*Over_p == '\0') {
20447c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, dirfd);
20457c478bd9Sstevel@tonic-gate }
20467c478bd9Sstevel@tonic-gate
20477c478bd9Sstevel@tonic-gate break;
20487c478bd9Sstevel@tonic-gate
20497c478bd9Sstevel@tonic-gate default:
20507c478bd9Sstevel@tonic-gate msg(EXT, "Impossible case.");
20517c478bd9Sstevel@tonic-gate }
20527c478bd9Sstevel@tonic-gate
20537c478bd9Sstevel@tonic-gate return (rv);
20547c478bd9Sstevel@tonic-gate }
20557c478bd9Sstevel@tonic-gate
20567c478bd9Sstevel@tonic-gate /*
20577c478bd9Sstevel@tonic-gate * creat_tmp:
20587c478bd9Sstevel@tonic-gate */
20597c478bd9Sstevel@tonic-gate
20607c478bd9Sstevel@tonic-gate static int
creat_tmp(char * nam_p)20617c478bd9Sstevel@tonic-gate creat_tmp(char *nam_p)
20627c478bd9Sstevel@tonic-gate {
20637c478bd9Sstevel@tonic-gate char *t_p;
20640b9a5158SToomas Soome int cwd = -1;
20657c478bd9Sstevel@tonic-gate
20667c478bd9Sstevel@tonic-gate if ((Args & OCp) && G_p->g_ino == DesSt.st_ino &&
20677c478bd9Sstevel@tonic-gate G_p->g_dev == DesSt.st_dev) {
20687c478bd9Sstevel@tonic-gate msg(ERR, "Attempt to pass a file to itself.");
20697c478bd9Sstevel@tonic-gate return (-1);
20707c478bd9Sstevel@tonic-gate }
20717c478bd9Sstevel@tonic-gate
20727c478bd9Sstevel@tonic-gate if (G_p->g_mtime <= DesSt.st_mtime && !(Args & OCu)) {
20737c478bd9Sstevel@tonic-gate msg(ERR, "Existing \"%s\" same age or newer", nam_p);
20747c478bd9Sstevel@tonic-gate return (-1);
20757c478bd9Sstevel@tonic-gate }
20767c478bd9Sstevel@tonic-gate
20777c478bd9Sstevel@tonic-gate /* Make the temporary file name. */
20787c478bd9Sstevel@tonic-gate
20797c478bd9Sstevel@tonic-gate (void) strcpy(Over_p, nam_p);
20807c478bd9Sstevel@tonic-gate t_p = Over_p + strlen(Over_p);
20817c478bd9Sstevel@tonic-gate
20827c478bd9Sstevel@tonic-gate while (t_p != Over_p) {
20837c478bd9Sstevel@tonic-gate if (*(t_p - 1) == '/')
20847c478bd9Sstevel@tonic-gate break;
20857c478bd9Sstevel@tonic-gate t_p--;
20867c478bd9Sstevel@tonic-gate }
20877c478bd9Sstevel@tonic-gate
20887c478bd9Sstevel@tonic-gate (void) strcpy(t_p, "XXXXXX");
20897c478bd9Sstevel@tonic-gate
2090ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
20917c478bd9Sstevel@tonic-gate /*
20927c478bd9Sstevel@tonic-gate * Save our current directory, so we can go into
20937c478bd9Sstevel@tonic-gate * the attribute directory to make the temp file
20947c478bd9Sstevel@tonic-gate * and then return.
20957c478bd9Sstevel@tonic-gate */
20967c478bd9Sstevel@tonic-gate
20977c478bd9Sstevel@tonic-gate cwd = save_cwd();
20987c478bd9Sstevel@tonic-gate (void) fchdir(G_p->g_dirfd);
20997c478bd9Sstevel@tonic-gate }
21007c478bd9Sstevel@tonic-gate
21017c478bd9Sstevel@tonic-gate (void) mktemp(Over_p);
21027c478bd9Sstevel@tonic-gate
2103ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
21047c478bd9Sstevel@tonic-gate /* Return to the current directory. */
21057c478bd9Sstevel@tonic-gate
21067c478bd9Sstevel@tonic-gate rest_cwd(cwd);
21077c478bd9Sstevel@tonic-gate }
21087c478bd9Sstevel@tonic-gate
21097c478bd9Sstevel@tonic-gate if (*Over_p == '\0') {
21107c478bd9Sstevel@tonic-gate /* mktemp reports a failure. */
21117c478bd9Sstevel@tonic-gate
21127c478bd9Sstevel@tonic-gate msg(ERR, "Cannot get temporary file name.");
21137c478bd9Sstevel@tonic-gate return (-1);
21147c478bd9Sstevel@tonic-gate }
21157c478bd9Sstevel@tonic-gate
21167c478bd9Sstevel@tonic-gate /*
21177c478bd9Sstevel@tonic-gate * If it's a regular file, write to the temporary file, and then rename
2118da6c28aaSamw * in order to accommodate potential executables.
21197c478bd9Sstevel@tonic-gate *
21207c478bd9Sstevel@tonic-gate * Note: g_typeflag is only defined (set) for USTAR archive types. It
21217c478bd9Sstevel@tonic-gate * defaults to 0 in the cpio-format-regular file case, so this test
21227c478bd9Sstevel@tonic-gate * succeeds.
21237c478bd9Sstevel@tonic-gate */
21247c478bd9Sstevel@tonic-gate
21257c478bd9Sstevel@tonic-gate if (G_p->g_typeflag == 0 &&
2126*6d3b960aSAndy Fiddaman (DesSt.st_mode & (uint_t)Ftype) == S_IFREG &&
2127*6d3b960aSAndy Fiddaman (G_p->g_mode & (uint_t)Ftype) == S_IFREG) {
21287c478bd9Sstevel@tonic-gate /*
21297c478bd9Sstevel@tonic-gate * The archive file and the filesystem file are both regular
21307c478bd9Sstevel@tonic-gate * files. We write to the temporary file in this case.
21317c478bd9Sstevel@tonic-gate */
21327c478bd9Sstevel@tonic-gate
21337c478bd9Sstevel@tonic-gate if (Args & OCp) {
2134ced83f9bSceastha if (G_p->g_attrnam_p == NULL) {
21357c478bd9Sstevel@tonic-gate Fullnam_p = Over_p;
21367c478bd9Sstevel@tonic-gate } else {
21377c478bd9Sstevel@tonic-gate Attrfile_p = Over_p;
21387c478bd9Sstevel@tonic-gate }
21397c478bd9Sstevel@tonic-gate } else {
21407c478bd9Sstevel@tonic-gate G_p->g_nam_p = Over_p;
2141ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
21427c478bd9Sstevel@tonic-gate Attrfile_p = Over_p;
21437c478bd9Sstevel@tonic-gate }
21447c478bd9Sstevel@tonic-gate }
21457c478bd9Sstevel@tonic-gate
2146ced83f9bSceastha if (G_p->g_attrnam_p == NULL) {
21477c478bd9Sstevel@tonic-gate Over_p = nam_p;
21487c478bd9Sstevel@tonic-gate } else {
21497c478bd9Sstevel@tonic-gate Over_p = G_p->g_attrnam_p;
21507c478bd9Sstevel@tonic-gate }
21517c478bd9Sstevel@tonic-gate
21527c478bd9Sstevel@tonic-gate Do_rename = 1;
21537c478bd9Sstevel@tonic-gate } else {
21547c478bd9Sstevel@tonic-gate /*
21557c478bd9Sstevel@tonic-gate * Either the archive file or the filesystem file is not a
21567c478bd9Sstevel@tonic-gate * regular file.
21577c478bd9Sstevel@tonic-gate */
21587c478bd9Sstevel@tonic-gate
21597c478bd9Sstevel@tonic-gate Do_rename = 0;
21607c478bd9Sstevel@tonic-gate
21617c478bd9Sstevel@tonic-gate if (S_ISDIR(DesSt.st_mode)) {
21627c478bd9Sstevel@tonic-gate /*
21637c478bd9Sstevel@tonic-gate * The filesystem file is a directory.
21647c478bd9Sstevel@tonic-gate *
21657c478bd9Sstevel@tonic-gate * Save the current working directory because we will
21667c478bd9Sstevel@tonic-gate * want to restore it back just in case remove_dir()
21677c478bd9Sstevel@tonic-gate * fails or get confused about where we should be.
21687c478bd9Sstevel@tonic-gate */
21697c478bd9Sstevel@tonic-gate
21707c478bd9Sstevel@tonic-gate *Over_p = '\0';
21717c478bd9Sstevel@tonic-gate cwd = save_cwd();
21727c478bd9Sstevel@tonic-gate
21737c478bd9Sstevel@tonic-gate if (remove_dir(nam_p) < 0) {
21747c478bd9Sstevel@tonic-gate msg(ERRN,
21757c478bd9Sstevel@tonic-gate "Cannot remove the directory \"%s\"",
21767c478bd9Sstevel@tonic-gate nam_p);
21777c478bd9Sstevel@tonic-gate /*
21787c478bd9Sstevel@tonic-gate * Restore working directory back to the one
21797c478bd9Sstevel@tonic-gate * saved earlier.
21807c478bd9Sstevel@tonic-gate */
21817c478bd9Sstevel@tonic-gate
21827c478bd9Sstevel@tonic-gate rest_cwd(cwd);
21837c478bd9Sstevel@tonic-gate return (-1);
21847c478bd9Sstevel@tonic-gate }
21857c478bd9Sstevel@tonic-gate
21867c478bd9Sstevel@tonic-gate /*
21877c478bd9Sstevel@tonic-gate * Restore working directory back to the one
21887c478bd9Sstevel@tonic-gate * saved earlier
21897c478bd9Sstevel@tonic-gate */
21907c478bd9Sstevel@tonic-gate
21917c478bd9Sstevel@tonic-gate rest_cwd(cwd);
21927c478bd9Sstevel@tonic-gate } else {
21937c478bd9Sstevel@tonic-gate /*
21947c478bd9Sstevel@tonic-gate * The file is not a directory. Will use the original
21957c478bd9Sstevel@tonic-gate * link/unlink construct, however, if the file is
21967c478bd9Sstevel@tonic-gate * namefs, link would fail with EXDEV. Therefore, we
21977c478bd9Sstevel@tonic-gate * use rename() first to back up the file.
21987c478bd9Sstevel@tonic-gate */
21997c478bd9Sstevel@tonic-gate if (rename(nam_p, Over_p) < 0) {
22007c478bd9Sstevel@tonic-gate /*
22017c478bd9Sstevel@tonic-gate * If rename failed, try old construction
22027c478bd9Sstevel@tonic-gate * method.
22037c478bd9Sstevel@tonic-gate */
22047c478bd9Sstevel@tonic-gate if (link(nam_p, Over_p) < 0) {
22057c478bd9Sstevel@tonic-gate msg(ERRN,
2206ced83f9bSceastha "Cannot rename temporary file "
2207ced83f9bSceastha "\"%s\" to \"%s\"", Over_p, nam_p);
22087c478bd9Sstevel@tonic-gate *Over_p = '\0';
22097c478bd9Sstevel@tonic-gate return (-1);
22107c478bd9Sstevel@tonic-gate }
22117c478bd9Sstevel@tonic-gate
22127c478bd9Sstevel@tonic-gate if (unlink(nam_p) < 0) {
22137c478bd9Sstevel@tonic-gate msg(ERRN,
22147c478bd9Sstevel@tonic-gate "Cannot unlink() current \"%s\"",
22157c478bd9Sstevel@tonic-gate nam_p);
22167c478bd9Sstevel@tonic-gate (void) unlink(Over_p);
22177c478bd9Sstevel@tonic-gate *Over_p = '\0';
22187c478bd9Sstevel@tonic-gate return (-1);
22197c478bd9Sstevel@tonic-gate }
22207c478bd9Sstevel@tonic-gate }
22217c478bd9Sstevel@tonic-gate }
22227c478bd9Sstevel@tonic-gate }
22237c478bd9Sstevel@tonic-gate
22247c478bd9Sstevel@tonic-gate return (1);
22257c478bd9Sstevel@tonic-gate }
22267c478bd9Sstevel@tonic-gate
22277c478bd9Sstevel@tonic-gate /*
2228ced83f9bSceastha * Copy the datasize amount of data from the input file to buffer.
2229ced83f9bSceastha *
2230ced83f9bSceastha * ifd - Input file descriptor.
2231ced83f9bSceastha * buffer - Buffer (allocated by caller) to copy data to.
2232ced83f9bSceastha * datasize - The amount of data to read from the input file
2233ced83f9bSceastha * and copy to the buffer.
2234ced83f9bSceastha * error - When reading from an Archive file, indicates unreadable
2235ced83f9bSceastha * data was encountered, otherwise indicates errno.
2236ced83f9bSceastha * data_in_info - Information needed when called from data_in().
2237ced83f9bSceastha */
2238ced83f9bSceastha static ssize_t
read_chunk(int ifd,char * buffer,size_t datasize,data_in_t * data_in_info)2239ced83f9bSceastha read_chunk(int ifd, char *buffer, size_t datasize, data_in_t *data_in_info)
2240ced83f9bSceastha {
2241ced83f9bSceastha if (Args & OCp) {
2242ced83f9bSceastha return (read(ifd, buffer, datasize));
2243ced83f9bSceastha } else {
2244ced83f9bSceastha FILL(datasize);
2245ced83f9bSceastha if (data_in_info->data_in_proc_mode != P_SKIP) {
2246ced83f9bSceastha if (Hdr_type == CRC)
2247ced83f9bSceastha data_in_info->data_in_cksumval += cksum(CRC,
2248ced83f9bSceastha datasize, NULL);
2249ced83f9bSceastha if (data_in_info->data_in_swapfile)
2250ced83f9bSceastha swap(Buffr.b_out_p, datasize);
2251ced83f9bSceastha
2252ced83f9bSceastha
2253ced83f9bSceastha /*
2254ced83f9bSceastha * if the bar archive is compressed, set up a pipe and
2255ced83f9bSceastha * do the de-compression while reading in the file
2256ced83f9bSceastha */
2257ced83f9bSceastha if (Hdr_type == BAR) {
2258ced83f9bSceastha if (data_in_info->data_in_compress_flag == 0 &&
2259ced83f9bSceastha Compressed) {
2260ced83f9bSceastha setup_uncompress(
2261ced83f9bSceastha &(data_in_info->data_in_pipef));
2262ced83f9bSceastha data_in_info->data_in_compress_flag++;
2263ced83f9bSceastha }
2264ced83f9bSceastha }
2265ced83f9bSceastha }
2266ced83f9bSceastha (void) memcpy(buffer, Buffr.b_out_p, datasize);
2267ced83f9bSceastha Buffr.b_out_p += datasize;
2268ced83f9bSceastha Buffr.b_cnt -= datasize;
2269ced83f9bSceastha return (datasize);
2270ced83f9bSceastha }
2271ced83f9bSceastha }
2272ced83f9bSceastha
22735fbb8099SNobutomo Nakano /*
22745fbb8099SNobutomo Nakano * Read as much data as we can.
22755fbb8099SNobutomo Nakano *
22765fbb8099SNobutomo Nakano * ifd - input file descriptor.
22775fbb8099SNobutomo Nakano * buf - Buffer (allocated by caller) to copy data to.
22785fbb8099SNobutomo Nakano * bytes - The amount of data to read from the input file
22795fbb8099SNobutomo Nakano * and copy to the buffer.
22805fbb8099SNobutomo Nakano * rdblocksz - The size of the chunk of data to read.
22815fbb8099SNobutomo Nakano *
22824e621e6cSNobutomo Nakano * Return number of bytes failed to read.
22834e621e6cSNobutomo Nakano * Return -1 when buffer is empty and read failed.
22845fbb8099SNobutomo Nakano */
22855fbb8099SNobutomo Nakano static int
read_bytes(int ifd,char * buf,size_t bytes,size_t rdblocksz,data_in_t * data_in_info)22865fbb8099SNobutomo Nakano read_bytes(int ifd, char *buf, size_t bytes, size_t rdblocksz,
22875fbb8099SNobutomo Nakano data_in_t *data_in_info)
22885fbb8099SNobutomo Nakano {
22895fbb8099SNobutomo Nakano size_t bytesread;
22905fbb8099SNobutomo Nakano ssize_t got;
22915fbb8099SNobutomo Nakano
22925fbb8099SNobutomo Nakano for (bytesread = 0; bytesread < bytes; bytesread += got) {
22935fbb8099SNobutomo Nakano /*
22945fbb8099SNobutomo Nakano * Read the data from either the input file descriptor
22955fbb8099SNobutomo Nakano * or the archive file. read_chunk() will only return
22965fbb8099SNobutomo Nakano * <= 0 if data_copy() was called from data_pass().
22975fbb8099SNobutomo Nakano */
22985fbb8099SNobutomo Nakano if ((got = read_chunk(ifd, buf + bytesread,
22995fbb8099SNobutomo Nakano min(bytes - bytesread, rdblocksz),
23005fbb8099SNobutomo Nakano data_in_info)) <= 0) {
23015fbb8099SNobutomo Nakano /*
23024e621e6cSNobutomo Nakano * We come here only in the pass mode.
23035fbb8099SNobutomo Nakano * If data couldn't be read from the input file
23044e621e6cSNobutomo Nakano * descriptor, return number of bytes in the buf.
23054e621e6cSNobutomo Nakano * If buffer is empty, return -1.
23065fbb8099SNobutomo Nakano */
23074e621e6cSNobutomo Nakano if (bytesread == 0) {
23084e621e6cSNobutomo Nakano if (got == 0) /* EOF */
23094e621e6cSNobutomo Nakano data_in_info->data_in_rd_eof = 1;
23105fbb8099SNobutomo Nakano return (-1);
23115fbb8099SNobutomo Nakano }
23124e621e6cSNobutomo Nakano return (bytes - bytesread);
23134e621e6cSNobutomo Nakano }
23145fbb8099SNobutomo Nakano }
23155fbb8099SNobutomo Nakano return (0);
23165fbb8099SNobutomo Nakano }
2317ced83f9bSceastha
2318ced83f9bSceastha /*
23195fbb8099SNobutomo Nakano * Write as much data as we can.
23205fbb8099SNobutomo Nakano *
23215fbb8099SNobutomo Nakano * ofd - output file descriptor.
23225fbb8099SNobutomo Nakano * buf - Source buffer to output data from.
23235fbb8099SNobutomo Nakano * maxwrite - The amount of data to write to the output.
23245fbb8099SNobutomo Nakano *
23255fbb8099SNobutomo Nakano * return 0 upon success.
23265fbb8099SNobutomo Nakano */
23275fbb8099SNobutomo Nakano static int
write_bytes(int ofd,char * buf,size_t maxwrite,data_in_t * data_in_info)23285fbb8099SNobutomo Nakano write_bytes(int ofd, char *buf, size_t maxwrite, data_in_t *data_in_info)
23295fbb8099SNobutomo Nakano {
23305fbb8099SNobutomo Nakano ssize_t cnt;
23315fbb8099SNobutomo Nakano
23324e621e6cSNobutomo Nakano errno = 0;
23335fbb8099SNobutomo Nakano if ((cnt = write(ofd, buf, maxwrite)) < (ssize_t)maxwrite) {
23345fbb8099SNobutomo Nakano data_in_info->data_in_errno = errno;
23355fbb8099SNobutomo Nakano /*
23365fbb8099SNobutomo Nakano * data_in() needs to know if it was an actual write(2)
23375fbb8099SNobutomo Nakano * failure, or if we just couldn't write all of the data
23385fbb8099SNobutomo Nakano * requested so that we know that the rest of the file's
23395fbb8099SNobutomo Nakano * data can be read but not written.
23405fbb8099SNobutomo Nakano */
23414e621e6cSNobutomo Nakano if (cnt != -1)
23424e621e6cSNobutomo Nakano data_in_info->data_in_wr_part = 1;
23435fbb8099SNobutomo Nakano return (1);
23445fbb8099SNobutomo Nakano } else if (Args & OCp) {
2345*6d3b960aSAndy Fiddaman Blocks += (ulong_t)((cnt + (Bufsize - 1)) / Bufsize);
23465fbb8099SNobutomo Nakano }
23475fbb8099SNobutomo Nakano return (0);
23485fbb8099SNobutomo Nakano }
23495fbb8099SNobutomo Nakano
23505fbb8099SNobutomo Nakano /*
23515fbb8099SNobutomo Nakano * Perform I/O for given byte size with using limited i/o block size
23525fbb8099SNobutomo Nakano * and supplied buffer.
23535fbb8099SNobutomo Nakano *
23545fbb8099SNobutomo Nakano * ifd/ofd - i/o file descriptor
23555fbb8099SNobutomo Nakano * buf - buffer to be used for i/o
23565fbb8099SNobutomo Nakano * bytes - Amount to read/write
23575fbb8099SNobutomo Nakano * wrblocksz - Output block size.
23585fbb8099SNobutomo Nakano * rdblocksz - Read block size.
23595fbb8099SNobutomo Nakano *
23605fbb8099SNobutomo Nakano * Return 0 upon success. Return negative if read failed.
23615fbb8099SNobutomo Nakano * Return positive non-zero if write failed.
23625fbb8099SNobutomo Nakano */
23635fbb8099SNobutomo Nakano static int
rdwr_bytes(int ifd,int ofd,char * buf,off_t bytes,size_t wrblocksz,size_t rdblocksz,data_in_t * data_in_info)23645fbb8099SNobutomo Nakano rdwr_bytes(int ifd, int ofd, char *buf, off_t bytes,
23655fbb8099SNobutomo Nakano size_t wrblocksz, size_t rdblocksz, data_in_t *data_in_info)
23665fbb8099SNobutomo Nakano {
23674e621e6cSNobutomo Nakano int rv, sz;
23685fbb8099SNobutomo Nakano int error = 0;
23694e621e6cSNobutomo Nakano int write_it = (data_in_info->data_in_proc_mode != P_SKIP);
23705fbb8099SNobutomo Nakano
23715fbb8099SNobutomo Nakano while (bytes > 0) {
23725fbb8099SNobutomo Nakano /*
23735fbb8099SNobutomo Nakano * If the number of bytes left to write is smaller than
23745fbb8099SNobutomo Nakano * the preferred I/O size, then we're about to do our final
23755fbb8099SNobutomo Nakano * write to the file, so just set wrblocksz to the number of
23765fbb8099SNobutomo Nakano * bytes left to write.
23775fbb8099SNobutomo Nakano */
23785fbb8099SNobutomo Nakano if (bytes < wrblocksz)
23795fbb8099SNobutomo Nakano wrblocksz = bytes;
23805fbb8099SNobutomo Nakano
23815fbb8099SNobutomo Nakano /* Read input till satisfy output block size */
23824e621e6cSNobutomo Nakano sz = read_bytes(ifd, buf, wrblocksz, rdblocksz, data_in_info);
23834e621e6cSNobutomo Nakano if (sz < 0)
23844e621e6cSNobutomo Nakano return (sz);
23855fbb8099SNobutomo Nakano
23865fbb8099SNobutomo Nakano if (write_it) {
23874e621e6cSNobutomo Nakano rv = write_bytes(ofd, buf,
23884e621e6cSNobutomo Nakano wrblocksz - sz, data_in_info);
23895fbb8099SNobutomo Nakano if (rv != 0) {
23905fbb8099SNobutomo Nakano /*
23915fbb8099SNobutomo Nakano * If we wrote partial, we return and quits.
23925fbb8099SNobutomo Nakano * Otherwise, read through the rest of input
23935fbb8099SNobutomo Nakano * to go to the next file.
23945fbb8099SNobutomo Nakano */
23955fbb8099SNobutomo Nakano if ((Args & OCp) ||
23964e621e6cSNobutomo Nakano data_in_info->data_in_wr_part) {
23975fbb8099SNobutomo Nakano return (rv);
23985fbb8099SNobutomo Nakano } else {
23995fbb8099SNobutomo Nakano write_it = 0;
24005fbb8099SNobutomo Nakano }
24015fbb8099SNobutomo Nakano error = 1;
24025fbb8099SNobutomo Nakano }
24035fbb8099SNobutomo Nakano }
24044e621e6cSNobutomo Nakano bytes -= (wrblocksz - sz);
24055fbb8099SNobutomo Nakano }
24065fbb8099SNobutomo Nakano return (error);
24075fbb8099SNobutomo Nakano }
24085fbb8099SNobutomo Nakano
24095fbb8099SNobutomo Nakano /*
24105fbb8099SNobutomo Nakano * Write zeros for give size.
24115fbb8099SNobutomo Nakano *
24125fbb8099SNobutomo Nakano * ofd - output file descriptor
24135fbb8099SNobutomo Nakano * buf - buffer to fill with zeros
24145fbb8099SNobutomo Nakano * bytes - Amount to write
24155fbb8099SNobutomo Nakano * wrblocksz - Write block size
24165fbb8099SNobutomo Nakano *
24175fbb8099SNobutomo Nakano * return 0 upon success.
24185fbb8099SNobutomo Nakano */
24195fbb8099SNobutomo Nakano static int
write_zeros(int ofd,char * buf,off_t bytes,size_t wrblocksz,data_in_t * data_in_info)24205fbb8099SNobutomo Nakano write_zeros(int ofd, char *buf, off_t bytes, size_t wrblocksz,
24215fbb8099SNobutomo Nakano data_in_t *data_in_info)
24225fbb8099SNobutomo Nakano {
24235fbb8099SNobutomo Nakano int rv;
24245fbb8099SNobutomo Nakano
24255fbb8099SNobutomo Nakano (void) memset(buf, 0, min(bytes, wrblocksz));
24265fbb8099SNobutomo Nakano while (bytes > 0) {
24275fbb8099SNobutomo Nakano if (bytes < wrblocksz)
24285fbb8099SNobutomo Nakano wrblocksz = bytes;
24295fbb8099SNobutomo Nakano rv = write_bytes(ofd, buf, wrblocksz, data_in_info);
24305fbb8099SNobutomo Nakano if (rv != 0)
24315fbb8099SNobutomo Nakano return (rv);
24325fbb8099SNobutomo Nakano bytes -= wrblocksz;
24335fbb8099SNobutomo Nakano }
24345fbb8099SNobutomo Nakano return (0);
24355fbb8099SNobutomo Nakano }
24365fbb8099SNobutomo Nakano
24375fbb8099SNobutomo Nakano /*
24385fbb8099SNobutomo Nakano * To figure out the size of the buffer used to accumulate data from
24395fbb8099SNobutomo Nakano * readtape() and to write to the file, we need to determine the largest
24405fbb8099SNobutomo Nakano * chunk of data to be written to the file at one time. This is determined
24415fbb8099SNobutomo Nakano * based on the following three things:
24425fbb8099SNobutomo Nakano * 1) The size of the archived file.
24435fbb8099SNobutomo Nakano * 2) The preferred I/O size of the file.
24445fbb8099SNobutomo Nakano * 3) If the file is a read-write system attribute file.
24455fbb8099SNobutomo Nakano * If the size of the file is less than the preferred I/O size or it's a
24465fbb8099SNobutomo Nakano * read-write system attribute file, which must be written in one operation,
24475fbb8099SNobutomo Nakano * then set the maximum write size to the size of the archived file.
24485fbb8099SNobutomo Nakano * Otherwise, the maximum write size is preferred I/O size.
24495fbb8099SNobutomo Nakano */
24505fbb8099SNobutomo Nakano static int
calc_maxwrite(int ofd,int rw_sysattr,off_t bytes,size_t blocksize)24515fbb8099SNobutomo Nakano calc_maxwrite(int ofd, int rw_sysattr, off_t bytes, size_t blocksize)
24525fbb8099SNobutomo Nakano {
24535fbb8099SNobutomo Nakano struct stat tsbuf;
24545fbb8099SNobutomo Nakano size_t maxwrite;
24555fbb8099SNobutomo Nakano size_t piosize; /* preferred I/O size */
24565fbb8099SNobutomo Nakano
24575fbb8099SNobutomo Nakano if (rw_sysattr || bytes < blocksize) {
24585fbb8099SNobutomo Nakano maxwrite = bytes;
24595fbb8099SNobutomo Nakano } else {
24605fbb8099SNobutomo Nakano if (fstat(ofd, &tsbuf) == 0) {
24615fbb8099SNobutomo Nakano piosize = tsbuf.st_blksize;
24625fbb8099SNobutomo Nakano } else {
24635fbb8099SNobutomo Nakano piosize = blocksize;
24645fbb8099SNobutomo Nakano }
24655fbb8099SNobutomo Nakano maxwrite = min(bytes, piosize);
24665fbb8099SNobutomo Nakano }
24675fbb8099SNobutomo Nakano return (maxwrite);
24685fbb8099SNobutomo Nakano }
24695fbb8099SNobutomo Nakano /*
24705fbb8099SNobutomo Nakano * data_copy() and data_copy_with_holes() copy data from the input
24715fbb8099SNobutomo Nakano * file to output file descriptor. If ifd is -1, then the input file is
24725fbb8099SNobutomo Nakano * the archive file.
2473ced83f9bSceastha *
2474ced83f9bSceastha * Parameters
2475ced83f9bSceastha * ifd - Input file descriptor to read from.
2476ced83f9bSceastha * ofd - Output file descriptor of extracted file.
2477ced83f9bSceastha * rw_sysattr - Flag indicating if a file is an extended
2478ced83f9bSceastha * system attribute file.
24795fbb8099SNobutomo Nakano * bytes - Amount of data (file size) of copy/write.
2480ced83f9bSceastha * blocksize - Amount of data to read at a time from either
2481ced83f9bSceastha * the input file descriptor or from the archive.
2482ced83f9bSceastha * data_in_info - information needed while reading data when
2483ced83f9bSceastha * called by data_in().
24845fbb8099SNobutomo Nakano * holes - Information of holes in the input file.
2485ced83f9bSceastha *
2486ced83f9bSceastha * Return code
2487ced83f9bSceastha * 0 Success
2488ced83f9bSceastha * < 0 An error occurred during the read of the input
2489ced83f9bSceastha * file
2490ced83f9bSceastha * > 0 An error occurred during the write of the output
2491ced83f9bSceastha * file descriptor.
2492ced83f9bSceastha */
2493ced83f9bSceastha static int
data_copy(int ifd,int ofd,int rw_sysattr,off_t bytes,size_t blocksize,data_in_t * data_in_info)24945d7d0335SNobutomo Nakano data_copy(int ifd, int ofd, int rw_sysattr, off_t bytes,
2495ced83f9bSceastha size_t blocksize, data_in_t *data_in_info)
2496ced83f9bSceastha {
2497ced83f9bSceastha char *buf;
2498ced83f9bSceastha size_t maxwrite;
24995fbb8099SNobutomo Nakano int rv;
2500ced83f9bSceastha
2501ced83f9bSceastha /* No data to copy. */
25025fbb8099SNobutomo Nakano if (bytes == 0)
2503ced83f9bSceastha return (0);
2504ced83f9bSceastha
25055fbb8099SNobutomo Nakano maxwrite = calc_maxwrite(ofd, rw_sysattr, bytes, blocksize);
2506ced83f9bSceastha buf = e_zalloc(E_EXIT, maxwrite);
2507ced83f9bSceastha
25085fbb8099SNobutomo Nakano rv = rdwr_bytes(ifd, ofd, buf, bytes, maxwrite,
25095fbb8099SNobutomo Nakano blocksize, data_in_info);
2510ced83f9bSceastha
2511ced83f9bSceastha free(buf);
25125fbb8099SNobutomo Nakano return (rv);
2513ced83f9bSceastha }
25145fbb8099SNobutomo Nakano
25155fbb8099SNobutomo Nakano static int
data_copy_with_holes(int ifd,int ofd,int rw_sysattr,off_t bytes,size_t blocksize,data_in_t * data_in_info,holes_info_t * holes)25165fbb8099SNobutomo Nakano data_copy_with_holes(int ifd, int ofd, int rw_sysattr, off_t bytes,
25175fbb8099SNobutomo Nakano size_t blocksize, data_in_t *data_in_info, holes_info_t *holes)
25185fbb8099SNobutomo Nakano {
25195fbb8099SNobutomo Nakano holes_list_t *hl;
25205fbb8099SNobutomo Nakano off_t curpos, noff, datasize;
25215fbb8099SNobutomo Nakano char *buf;
25225fbb8099SNobutomo Nakano size_t maxwrite;
25235fbb8099SNobutomo Nakano int rv, error;
25245fbb8099SNobutomo Nakano
25255fbb8099SNobutomo Nakano if (bytes == 0)
25265fbb8099SNobutomo Nakano return (0);
25275fbb8099SNobutomo Nakano
25285fbb8099SNobutomo Nakano maxwrite = calc_maxwrite(ofd, rw_sysattr, bytes, blocksize);
25295fbb8099SNobutomo Nakano buf = e_zalloc(E_EXIT, maxwrite);
25305fbb8099SNobutomo Nakano
25315fbb8099SNobutomo Nakano error = 0;
25325fbb8099SNobutomo Nakano curpos = 0;
25335fbb8099SNobutomo Nakano for (hl = holes->holes_list; hl != NULL; hl = hl->hl_next) {
25345fbb8099SNobutomo Nakano if (curpos != hl->hl_data) {
25355fbb8099SNobutomo Nakano /* adjust output position */
25365fbb8099SNobutomo Nakano noff = lseek(ofd, hl->hl_data, SEEK_SET);
25375fbb8099SNobutomo Nakano if (noff != hl->hl_data) {
25385fbb8099SNobutomo Nakano /*
25395fbb8099SNobutomo Nakano * Can't seek to the target, try to adjust
25405fbb8099SNobutomo Nakano * position by filling with zeros.
25415fbb8099SNobutomo Nakano */
25425fbb8099SNobutomo Nakano datasize = hl->hl_data - curpos;
25435fbb8099SNobutomo Nakano rv = write_zeros(ofd, buf, datasize,
25445fbb8099SNobutomo Nakano maxwrite, data_in_info);
25455fbb8099SNobutomo Nakano if (rv != 0)
25465fbb8099SNobutomo Nakano goto errout;
25475fbb8099SNobutomo Nakano }
25485fbb8099SNobutomo Nakano /*
25495fbb8099SNobutomo Nakano * Data is contiguous in the archive, but fragmented
25505fbb8099SNobutomo Nakano * in the regular file, so we also adjust the input
25515fbb8099SNobutomo Nakano * file position in pass mode.
25525fbb8099SNobutomo Nakano */
25535fbb8099SNobutomo Nakano if (Args & OCp) {
25545fbb8099SNobutomo Nakano /* adjust input position */
25555fbb8099SNobutomo Nakano (void) lseek(ifd, hl->hl_data, SEEK_SET);
25565fbb8099SNobutomo Nakano }
25575fbb8099SNobutomo Nakano curpos = hl->hl_data;
25585fbb8099SNobutomo Nakano }
25595fbb8099SNobutomo Nakano datasize = hl->hl_hole - hl->hl_data;
25605fbb8099SNobutomo Nakano if (datasize == 0) {
25615fbb8099SNobutomo Nakano /*
25625fbb8099SNobutomo Nakano * There is a hole at the end of file. To create
25635fbb8099SNobutomo Nakano * such hole, we append one byte, and truncate the
25645fbb8099SNobutomo Nakano * last block. This is necessary because ftruncate(2)
25655fbb8099SNobutomo Nakano * alone allocates one block on the end of file.
25665fbb8099SNobutomo Nakano */
25675fbb8099SNobutomo Nakano rv = write_zeros(ofd, buf, 1, maxwrite, data_in_info);
25685fbb8099SNobutomo Nakano if (rv != 0)
25695fbb8099SNobutomo Nakano goto errout;
25705fbb8099SNobutomo Nakano (void) ftruncate(ofd, hl->hl_data);
25715fbb8099SNobutomo Nakano break;
25725fbb8099SNobutomo Nakano }
25735fbb8099SNobutomo Nakano rv = rdwr_bytes(ifd, ofd, buf, datasize, maxwrite,
25745fbb8099SNobutomo Nakano blocksize, data_in_info);
25755fbb8099SNobutomo Nakano if (rv != 0) {
25765fbb8099SNobutomo Nakano errout:
25775fbb8099SNobutomo Nakano /*
25785fbb8099SNobutomo Nakano * Return if we got a read error or in pass mode,
25795fbb8099SNobutomo Nakano * or failed with partial write. Otherwise, we'll
25804e621e6cSNobutomo Nakano * read through the input stream till next file.
25815fbb8099SNobutomo Nakano */
25825fbb8099SNobutomo Nakano if (rv < 0 || (Args & OCp) ||
25834e621e6cSNobutomo Nakano data_in_info->data_in_wr_part) {
25845fbb8099SNobutomo Nakano free(buf);
25855fbb8099SNobutomo Nakano return (rv);
25865fbb8099SNobutomo Nakano }
25875fbb8099SNobutomo Nakano error = 1;
25885fbb8099SNobutomo Nakano hl = hl->hl_next;
25895fbb8099SNobutomo Nakano break;
25905fbb8099SNobutomo Nakano }
25915fbb8099SNobutomo Nakano curpos += datasize;
2592ced83f9bSceastha }
2593ced83f9bSceastha
2594ced83f9bSceastha /*
25955fbb8099SNobutomo Nakano * We should read through the input data to go to the next
25965fbb8099SNobutomo Nakano * header when non-fatal error occured.
2597ced83f9bSceastha */
25984e621e6cSNobutomo Nakano if (error && !(Args & OCp)) {
25995fbb8099SNobutomo Nakano data_in_info->data_in_proc_mode = P_SKIP;
26005fbb8099SNobutomo Nakano while (hl != NULL) {
26015fbb8099SNobutomo Nakano datasize = hl->hl_hole - hl->hl_data;
26025fbb8099SNobutomo Nakano rv = rdwr_bytes(ifd, ofd, buf, datasize, maxwrite,
26035fbb8099SNobutomo Nakano blocksize, data_in_info);
26045fbb8099SNobutomo Nakano if (rv != 0)
26055fbb8099SNobutomo Nakano break;
26065fbb8099SNobutomo Nakano hl = hl->hl_next;
2607ced83f9bSceastha }
26085fbb8099SNobutomo Nakano }
26095fbb8099SNobutomo Nakano
2610ced83f9bSceastha free(buf);
26115fbb8099SNobutomo Nakano return (error);
26125fbb8099SNobutomo Nakano }
26135fbb8099SNobutomo Nakano
26145fbb8099SNobutomo Nakano /*
26155fbb8099SNobutomo Nakano * Strip off the sparse file information that is prepended to
26165fbb8099SNobutomo Nakano * the compressed sparse file. The information is in the following
26175fbb8099SNobutomo Nakano * format:
26185fbb8099SNobutomo Nakano * <prepended info size><SP><orig file size><SP><holes info>
26195fbb8099SNobutomo Nakano * where prepended info size is long right justified in 10 bytes.
26205fbb8099SNobutomo Nakano * Holesdata consists of the series of offset pairs:
26215fbb8099SNobutomo Nakano * <data offset><SP><hole offset><SP><data offset><SP><hole offset>...
26225fbb8099SNobutomo Nakano * prepended info size and original file size have been read in gethdr().
26235fbb8099SNobutomo Nakano * We read the rest of holes information here in this function.
26245fbb8099SNobutomo Nakano */
26255fbb8099SNobutomo Nakano static int
read_holesdata(holes_info_t * holes,off_t * fileszp,char * nam_p,data_in_t * data_in_info)26265fbb8099SNobutomo Nakano read_holesdata(holes_info_t *holes, off_t *fileszp,
26275fbb8099SNobutomo Nakano char *nam_p, data_in_t *data_in_info)
26285fbb8099SNobutomo Nakano {
26295fbb8099SNobutomo Nakano char *holesdata;
26305fbb8099SNobutomo Nakano size_t holesdata_sz;
26315fbb8099SNobutomo Nakano
26325fbb8099SNobutomo Nakano /* We've already read the header. */
26335fbb8099SNobutomo Nakano holesdata_sz = holes->holesdata_sz - MIN_HOLES_HDRSIZE;
26345fbb8099SNobutomo Nakano
26355fbb8099SNobutomo Nakano if ((holesdata = e_zalloc(E_NORMAL, holesdata_sz)) == NULL) {
26365fbb8099SNobutomo Nakano msg(ERRN, "Could not allocate memory for "
26375fbb8099SNobutomo Nakano "sparse file information", nam_p);
2638ced83f9bSceastha return (1);
2639ced83f9bSceastha }
2640ced83f9bSceastha /*
26415fbb8099SNobutomo Nakano * This function is called only in OCi mode. Therefore,
26425fbb8099SNobutomo Nakano * read_bytes() won't fail, and won't return if error occurs in
26435fbb8099SNobutomo Nakano * input stream. See rstbuf().
2644ced83f9bSceastha */
26455fbb8099SNobutomo Nakano (void) read_bytes(-1, holesdata, holesdata_sz, CPIOBSZ, data_in_info);
26465fbb8099SNobutomo Nakano *fileszp -= holesdata_sz;
2647ced83f9bSceastha
26485fbb8099SNobutomo Nakano /* The string should be terminated. */
26495fbb8099SNobutomo Nakano if (holesdata[holesdata_sz - 1] != '\0') {
26505fbb8099SNobutomo Nakano invalid:
26515fbb8099SNobutomo Nakano free(holesdata);
26525fbb8099SNobutomo Nakano msg(ERR, "invalid sparse file information", nam_p);
26535fbb8099SNobutomo Nakano return (1);
26545fbb8099SNobutomo Nakano }
26555fbb8099SNobutomo Nakano if (parse_holesdata(holes, holesdata) != 0)
26565fbb8099SNobutomo Nakano goto invalid;
26575fbb8099SNobutomo Nakano
26585fbb8099SNobutomo Nakano /* sanity check */
26595fbb8099SNobutomo Nakano if (*fileszp != holes->data_size)
26605fbb8099SNobutomo Nakano goto invalid;
26615fbb8099SNobutomo Nakano
26625fbb8099SNobutomo Nakano free(holesdata);
2663ced83f9bSceastha return (0);
2664ced83f9bSceastha }
26655fbb8099SNobutomo Nakano
2666ced83f9bSceastha /*
26677c478bd9Sstevel@tonic-gate * data_in: If proc_mode == P_PROC, bread() the file's data from the archive
26687c478bd9Sstevel@tonic-gate * and write(2) it to the open fdes gotten from openout(). If proc_mode ==
26697c478bd9Sstevel@tonic-gate * P_SKIP, or becomes P_SKIP (due to errors etc), bread(2) the file's data
26707c478bd9Sstevel@tonic-gate * and ignore it. If the user specified any of the "swap" options (b, s or S),
26717c478bd9Sstevel@tonic-gate * and the length of the file is not appropriate for that action, do not
26727c478bd9Sstevel@tonic-gate * perform the "swap", otherwise perform the action on a buffer by buffer basis.
26737c478bd9Sstevel@tonic-gate * If the CRC header was selected, calculate a running checksum as each buffer
26747c478bd9Sstevel@tonic-gate * is processed.
26757c478bd9Sstevel@tonic-gate */
26767c478bd9Sstevel@tonic-gate static void
data_in(int proc_mode)26777c478bd9Sstevel@tonic-gate data_in(int proc_mode)
26787c478bd9Sstevel@tonic-gate {
26797c478bd9Sstevel@tonic-gate char *nam_p;
26805fbb8099SNobutomo Nakano int pad, rv;
26815fbb8099SNobutomo Nakano int error = 0;
2682ced83f9bSceastha int swapfile = 0;
26837c478bd9Sstevel@tonic-gate int cstatus = 0;
26845fbb8099SNobutomo Nakano off_t filesz;
2685ced83f9bSceastha data_in_t *data_in_info;
26867c478bd9Sstevel@tonic-gate
2687ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
26887c478bd9Sstevel@tonic-gate nam_p = G_p->g_attrnam_p;
26897c478bd9Sstevel@tonic-gate } else {
26907c478bd9Sstevel@tonic-gate nam_p = G_p->g_nam_p;
26917c478bd9Sstevel@tonic-gate }
26927c478bd9Sstevel@tonic-gate
26937c478bd9Sstevel@tonic-gate if (((G_p->g_mode & Ftype) == S_IFLNK && proc_mode != P_SKIP) ||
26947c478bd9Sstevel@tonic-gate (Hdr_type == BAR && bar_linkflag == '2' && proc_mode != P_SKIP)) {
26957c478bd9Sstevel@tonic-gate proc_mode = P_SKIP;
26967c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), nam_p);
26977c478bd9Sstevel@tonic-gate }
2698*6d3b960aSAndy Fiddaman if (Args & (OCb | OCs | OCS)) { /* verify that swapping is possible */
26997c478bd9Sstevel@tonic-gate swapfile = 1;
27007c478bd9Sstevel@tonic-gate if (Args & (OCs | OCb) && G_p->g_filesz % 2) {
27017c478bd9Sstevel@tonic-gate msg(ERR,
27027c478bd9Sstevel@tonic-gate "Cannot swap bytes of \"%s\", odd number of bytes",
27037c478bd9Sstevel@tonic-gate nam_p);
27047c478bd9Sstevel@tonic-gate swapfile = 0;
27057c478bd9Sstevel@tonic-gate }
27067c478bd9Sstevel@tonic-gate if (Args & (OCS | OCb) && G_p->g_filesz % 4) {
27077c478bd9Sstevel@tonic-gate msg(ERR,
27087c478bd9Sstevel@tonic-gate "Cannot swap halfwords of \"%s\", odd number "
27097c478bd9Sstevel@tonic-gate "of halfwords", nam_p);
27107c478bd9Sstevel@tonic-gate swapfile = 0;
27117c478bd9Sstevel@tonic-gate }
27127c478bd9Sstevel@tonic-gate }
2713ced83f9bSceastha
2714ced83f9bSceastha data_in_info = e_zalloc(E_EXIT, sizeof (data_in_t));
2715ced83f9bSceastha data_in_info->data_in_swapfile = swapfile;
2716ced83f9bSceastha data_in_info->data_in_proc_mode = proc_mode;
27177c478bd9Sstevel@tonic-gate
27185fbb8099SNobutomo Nakano filesz = G_p->g_filesz;
27195fbb8099SNobutomo Nakano
27205fbb8099SNobutomo Nakano if (S_ISSPARSE(G_p->g_mode) && G_p->g_holes != NULL) {
27215fbb8099SNobutomo Nakano /* We've already read the header in gethdr() */
27225fbb8099SNobutomo Nakano filesz -= MIN_HOLES_HDRSIZE;
27235fbb8099SNobutomo Nakano
27245fbb8099SNobutomo Nakano /*
27255fbb8099SNobutomo Nakano * Strip rest of the sparse file information. This includes
27265fbb8099SNobutomo Nakano * the data/hole offset pairs which will be used to restore
27275fbb8099SNobutomo Nakano * the holes in the file.
27285fbb8099SNobutomo Nakano */
27295fbb8099SNobutomo Nakano if (proc_mode == P_SKIP) {
27305fbb8099SNobutomo Nakano /* holes info isn't necessary to skip file */
27315fbb8099SNobutomo Nakano free_holes_info(G_p->g_holes);
27325fbb8099SNobutomo Nakano G_p->g_holes = NULL;
27335fbb8099SNobutomo Nakano } else {
27345fbb8099SNobutomo Nakano rv = read_holesdata(G_p->g_holes, &filesz,
27355fbb8099SNobutomo Nakano nam_p, data_in_info);
27365fbb8099SNobutomo Nakano if (rv != 0) {
27375fbb8099SNobutomo Nakano /*
27385fbb8099SNobutomo Nakano * We got an error. Skip this file. holes info
27395fbb8099SNobutomo Nakano * is no longer necessary.
27405fbb8099SNobutomo Nakano */
27415fbb8099SNobutomo Nakano free_holes_info(G_p->g_holes);
27425fbb8099SNobutomo Nakano G_p->g_holes = NULL;
27435fbb8099SNobutomo Nakano
27445fbb8099SNobutomo Nakano data_in_info->data_in_proc_mode = P_SKIP;
27455fbb8099SNobutomo Nakano error = 1;
27465fbb8099SNobutomo Nakano }
27475fbb8099SNobutomo Nakano }
27485fbb8099SNobutomo Nakano }
27495fbb8099SNobutomo Nakano
27505fbb8099SNobutomo Nakano if (G_p->g_holes != NULL) {
27515fbb8099SNobutomo Nakano rv = data_copy_with_holes(-1, Ofile,
27525fbb8099SNobutomo Nakano (G_p->g_attrnam_p == NULL) ? 0 : G_p->g_rw_sysattr,
27535fbb8099SNobutomo Nakano G_p->g_holes->orig_size,
27545fbb8099SNobutomo Nakano CPIOBSZ, data_in_info, G_p->g_holes);
27555fbb8099SNobutomo Nakano
27565fbb8099SNobutomo Nakano free_holes_info(G_p->g_holes);
27575fbb8099SNobutomo Nakano G_p->g_holes = NULL;
27585fbb8099SNobutomo Nakano } else {
27595fbb8099SNobutomo Nakano rv = data_copy(-1, Ofile,
27605fbb8099SNobutomo Nakano (G_p->g_attrnam_p == NULL) ? 0 : G_p->g_rw_sysattr,
27615fbb8099SNobutomo Nakano filesz, CPIOBSZ, data_in_info);
27625fbb8099SNobutomo Nakano }
27635fbb8099SNobutomo Nakano
27647c478bd9Sstevel@tonic-gate /* This writes out the file from the archive */
27655fbb8099SNobutomo Nakano if (rv != 0 || error) {
27665fbb8099SNobutomo Nakano errno = data_in_info->data_in_errno;
27675fbb8099SNobutomo Nakano
27684e621e6cSNobutomo Nakano if (!error) {
27694e621e6cSNobutomo Nakano msg(data_in_info->data_in_wr_part ? EXTN : ERRN,
27704e621e6cSNobutomo Nakano "Cannot write \"%s%s%s\"",
2771ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
2772ced83f9bSceastha G_p->g_attrfnam_p,
2773ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
2774ced83f9bSceastha G_p->g_rw_sysattr ?
2775ced83f9bSceastha gettext(" System Attribute ") :
2776ced83f9bSceastha gettext(" Attribute "), nam_p);
2777ced83f9bSceastha }
27787c478bd9Sstevel@tonic-gate /*
27795fbb8099SNobutomo Nakano * We've failed to write to the file, and input data
27805fbb8099SNobutomo Nakano * has been skiped to the next file. We'll need to restore
27815fbb8099SNobutomo Nakano * the original file, and skip the rest of work.
27827c478bd9Sstevel@tonic-gate */
27837c478bd9Sstevel@tonic-gate proc_mode = P_SKIP;
27847c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, G_p->g_dirfd);
27857c478bd9Sstevel@tonic-gate cstatus = close(Ofile);
27867c478bd9Sstevel@tonic-gate Ofile = 0;
27877c478bd9Sstevel@tonic-gate if (cstatus != 0) {
27887c478bd9Sstevel@tonic-gate msg(EXTN, "close error");
27897c478bd9Sstevel@tonic-gate }
27907c478bd9Sstevel@tonic-gate }
27917c478bd9Sstevel@tonic-gate
27925fbb8099SNobutomo Nakano /* we must use g_filesz for the amount of padding */
27937c478bd9Sstevel@tonic-gate pad = (Pad_val + 1 - (G_p->g_filesz & Pad_val)) & Pad_val;
27947c478bd9Sstevel@tonic-gate if (pad != 0) {
27957c478bd9Sstevel@tonic-gate FILL(pad);
27967c478bd9Sstevel@tonic-gate Buffr.b_out_p += pad;
27977c478bd9Sstevel@tonic-gate Buffr.b_cnt -= pad;
27987c478bd9Sstevel@tonic-gate }
27997c478bd9Sstevel@tonic-gate if (proc_mode != P_SKIP) {
2800ced83f9bSceastha if (Hdr_type == CRC &&
2801ced83f9bSceastha Gen.g_cksum != data_in_info->data_in_cksumval) {
28027c478bd9Sstevel@tonic-gate msg(ERR, "\"%s\" - checksum error", nam_p);
28037c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, G_p->g_dirfd);
28047c478bd9Sstevel@tonic-gate } else
28057c478bd9Sstevel@tonic-gate rstfiles(U_OVER, G_p->g_dirfd);
2806ced83f9bSceastha if (Hdr_type == BAR && data_in_info->data_in_compress_flag) {
2807ced83f9bSceastha (void) pclose(data_in_info->data_in_pipef);
28087c478bd9Sstevel@tonic-gate } else {
28097c478bd9Sstevel@tonic-gate cstatus = close(Ofile);
28107c478bd9Sstevel@tonic-gate }
28117c478bd9Sstevel@tonic-gate Ofile = 0;
28127c478bd9Sstevel@tonic-gate if (cstatus != 0) {
28137c478bd9Sstevel@tonic-gate msg(EXTN, "close error");
28147c478bd9Sstevel@tonic-gate }
28157c478bd9Sstevel@tonic-gate }
2816ced83f9bSceastha (void) free(data_in_info);
2817ced83f9bSceastha
2818ced83f9bSceastha VERBOSE((proc_mode != P_SKIP && (Args & (OCv | OCV))),
2819ced83f9bSceastha (G_p->g_attrparent_p == NULL) ? G_p->g_nam_p : G_p->g_attrpath_p);
28207c478bd9Sstevel@tonic-gate Finished = 1;
28217c478bd9Sstevel@tonic-gate }
28227c478bd9Sstevel@tonic-gate
28237c478bd9Sstevel@tonic-gate /*
28245fbb8099SNobutomo Nakano * Read regular file. Return number of bytes which weren't read.
28255fbb8099SNobutomo Nakano * Upon return, real_filesz will be real file size of input file.
28265fbb8099SNobutomo Nakano * When read_exact is specified, read size is adjusted to the given
28275fbb8099SNobutomo Nakano * file size.
28285fbb8099SNobutomo Nakano */
28295fbb8099SNobutomo Nakano static off_t
read_file(char * nam_p,off_t file_size,off_t * real_filesz,boolean_t read_exact)28305fbb8099SNobutomo Nakano read_file(char *nam_p, off_t file_size, off_t *real_filesz,
28315fbb8099SNobutomo Nakano boolean_t read_exact)
28325fbb8099SNobutomo Nakano {
28335fbb8099SNobutomo Nakano int amount_read;
28345fbb8099SNobutomo Nakano off_t amt_to_read;
28355fbb8099SNobutomo Nakano off_t readsz;
28365fbb8099SNobutomo Nakano
28375fbb8099SNobutomo Nakano if (file_size == 0)
28385fbb8099SNobutomo Nakano return (0);
28395fbb8099SNobutomo Nakano
28405fbb8099SNobutomo Nakano amt_to_read = file_size;
28415fbb8099SNobutomo Nakano do {
28425fbb8099SNobutomo Nakano if (read_exact && amt_to_read < CPIOBSZ)
28435fbb8099SNobutomo Nakano readsz = amt_to_read;
28445fbb8099SNobutomo Nakano else
28455fbb8099SNobutomo Nakano readsz = CPIOBSZ;
28465fbb8099SNobutomo Nakano
28475fbb8099SNobutomo Nakano FLUSH(readsz);
28485fbb8099SNobutomo Nakano errno = 0;
28495fbb8099SNobutomo Nakano
28505fbb8099SNobutomo Nakano if ((amount_read = read(Ifile, Buffr.b_in_p, readsz)) < 0) {
28515fbb8099SNobutomo Nakano msg(EXTN, "Cannot read \"%s%s%s\"",
28525fbb8099SNobutomo Nakano (Gen.g_attrnam_p == NULL) ?
28535fbb8099SNobutomo Nakano nam_p : Gen.g_attrfnam_p,
28545fbb8099SNobutomo Nakano (Gen.g_attrnam_p == NULL) ? "" : Gen.g_rw_sysattr ?
28555fbb8099SNobutomo Nakano gettext(" System Attribute ") :
28565fbb8099SNobutomo Nakano gettext(" Attribute "),
28575fbb8099SNobutomo Nakano (Gen.g_attrnam_p == NULL) ? "" : nam_p);
28585fbb8099SNobutomo Nakano break;
28595fbb8099SNobutomo Nakano }
28605fbb8099SNobutomo Nakano
28615fbb8099SNobutomo Nakano if (amount_read == 0) {
28625fbb8099SNobutomo Nakano /* got EOF. the file has shrunk */
28635fbb8099SNobutomo Nakano *real_filesz = file_size - amt_to_read;
28645fbb8099SNobutomo Nakano break;
28655fbb8099SNobutomo Nakano } else if (amount_read > amt_to_read) {
28665fbb8099SNobutomo Nakano /* the file has grown */
28675fbb8099SNobutomo Nakano *real_filesz = file_size +
28685fbb8099SNobutomo Nakano (amount_read - amt_to_read);
28695fbb8099SNobutomo Nakano amount_read = amt_to_read;
28705fbb8099SNobutomo Nakano } else if (amount_read == amt_to_read) {
28715fbb8099SNobutomo Nakano /* the file is the same size */
28725fbb8099SNobutomo Nakano *real_filesz = file_size;
28735fbb8099SNobutomo Nakano }
28745fbb8099SNobutomo Nakano
28755fbb8099SNobutomo Nakano Buffr.b_in_p += amount_read;
2876*6d3b960aSAndy Fiddaman Buffr.b_cnt += amount_read;
28775fbb8099SNobutomo Nakano
28785fbb8099SNobutomo Nakano amt_to_read -= (off_t)amount_read;
28795fbb8099SNobutomo Nakano if (!read_exact &&
28805fbb8099SNobutomo Nakano amt_to_read == 0 && amount_read == CPIOBSZ) {
28815fbb8099SNobutomo Nakano /*
28825fbb8099SNobutomo Nakano * If the file size is multiple of CPIOBSZ, we may
28835fbb8099SNobutomo Nakano * be able to read more from the file even though
28845fbb8099SNobutomo Nakano * amt_to_read already gets 0.
28855fbb8099SNobutomo Nakano */
28865fbb8099SNobutomo Nakano FLUSH(CPIOBSZ);
28875fbb8099SNobutomo Nakano amount_read = read(Ifile, Buffr.b_in_p, CPIOBSZ);
28885fbb8099SNobutomo Nakano if (amount_read != 0) {
28895fbb8099SNobutomo Nakano /* the file has grown */
28905fbb8099SNobutomo Nakano *real_filesz = file_size + amount_read;
28915fbb8099SNobutomo Nakano }
28925fbb8099SNobutomo Nakano }
28935fbb8099SNobutomo Nakano } while (amt_to_read != 0);
28945fbb8099SNobutomo Nakano
28955fbb8099SNobutomo Nakano return (amt_to_read);
28965fbb8099SNobutomo Nakano }
28975fbb8099SNobutomo Nakano
28985fbb8099SNobutomo Nakano /*
28995fbb8099SNobutomo Nakano * Read through the data in files skipping holes.
29005fbb8099SNobutomo Nakano */
29015fbb8099SNobutomo Nakano static off_t
read_compress_holes(char * nam_p,off_t file_size,off_t * real_filesz,holes_info_t * holes,int * hole_changed)29025fbb8099SNobutomo Nakano read_compress_holes(char *nam_p, off_t file_size, off_t *real_filesz,
29035fbb8099SNobutomo Nakano holes_info_t *holes, int *hole_changed)
29045fbb8099SNobutomo Nakano {
29055fbb8099SNobutomo Nakano off_t left;
29065fbb8099SNobutomo Nakano off_t datasize, realsz;
29075fbb8099SNobutomo Nakano off_t curpos, npos;
29085fbb8099SNobutomo Nakano holes_list_t *hl = holes->holes_list;
29095fbb8099SNobutomo Nakano
29105fbb8099SNobutomo Nakano curpos = 0;
29115fbb8099SNobutomo Nakano for (hl = holes->holes_list; hl != NULL; hl = hl->hl_next) {
29125fbb8099SNobutomo Nakano datasize = hl->hl_hole - hl->hl_data;
29135fbb8099SNobutomo Nakano
29145fbb8099SNobutomo Nakano npos = lseek(Ifile, curpos, SEEK_DATA);
29155fbb8099SNobutomo Nakano if (npos == -1 && errno == ENXIO) {
29165fbb8099SNobutomo Nakano /*
29175fbb8099SNobutomo Nakano * No more data. There are two cases.
29185fbb8099SNobutomo Nakano * - we have a hole toward the end of file.
29195fbb8099SNobutomo Nakano * - file has been shrunk, and we've reached EOF.
29205fbb8099SNobutomo Nakano */
29215fbb8099SNobutomo Nakano *real_filesz = lseek(Ifile, 0, SEEK_END);
29225fbb8099SNobutomo Nakano if (hl->hl_data == file_size)
29235fbb8099SNobutomo Nakano return (0);
29245fbb8099SNobutomo Nakano /*
29255fbb8099SNobutomo Nakano * File has been shrunk. Check the amount of data
29265fbb8099SNobutomo Nakano * left.
29275fbb8099SNobutomo Nakano */
29285fbb8099SNobutomo Nakano left = 0;
29295fbb8099SNobutomo Nakano while (hl != NULL) {
29305fbb8099SNobutomo Nakano left += (hl->hl_hole - hl->hl_data);
29315fbb8099SNobutomo Nakano hl = hl->hl_next;
29325fbb8099SNobutomo Nakano }
29335fbb8099SNobutomo Nakano return (left);
29345fbb8099SNobutomo Nakano }
29355fbb8099SNobutomo Nakano
29365fbb8099SNobutomo Nakano /* found data */
29375fbb8099SNobutomo Nakano curpos = npos;
29385fbb8099SNobutomo Nakano if (curpos != hl->hl_data) {
29395fbb8099SNobutomo Nakano /*
29405fbb8099SNobutomo Nakano * File has been changed. We shouldn't read data
29415fbb8099SNobutomo Nakano * from different offset since we've already put
29425fbb8099SNobutomo Nakano * the holes data.
29435fbb8099SNobutomo Nakano */
29445fbb8099SNobutomo Nakano *hole_changed = 1;
29455fbb8099SNobutomo Nakano (void) lseek(Ifile, hl->hl_data, SEEK_SET);
29465fbb8099SNobutomo Nakano curpos = hl->hl_data;
29475fbb8099SNobutomo Nakano }
29485fbb8099SNobutomo Nakano left = read_file(nam_p, datasize, &realsz, B_TRUE);
29495fbb8099SNobutomo Nakano if (left != 0) {
29505fbb8099SNobutomo Nakano /* file has been shrunk */
29515fbb8099SNobutomo Nakano *real_filesz = curpos + datasize - left;
29525fbb8099SNobutomo Nakano left = file_size - *real_filesz;
29535fbb8099SNobutomo Nakano return (left);
29545fbb8099SNobutomo Nakano }
29555fbb8099SNobutomo Nakano curpos += datasize;
29565fbb8099SNobutomo Nakano }
29575fbb8099SNobutomo Nakano /*
29585fbb8099SNobutomo Nakano * We've read exact size of holes. We need to make sure
29595fbb8099SNobutomo Nakano * that file hasn't grown by reading from the EOF.
29605fbb8099SNobutomo Nakano */
29615fbb8099SNobutomo Nakano realsz = 0;
29625fbb8099SNobutomo Nakano (void) read_file(nam_p, CPIOBSZ, &realsz, B_FALSE);
29635fbb8099SNobutomo Nakano
29645fbb8099SNobutomo Nakano *real_filesz = curpos + realsz;
29655fbb8099SNobutomo Nakano return (0);
29665fbb8099SNobutomo Nakano }
29675fbb8099SNobutomo Nakano
29685fbb8099SNobutomo Nakano /*
29697c478bd9Sstevel@tonic-gate * data_out: open(2) the file to be archived, compute the checksum
29707c478bd9Sstevel@tonic-gate * of it's data if the CRC header was specified and write the header.
29717c478bd9Sstevel@tonic-gate * read(2) each block of data and bwrite() it to the archive. For TARTYP (TAR
29727c478bd9Sstevel@tonic-gate * and USTAR) archives, pad the data with NULLs to the next 512 byte boundary.
29737c478bd9Sstevel@tonic-gate */
29747c478bd9Sstevel@tonic-gate static void
data_out(void)29757c478bd9Sstevel@tonic-gate data_out(void)
29767c478bd9Sstevel@tonic-gate {
29777c478bd9Sstevel@tonic-gate char *nam_p;
29785fbb8099SNobutomo Nakano int cnt, pad;
29795fbb8099SNobutomo Nakano off_t amt_to_read;
29805fbb8099SNobutomo Nakano off_t real_filesz;
29817c478bd9Sstevel@tonic-gate int errret = 0;
29825fbb8099SNobutomo Nakano int hole_changed = 0;
29835fbb8099SNobutomo Nakano off_t orig_filesz;
29845fbb8099SNobutomo Nakano holes_info_t *holes = NULL;
29857c478bd9Sstevel@tonic-gate
29867c478bd9Sstevel@tonic-gate nam_p = G_p->g_nam_p;
29877c478bd9Sstevel@tonic-gate if (Aspec) {
29887c478bd9Sstevel@tonic-gate if (Pflag && aclp != NULL) {
29897c478bd9Sstevel@tonic-gate char *secinfo = NULL;
29907c478bd9Sstevel@tonic-gate int len = 0;
29917c478bd9Sstevel@tonic-gate
29927c478bd9Sstevel@tonic-gate /* append security attributes */
2993fa9e4066Sahrens if (append_secattr(&secinfo, &len, aclp) == -1) {
29947c478bd9Sstevel@tonic-gate msg(ERR,
29957c478bd9Sstevel@tonic-gate "can create security information");
29967c478bd9Sstevel@tonic-gate }
29977c478bd9Sstevel@tonic-gate /* call append_secattr() if more than one */
29987c478bd9Sstevel@tonic-gate
29997c478bd9Sstevel@tonic-gate if (len > 0) {
30007c478bd9Sstevel@tonic-gate /* write ancillary only if there is sec info */
30015fbb8099SNobutomo Nakano write_hdr(ARCHIVE_ACL, (off_t)len);
30025fbb8099SNobutomo Nakano write_ancillary(secinfo, len, B_TRUE);
30037c478bd9Sstevel@tonic-gate }
30047c478bd9Sstevel@tonic-gate }
30057c478bd9Sstevel@tonic-gate write_hdr(ARCHIVE_NORMAL, (off_t)0);
30067c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, G_p->g_dirfd);
30077c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), nam_p);
30087c478bd9Sstevel@tonic-gate return;
30097c478bd9Sstevel@tonic-gate }
30107c478bd9Sstevel@tonic-gate if ((G_p->g_mode & Ftype) == S_IFLNK && (Hdr_type !=
30117c478bd9Sstevel@tonic-gate USTAR && Hdr_type != TAR)) { /* symbolic link */
30127c478bd9Sstevel@tonic-gate int size;
30137c478bd9Sstevel@tonic-gate write_hdr(ARCHIVE_NORMAL, (off_t)0);
30147c478bd9Sstevel@tonic-gate
30157c478bd9Sstevel@tonic-gate FLUSH(G_p->g_filesz);
30167c478bd9Sstevel@tonic-gate errno = 0;
30177c478bd9Sstevel@tonic-gate
30187c478bd9Sstevel@tonic-gate /* Note that "size" and G_p->g_filesz are the same number */
30197c478bd9Sstevel@tonic-gate
30207c478bd9Sstevel@tonic-gate if ((size = readlink(nam_p, Buffr.b_in_p, G_p->g_filesz)) <
30217c478bd9Sstevel@tonic-gate 0) {
30227c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot read symbolic link \"%s\"", nam_p);
30237c478bd9Sstevel@tonic-gate return;
30247c478bd9Sstevel@tonic-gate }
30257c478bd9Sstevel@tonic-gate
30267c478bd9Sstevel@tonic-gate /*
30277c478bd9Sstevel@tonic-gate * Note that it is OK not to add the NUL after the name read by
30287c478bd9Sstevel@tonic-gate * readlink, because it is not being used subsequently.
30297c478bd9Sstevel@tonic-gate */
30307c478bd9Sstevel@tonic-gate
30317c478bd9Sstevel@tonic-gate Buffr.b_in_p += size;
30327c478bd9Sstevel@tonic-gate Buffr.b_cnt += size;
30337c478bd9Sstevel@tonic-gate pad = (Pad_val + 1 - (size & Pad_val)) & Pad_val;
30347c478bd9Sstevel@tonic-gate if (pad != 0) {
30357c478bd9Sstevel@tonic-gate FLUSH(pad);
30365fbb8099SNobutomo Nakano (void) memset(Buffr.b_in_p, 0, pad);
30377c478bd9Sstevel@tonic-gate Buffr.b_in_p += pad;
30387c478bd9Sstevel@tonic-gate Buffr.b_cnt += pad;
30397c478bd9Sstevel@tonic-gate }
30407c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), nam_p);
30417c478bd9Sstevel@tonic-gate return;
30427c478bd9Sstevel@tonic-gate } else if ((G_p->g_mode & Ftype) == S_IFLNK &&
30437c478bd9Sstevel@tonic-gate (Hdr_type == USTAR || Hdr_type == TAR)) {
30447c478bd9Sstevel@tonic-gate int size;
30457c478bd9Sstevel@tonic-gate
30467c478bd9Sstevel@tonic-gate /*
30477c478bd9Sstevel@tonic-gate * G_p->g_filesz is the length of the right-hand side of
30487c478bd9Sstevel@tonic-gate * the symlink "x -> y".
30497c478bd9Sstevel@tonic-gate * The tar link field is only NAMSIZ long.
30507c478bd9Sstevel@tonic-gate */
30517c478bd9Sstevel@tonic-gate
30527c478bd9Sstevel@tonic-gate if (G_p->g_filesz > NAMSIZ) {
30537c478bd9Sstevel@tonic-gate msg(ERRN,
30547c478bd9Sstevel@tonic-gate "Symbolic link too long \"%s\"", nam_p);
30557c478bd9Sstevel@tonic-gate return;
30567c478bd9Sstevel@tonic-gate }
30577c478bd9Sstevel@tonic-gate if ((size = readlink(nam_p, T_lname, G_p->g_filesz)) < 0) {
30587c478bd9Sstevel@tonic-gate msg(ERRN,
30597c478bd9Sstevel@tonic-gate "Cannot read symbolic link \"%s\"", nam_p);
30607c478bd9Sstevel@tonic-gate return;
30617c478bd9Sstevel@tonic-gate }
30627c478bd9Sstevel@tonic-gate T_lname[size] = '\0';
30637c478bd9Sstevel@tonic-gate G_p->g_filesz = (off_t)0;
30647c478bd9Sstevel@tonic-gate write_hdr(ARCHIVE_NORMAL, (off_t)0);
30657c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), nam_p);
30667c478bd9Sstevel@tonic-gate return;
30677c478bd9Sstevel@tonic-gate }
30687c478bd9Sstevel@tonic-gate if ((Ifile = openfile(O_RDONLY)) < 0) {
30697c478bd9Sstevel@tonic-gate msg(ERR, "\"%s%s%s\" ?",
3070ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? nam_p : Gen.g_attrfnam_p,
3071ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? "" : Gen.g_rw_sysattr ?
3072ced83f9bSceastha gettext(" System Attribute ") : gettext(" Attribute "),
3073ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? "" :
3074ced83f9bSceastha (Gen.g_attrparent_p == NULL) ? Gen.g_attrnam_p :
3075ced83f9bSceastha Gen.g_attrparent_p);
30767c478bd9Sstevel@tonic-gate return;
30777c478bd9Sstevel@tonic-gate }
30787c478bd9Sstevel@tonic-gate
30795fbb8099SNobutomo Nakano /* save original file size */
30805fbb8099SNobutomo Nakano orig_filesz = G_p->g_filesz;
30815fbb8099SNobutomo Nakano
30825fbb8099SNobutomo Nakano /*
30835fbb8099SNobutomo Nakano * Calculate the new compressed file size of a sparse file
30845fbb8099SNobutomo Nakano * before any of the header information is written
30855fbb8099SNobutomo Nakano * to the archive.
30865fbb8099SNobutomo Nakano */
30875fbb8099SNobutomo Nakano if (Compress_sparse && S_ISREG(G_p->g_mode)) {
30885fbb8099SNobutomo Nakano /*
30895fbb8099SNobutomo Nakano * If the file being processed is a sparse file, gather the
30905fbb8099SNobutomo Nakano * hole information and the compressed file size.
30915fbb8099SNobutomo Nakano * G_p->g_filesz will need to be changed to be the size of
30925fbb8099SNobutomo Nakano * the compressed sparse file plus the the size of the hole
30935fbb8099SNobutomo Nakano * information that will be prepended to the compressed file
30945fbb8099SNobutomo Nakano * in the archive.
30955fbb8099SNobutomo Nakano */
30965fbb8099SNobutomo Nakano holes = get_holes_info(Ifile, G_p->g_filesz, B_FALSE);
30975fbb8099SNobutomo Nakano if (holes != NULL)
30985fbb8099SNobutomo Nakano G_p->g_filesz = holes->holesdata_sz + holes->data_size;
30995fbb8099SNobutomo Nakano
31005fbb8099SNobutomo Nakano if (G_p->g_filesz > Max_offset) {
31015fbb8099SNobutomo Nakano msg(ERR, "%s%s%s: too large to archive "
31025fbb8099SNobutomo Nakano "in current mode",
31035fbb8099SNobutomo Nakano G_p->g_nam_p,
31045fbb8099SNobutomo Nakano (G_p->g_attrnam_p == NULL) ? "" :
31055fbb8099SNobutomo Nakano G_p->g_rw_sysattr ?
31065fbb8099SNobutomo Nakano gettext(" System Attribute ") :
31075fbb8099SNobutomo Nakano gettext(" Attribute "),
31085fbb8099SNobutomo Nakano (G_p->g_attrnam_p == NULL) ? "" :
31095fbb8099SNobutomo Nakano ((G_p->g_attrparent_p == NULL) ?
31105fbb8099SNobutomo Nakano G_p->g_attrnam_p:
31115fbb8099SNobutomo Nakano G_p->g_attrpath_p));
31125fbb8099SNobutomo Nakano
31135fbb8099SNobutomo Nakano (void) close(Ifile);
31145fbb8099SNobutomo Nakano if (holes != NULL)
31155fbb8099SNobutomo Nakano free_holes_info(holes);
31165fbb8099SNobutomo Nakano return; /* do not archive if it's too big */
31175fbb8099SNobutomo Nakano }
31185fbb8099SNobutomo Nakano }
31195fbb8099SNobutomo Nakano
31207c478bd9Sstevel@tonic-gate /*
31217c478bd9Sstevel@tonic-gate * Dump extended attribute header.
31227c478bd9Sstevel@tonic-gate */
31237c478bd9Sstevel@tonic-gate
3124ced83f9bSceastha if (Gen.g_attrnam_p != NULL) {
31257c478bd9Sstevel@tonic-gate write_xattr_hdr();
31267c478bd9Sstevel@tonic-gate }
31277c478bd9Sstevel@tonic-gate
31287c478bd9Sstevel@tonic-gate if (Hdr_type == CRC) {
3129*6d3b960aSAndy Fiddaman uint_t csum = cksum(CRC, 0, &errret);
31307c478bd9Sstevel@tonic-gate if (errret != 0) {
3131*6d3b960aSAndy Fiddaman G_p->g_cksum = UINT_MAX;
31327c478bd9Sstevel@tonic-gate msg(POST, "\"%s%s%s\" skipped",
3133ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
31347c478bd9Sstevel@tonic-gate nam_p : Gen.g_attrfnam_p,
3135ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? "" : Gen.g_rw_sysattr ?
3136ced83f9bSceastha gettext(" System Attribute ") :
3137ced83f9bSceastha gettext(" Attribute "),
3138ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? "" : nam_p);
31395fbb8099SNobutomo Nakano if (holes != NULL)
31405fbb8099SNobutomo Nakano free_holes_info(holes);
31417c478bd9Sstevel@tonic-gate (void) close(Ifile);
31427c478bd9Sstevel@tonic-gate return;
31437c478bd9Sstevel@tonic-gate }
31447c478bd9Sstevel@tonic-gate G_p->g_cksum = csum;
31457c478bd9Sstevel@tonic-gate } else {
31467c478bd9Sstevel@tonic-gate G_p->g_cksum = 0;
31477c478bd9Sstevel@tonic-gate }
31487c478bd9Sstevel@tonic-gate
31497c478bd9Sstevel@tonic-gate /*
31507c478bd9Sstevel@tonic-gate * ACL has been retrieved in getname().
31517c478bd9Sstevel@tonic-gate */
31527c478bd9Sstevel@tonic-gate if (Pflag) {
31537c478bd9Sstevel@tonic-gate char *secinfo = NULL;
31547c478bd9Sstevel@tonic-gate int len = 0;
31557c478bd9Sstevel@tonic-gate
31567c478bd9Sstevel@tonic-gate /* append security attributes */
3157fa9e4066Sahrens if ((append_secattr(&secinfo, &len, aclp)) == -1)
31587c478bd9Sstevel@tonic-gate msg(ERR, "can create security information");
31597c478bd9Sstevel@tonic-gate
31607c478bd9Sstevel@tonic-gate /* call append_secattr() if more than one */
31617c478bd9Sstevel@tonic-gate
31627c478bd9Sstevel@tonic-gate if (len > 0) {
31637c478bd9Sstevel@tonic-gate /* write ancillary only if there is sec info */
31645fbb8099SNobutomo Nakano write_hdr(ARCHIVE_ACL, (off_t)len);
31655fbb8099SNobutomo Nakano write_ancillary(secinfo, len, B_TRUE);
31667c478bd9Sstevel@tonic-gate }
31677c478bd9Sstevel@tonic-gate }
31687c478bd9Sstevel@tonic-gate
31695fbb8099SNobutomo Nakano if (holes != NULL) {
31705fbb8099SNobutomo Nakano /*
31715fbb8099SNobutomo Nakano * Write the header info with a modified c_mode field to
31725fbb8099SNobutomo Nakano * indicate a compressed sparse file is being archived,
31735fbb8099SNobutomo Nakano * as well as the new file size, including the size of the
31745fbb8099SNobutomo Nakano * compressed file as well as all the prepended data.
31755fbb8099SNobutomo Nakano */
31765fbb8099SNobutomo Nakano write_hdr(ARCHIVE_SPARSE, (off_t)0);
31775fbb8099SNobutomo Nakano /* Prepend sparse file info */
31785fbb8099SNobutomo Nakano write_ancillary(holes->holesdata,
31795fbb8099SNobutomo Nakano holes->holesdata_sz, B_FALSE);
31805fbb8099SNobutomo Nakano } else {
31817c478bd9Sstevel@tonic-gate write_hdr(ARCHIVE_NORMAL, (off_t)0);
31825fbb8099SNobutomo Nakano }
31837c478bd9Sstevel@tonic-gate
31847c478bd9Sstevel@tonic-gate real_filesz = 0;
31857c478bd9Sstevel@tonic-gate
31865fbb8099SNobutomo Nakano if (holes != NULL) {
31875fbb8099SNobutomo Nakano amt_to_read = read_compress_holes(nam_p, G_p->g_filesz,
31885fbb8099SNobutomo Nakano &real_filesz, holes, &hole_changed);
31895fbb8099SNobutomo Nakano } else {
31905fbb8099SNobutomo Nakano amt_to_read = read_file(nam_p, G_p->g_filesz,
31915fbb8099SNobutomo Nakano &real_filesz, B_FALSE);
31927c478bd9Sstevel@tonic-gate }
31937c478bd9Sstevel@tonic-gate
31947c478bd9Sstevel@tonic-gate while (amt_to_read > 0) {
31957c478bd9Sstevel@tonic-gate cnt = (amt_to_read > CPIOBSZ) ? CPIOBSZ : (int)amt_to_read;
31967c478bd9Sstevel@tonic-gate FLUSH(cnt);
31975fbb8099SNobutomo Nakano (void) memset(Buffr.b_in_p, 0, cnt);
31987c478bd9Sstevel@tonic-gate Buffr.b_in_p += cnt;
31997c478bd9Sstevel@tonic-gate Buffr.b_cnt += cnt;
32007c478bd9Sstevel@tonic-gate amt_to_read -= cnt;
32017c478bd9Sstevel@tonic-gate }
32027c478bd9Sstevel@tonic-gate
32037c478bd9Sstevel@tonic-gate pad = (Pad_val + 1 - (G_p->g_filesz & Pad_val)) & Pad_val;
32047c478bd9Sstevel@tonic-gate if (pad != 0) {
32057c478bd9Sstevel@tonic-gate FLUSH(pad);
32065fbb8099SNobutomo Nakano (void) memset(Buffr.b_in_p, 0, pad);
32077c478bd9Sstevel@tonic-gate Buffr.b_in_p += pad;
32087c478bd9Sstevel@tonic-gate Buffr.b_cnt += pad;
32097c478bd9Sstevel@tonic-gate }
32107c478bd9Sstevel@tonic-gate
32115fbb8099SNobutomo Nakano if (hole_changed == 1) {
32125fbb8099SNobutomo Nakano msg(ERR,
32135fbb8099SNobutomo Nakano "File data and hole offsets of \"%s%s%s\" have changed",
32145fbb8099SNobutomo Nakano (Gen.g_attrnam_p == NULL) ?
32155fbb8099SNobutomo Nakano G_p->g_nam_p : Gen.g_attrfnam_p,
32165fbb8099SNobutomo Nakano (Gen.g_attrnam_p == NULL) ? "" : Gen.g_rw_sysattr ?
32175fbb8099SNobutomo Nakano gettext(" System Attribute ") : gettext(" Attribute "),
32185fbb8099SNobutomo Nakano (Gen.g_attrnam_p == NULL) ? "" : G_p->g_nam_p);
32195fbb8099SNobutomo Nakano }
32205fbb8099SNobutomo Nakano if (real_filesz > orig_filesz) {
32217c478bd9Sstevel@tonic-gate msg(ERR, "File size of \"%s%s%s\" has increased by %lld",
3222ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
32237c478bd9Sstevel@tonic-gate G_p->g_nam_p : Gen.g_attrfnam_p,
3224ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? "" : Gen.g_rw_sysattr ?
3225ced83f9bSceastha gettext(" System Attribute ") : gettext(" Attribute "),
3226ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? "" : G_p->g_nam_p,
32275fbb8099SNobutomo Nakano (real_filesz - orig_filesz));
32287c478bd9Sstevel@tonic-gate }
32295fbb8099SNobutomo Nakano if (real_filesz < orig_filesz) {
32307c478bd9Sstevel@tonic-gate msg(ERR, "File size of \"%s%s%s\" has decreased by %lld",
3231ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
32327c478bd9Sstevel@tonic-gate G_p->g_nam_p : Gen.g_attrfnam_p,
3233ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? "" : Gen.g_rw_sysattr ?
3234ced83f9bSceastha gettext(" System Attribute ") : gettext(" Attribute "),
3235ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? "" : G_p->g_nam_p,
32365fbb8099SNobutomo Nakano (orig_filesz - real_filesz));
32377c478bd9Sstevel@tonic-gate }
32387c478bd9Sstevel@tonic-gate
32395fbb8099SNobutomo Nakano if (holes != NULL)
32405fbb8099SNobutomo Nakano free_holes_info(holes);
32415fbb8099SNobutomo Nakano
32427c478bd9Sstevel@tonic-gate (void) close(Ifile);
32437c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, G_p->g_dirfd);
32447c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), G_p->g_nam_p);
32457c478bd9Sstevel@tonic-gate }
32467c478bd9Sstevel@tonic-gate
32477c478bd9Sstevel@tonic-gate /*
32487c478bd9Sstevel@tonic-gate * data_pass: If not a special file (Aspec), open(2) the file to be
32497c478bd9Sstevel@tonic-gate * transferred, read(2) each block of data and write(2) it to the output file
32507c478bd9Sstevel@tonic-gate * Ofile, which was opened in file_pass().
32517c478bd9Sstevel@tonic-gate */
32527c478bd9Sstevel@tonic-gate static void
data_pass(void)32537c478bd9Sstevel@tonic-gate data_pass(void)
32547c478bd9Sstevel@tonic-gate {
3255ced83f9bSceastha int rv;
32567c478bd9Sstevel@tonic-gate int cstatus;
32577c478bd9Sstevel@tonic-gate char *namep = Nam_p;
32585fbb8099SNobutomo Nakano holes_info_t *holes = NULL;
32594e621e6cSNobutomo Nakano data_in_t *data_in_info;
32607c478bd9Sstevel@tonic-gate
3261ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
32627c478bd9Sstevel@tonic-gate namep = G_p->g_attrnam_p;
32637c478bd9Sstevel@tonic-gate }
32647c478bd9Sstevel@tonic-gate if (Aspec) {
32657c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, G_p->g_passdirfd);
32667c478bd9Sstevel@tonic-gate cstatus = close(Ofile);
32677c478bd9Sstevel@tonic-gate Ofile = 0;
32687c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), Nam_p);
32697c478bd9Sstevel@tonic-gate if (cstatus != 0) {
32707c478bd9Sstevel@tonic-gate msg(EXTN, "close error");
32717c478bd9Sstevel@tonic-gate }
32727c478bd9Sstevel@tonic-gate return;
32737c478bd9Sstevel@tonic-gate }
32747c478bd9Sstevel@tonic-gate if ((Ifile = openat(G_p->g_dirfd, get_component(namep), 0)) < 0) {
32757c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot open \"%s%s%s\", skipped",
3276ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? Nam_p : G_p->g_attrfnam_p,
3277ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : G_p->g_rw_sysattr ?
3278ced83f9bSceastha gettext(" System Attribute ") : gettext(" Attribute "),
3279ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : G_p->g_attrnam_p);
32807c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, G_p->g_passdirfd);
32817c478bd9Sstevel@tonic-gate cstatus = close(Ofile);
32827c478bd9Sstevel@tonic-gate Ofile = 0;
32837c478bd9Sstevel@tonic-gate if (cstatus != 0) {
32847c478bd9Sstevel@tonic-gate msg(EXTN, "close error");
32857c478bd9Sstevel@tonic-gate }
32867c478bd9Sstevel@tonic-gate return;
32877c478bd9Sstevel@tonic-gate }
32887c478bd9Sstevel@tonic-gate
32894e621e6cSNobutomo Nakano data_in_info = e_zalloc(E_EXIT, sizeof (data_in_t));
32904e621e6cSNobutomo Nakano data_in_info->data_in_proc_mode = P_PROC;
32914e621e6cSNobutomo Nakano
32925fbb8099SNobutomo Nakano if (S_ISREG(G_p->g_mode))
32935fbb8099SNobutomo Nakano holes = get_holes_info(Ifile, G_p->g_filesz, B_TRUE);
32945fbb8099SNobutomo Nakano
32955fbb8099SNobutomo Nakano if (holes != NULL) {
32965fbb8099SNobutomo Nakano rv = data_copy_with_holes(Ifile, Ofile,
32975fbb8099SNobutomo Nakano (G_p->g_attrnam_p == NULL) ? 0 : G_p->g_rw_sysattr,
32984e621e6cSNobutomo Nakano G_p->g_filesz, Bufsize, data_in_info, holes);
32995fbb8099SNobutomo Nakano
33005fbb8099SNobutomo Nakano free_holes_info(holes);
33015fbb8099SNobutomo Nakano } else {
33025fbb8099SNobutomo Nakano rv = data_copy(Ifile, Ofile,
33035fbb8099SNobutomo Nakano (G_p->g_attrnam_p == NULL) ? 0 : G_p->g_rw_sysattr,
33044e621e6cSNobutomo Nakano G_p->g_filesz, Bufsize, data_in_info);
33055fbb8099SNobutomo Nakano }
33064e621e6cSNobutomo Nakano
3307ced83f9bSceastha if (rv < 0) {
33084e621e6cSNobutomo Nakano /* read error or unexpected EOF */
33094e621e6cSNobutomo Nakano if (data_in_info->data_in_rd_eof) {
33104e621e6cSNobutomo Nakano /*
33114e621e6cSNobutomo Nakano * read has reached EOF unexpectedly, but this isn't
33124e621e6cSNobutomo Nakano * an error since it's the latest shape of the file.
33134e621e6cSNobutomo Nakano */
33144e621e6cSNobutomo Nakano msg(EPOST, "File size of \"%s%s%s\" has decreased",
33154e621e6cSNobutomo Nakano (G_p->g_attrnam_p == NULL) ?
33164e621e6cSNobutomo Nakano Nam_p : G_p->g_attrfnam_p,
33174e621e6cSNobutomo Nakano (G_p->g_attrnam_p == NULL) ? "" :
33184e621e6cSNobutomo Nakano G_p->g_rw_sysattr ? gettext(" System Attribute ") :
33194e621e6cSNobutomo Nakano gettext(" Attribute "),
33204e621e6cSNobutomo Nakano (G_p->g_attrnam_p == NULL) ? "" : G_p->g_attrnam_p);
33214e621e6cSNobutomo Nakano
33224e621e6cSNobutomo Nakano /* It's not error. We'll use the new file */
33234e621e6cSNobutomo Nakano rv = 0;
33244e621e6cSNobutomo Nakano } else {
33254e621e6cSNobutomo Nakano /* read error */
33267c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot read \"%s%s%s\"",
3327ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
33287c478bd9Sstevel@tonic-gate Nam_p : G_p->g_attrfnam_p,
3329ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
3330ced83f9bSceastha G_p->g_rw_sysattr ? gettext(" System Attribute ") :
3331ced83f9bSceastha gettext(" Attribute "),
3332ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : G_p->g_attrnam_p);
33334e621e6cSNobutomo Nakano }
3334ced83f9bSceastha } else if (rv > 0) {
33354e621e6cSNobutomo Nakano /* write error */
33367c478bd9Sstevel@tonic-gate if (Do_rename) {
33377c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot write \"%s%s%s\"", Over_p,
3338ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
33394e621e6cSNobutomo Nakano G_p->g_rw_sysattr ? gettext(" System Attribute ") :
3340ced83f9bSceastha gettext(" Attribute "),
3341ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : Over_p);
33427c478bd9Sstevel@tonic-gate } else {
33437c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot write \"%s%s%s\"",
33447c478bd9Sstevel@tonic-gate Fullnam_p,
3345ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
33464e621e6cSNobutomo Nakano G_p->g_rw_sysattr ? gettext(" System Attribute ") :
3347ced83f9bSceastha gettext(" Attribute "),
33484e621e6cSNobutomo Nakano (G_p->g_attrnam_p == NULL) ? "" : G_p->g_attrnam_p);
33497c478bd9Sstevel@tonic-gate }
3350ced83f9bSceastha }
33514e621e6cSNobutomo Nakano
33524e621e6cSNobutomo Nakano free(data_in_info);
3353ced83f9bSceastha
33545fbb8099SNobutomo Nakano if (rv == 0) {
33557c478bd9Sstevel@tonic-gate rstfiles(U_OVER, G_p->g_passdirfd);
33567c478bd9Sstevel@tonic-gate } else {
33577c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, G_p->g_passdirfd);
33587c478bd9Sstevel@tonic-gate }
3359ced83f9bSceastha
33607c478bd9Sstevel@tonic-gate (void) close(Ifile);
33617c478bd9Sstevel@tonic-gate cstatus = close(Ofile);
33627c478bd9Sstevel@tonic-gate Ofile = 0;
33637c478bd9Sstevel@tonic-gate if (cstatus != 0) {
33647c478bd9Sstevel@tonic-gate msg(EXTN, "close error");
33657c478bd9Sstevel@tonic-gate }
33667c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), Fullnam_p);
33677c478bd9Sstevel@tonic-gate Finished = 1;
33687c478bd9Sstevel@tonic-gate }
33697c478bd9Sstevel@tonic-gate
33707c478bd9Sstevel@tonic-gate /*
33717c478bd9Sstevel@tonic-gate * file_in: Process an object from the archive. If a TARTYP (TAR or USTAR)
33727c478bd9Sstevel@tonic-gate * archive and g_nlink == 1, link this file to the file name in t_linkname
33737c478bd9Sstevel@tonic-gate * and return. Handle linked files in one of two ways. If Onecopy == 0, this
33747c478bd9Sstevel@tonic-gate * is an old style (binary or -c) archive, create and extract the data for the
33757c478bd9Sstevel@tonic-gate * first link found, link all subsequent links to this file and skip their data.
33767c478bd9Sstevel@tonic-gate * If Oncecopy == 1, save links until all have been processed, and then
33777c478bd9Sstevel@tonic-gate * process the links first to last checking their names against the patterns
33787c478bd9Sstevel@tonic-gate * and/or asking the user to rename them. The first link that is accepted
33797c478bd9Sstevel@tonic-gate * for xtraction is created and the data is read from the archive.
33807c478bd9Sstevel@tonic-gate * All subsequent links that are accepted are linked to this file.
33817c478bd9Sstevel@tonic-gate */
33827c478bd9Sstevel@tonic-gate static void
file_in(void)33837c478bd9Sstevel@tonic-gate file_in(void)
33847c478bd9Sstevel@tonic-gate {
33857c478bd9Sstevel@tonic-gate struct Lnk *l_p, *tl_p;
33867c478bd9Sstevel@tonic-gate int lnkem = 0, cleanup = 0;
33877c478bd9Sstevel@tonic-gate int proc_file;
33887c478bd9Sstevel@tonic-gate struct Lnk *ttl_p;
33897c478bd9Sstevel@tonic-gate int typeflag;
33907c478bd9Sstevel@tonic-gate char savacl;
33917c478bd9Sstevel@tonic-gate int cwd;
33927c478bd9Sstevel@tonic-gate
33937c478bd9Sstevel@tonic-gate G_p = &Gen;
33947c478bd9Sstevel@tonic-gate
33957c478bd9Sstevel@tonic-gate /*
3396ced83f9bSceastha * Now that we've read the extended header,
3397ced83f9bSceastha * determine if we should restore attributes.
3398ced83f9bSceastha * Don't restore the attribute if we are extracting
3399ced83f9bSceastha * a file from an archive (as opposed to doing a table of
3400ced83f9bSceastha * contents) and any of the following are true:
3401ced83f9bSceastha * 1. neither -@ or -/ was specified.
3402ced83f9bSceastha * 2. -@ was specified, -/ wasn't specified, and we're
3403ced83f9bSceastha * processing a hidden attribute directory of an attribute
3404ced83f9bSceastha * or we're processing a read-write system attribute file.
3405ced83f9bSceastha * 3. -@ wasn't specified, -/ was specified, and the file
3406ced83f9bSceastha * we're processing it not a read-write system attribute file,
3407ced83f9bSceastha * or we're processing the hidden attribute directory of an
3408ced83f9bSceastha * attribute.
3409ced83f9bSceastha *
3410ced83f9bSceastha * We always process the attributes if we're just generating
3411ced83f9bSceastha * generating a table of contents, or if both -@ and -/ were
3412ced83f9bSceastha * specified.
3413ced83f9bSceastha */
3414ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
3415ced83f9bSceastha if (((Args & OCt) == 0) &&
3416ced83f9bSceastha ((!Atflag && !SysAtflag) ||
3417ced83f9bSceastha (Atflag && !SysAtflag && ((G_p->g_attrparent_p != NULL) ||
3418ced83f9bSceastha G_p->g_rw_sysattr)) ||
3419ced83f9bSceastha (!Atflag && SysAtflag && ((G_p->g_attrparent_p != NULL) ||
3420ced83f9bSceastha !G_p->g_rw_sysattr)))) {
3421ced83f9bSceastha proc_file = F_SKIP;
3422ced83f9bSceastha data_in(P_SKIP);
3423ced83f9bSceastha return;
3424ced83f9bSceastha }
3425ced83f9bSceastha }
3426ced83f9bSceastha
3427ced83f9bSceastha /*
34287c478bd9Sstevel@tonic-gate * Open target directory if this isn't a skipped file
34297c478bd9Sstevel@tonic-gate * and g_nlink == 1
34307c478bd9Sstevel@tonic-gate *
34317c478bd9Sstevel@tonic-gate * Links are handled further down in this function.
34327c478bd9Sstevel@tonic-gate */
34337c478bd9Sstevel@tonic-gate
34347c478bd9Sstevel@tonic-gate proc_file = ckname(0);
34357c478bd9Sstevel@tonic-gate
34367c478bd9Sstevel@tonic-gate if (proc_file == F_SKIP && G_p->g_nlink == 1) {
34377c478bd9Sstevel@tonic-gate /*
34387c478bd9Sstevel@tonic-gate * Normally ckname() prints out the file as a side
34397c478bd9Sstevel@tonic-gate * effect except for table of contents listing
34407c478bd9Sstevel@tonic-gate * when its parameter is zero and Onecopy isn't
34417c478bd9Sstevel@tonic-gate * Zero. Due to this we need to force the name
34427c478bd9Sstevel@tonic-gate * to be printed here.
34437c478bd9Sstevel@tonic-gate */
34447c478bd9Sstevel@tonic-gate if (Onecopy == 1) {
34457c478bd9Sstevel@tonic-gate VERBOSE((Args & OCt), G_p->g_nam_p);
34467c478bd9Sstevel@tonic-gate }
34477c478bd9Sstevel@tonic-gate data_in(P_SKIP);
34487c478bd9Sstevel@tonic-gate return;
34497c478bd9Sstevel@tonic-gate }
34507c478bd9Sstevel@tonic-gate
34517c478bd9Sstevel@tonic-gate if (proc_file != F_SKIP && open_dirfd() != 0) {
34527c478bd9Sstevel@tonic-gate data_in(P_SKIP);
34537c478bd9Sstevel@tonic-gate return;
34547c478bd9Sstevel@tonic-gate }
34557c478bd9Sstevel@tonic-gate
34567c478bd9Sstevel@tonic-gate if (Hdr_type == BAR) {
34577c478bd9Sstevel@tonic-gate bar_file_in();
34587c478bd9Sstevel@tonic-gate close_dirfd();
34597c478bd9Sstevel@tonic-gate return;
34607c478bd9Sstevel@tonic-gate }
34617c478bd9Sstevel@tonic-gate
34627c478bd9Sstevel@tonic-gate /*
34637c478bd9Sstevel@tonic-gate * For archives in USTAR format, the files are extracted according
34647c478bd9Sstevel@tonic-gate * to the typeflag.
34657c478bd9Sstevel@tonic-gate */
34667c478bd9Sstevel@tonic-gate if (Hdr_type == USTAR || Hdr_type == TAR) {
34677c478bd9Sstevel@tonic-gate typeflag = Thdr_p->tbuf.t_typeflag;
34687c478bd9Sstevel@tonic-gate if (G_p->g_nlink == 1) { /* hard link */
34697c478bd9Sstevel@tonic-gate if (proc_file != F_SKIP) {
34707c478bd9Sstevel@tonic-gate int i;
34717c478bd9Sstevel@tonic-gate char lname[NAMSIZ+1];
34727c478bd9Sstevel@tonic-gate (void) memset(lname, '\0', sizeof (lname));
34737c478bd9Sstevel@tonic-gate
34747c478bd9Sstevel@tonic-gate (void) strncpy(lname, Thdr_p->tbuf.t_linkname,
34757c478bd9Sstevel@tonic-gate NAMSIZ);
34767c478bd9Sstevel@tonic-gate for (i = 0; i <= NAMSIZ && lname[i] != 0; i++)
34777c478bd9Sstevel@tonic-gate ;
34787c478bd9Sstevel@tonic-gate
34797c478bd9Sstevel@tonic-gate lname[i] = 0;
34807c478bd9Sstevel@tonic-gate (void) creat_lnk(G_p->g_dirfd,
34817c478bd9Sstevel@tonic-gate &lname[0], G_p->g_nam_p);
34827c478bd9Sstevel@tonic-gate }
34837c478bd9Sstevel@tonic-gate close_dirfd();
34847c478bd9Sstevel@tonic-gate return;
34857c478bd9Sstevel@tonic-gate }
34867c478bd9Sstevel@tonic-gate if (typeflag == '3' || typeflag == '4' || typeflag == '5' ||
34877c478bd9Sstevel@tonic-gate typeflag == '6') {
34887c478bd9Sstevel@tonic-gate if (proc_file != F_SKIP &&
34897c478bd9Sstevel@tonic-gate creat_spec(G_p->g_dirfd) > 0) {
3490ced83f9bSceastha VERBOSE((Args & (OCv | OCV)),
3491ced83f9bSceastha (G_p->g_attrparent_p == NULL) ?
3492ced83f9bSceastha G_p->g_nam_p : G_p->g_attrpath_p);
34937c478bd9Sstevel@tonic-gate }
34947c478bd9Sstevel@tonic-gate close_dirfd();
34957c478bd9Sstevel@tonic-gate return;
34967c478bd9Sstevel@tonic-gate } else if (Adir || Aspec) {
34977c478bd9Sstevel@tonic-gate if ((proc_file == F_SKIP) ||
34987c478bd9Sstevel@tonic-gate (Ofile = openout(G_p->g_dirfd)) < 0) {
34997c478bd9Sstevel@tonic-gate data_in(P_SKIP);
35007c478bd9Sstevel@tonic-gate } else {
35017c478bd9Sstevel@tonic-gate data_in(P_PROC);
35027c478bd9Sstevel@tonic-gate }
35037c478bd9Sstevel@tonic-gate close_dirfd();
35047c478bd9Sstevel@tonic-gate return;
35057c478bd9Sstevel@tonic-gate }
35067c478bd9Sstevel@tonic-gate }
35077c478bd9Sstevel@tonic-gate
35087c478bd9Sstevel@tonic-gate if (Adir) {
35097c478bd9Sstevel@tonic-gate if (proc_file != F_SKIP && creat_spec(G_p->g_dirfd) > 0) {
35107c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), G_p->g_nam_p);
35117c478bd9Sstevel@tonic-gate }
35127c478bd9Sstevel@tonic-gate close_dirfd();
35137c478bd9Sstevel@tonic-gate if (Onecopy == 1) {
35147c478bd9Sstevel@tonic-gate VERBOSE((Args & OCt), G_p->g_nam_p);
35157c478bd9Sstevel@tonic-gate }
35167c478bd9Sstevel@tonic-gate return;
35177c478bd9Sstevel@tonic-gate }
35187c478bd9Sstevel@tonic-gate if (G_p->g_nlink == 1 || (Hdr_type == TAR ||
35197c478bd9Sstevel@tonic-gate Hdr_type == USTAR)) {
35207c478bd9Sstevel@tonic-gate if (Aspec) {
35217c478bd9Sstevel@tonic-gate if (proc_file != F_SKIP && creat_spec(G_p->g_dirfd) > 0)
35227c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), G_p->g_nam_p);
35237c478bd9Sstevel@tonic-gate } else {
35247c478bd9Sstevel@tonic-gate if ((proc_file == F_SKIP) ||
35257c478bd9Sstevel@tonic-gate (Ofile = openout(G_p->g_dirfd)) < 0) {
35267c478bd9Sstevel@tonic-gate data_in(P_SKIP);
35277c478bd9Sstevel@tonic-gate } else {
35287c478bd9Sstevel@tonic-gate data_in(P_PROC);
35297c478bd9Sstevel@tonic-gate }
35307c478bd9Sstevel@tonic-gate }
35317c478bd9Sstevel@tonic-gate close_dirfd();
35327c478bd9Sstevel@tonic-gate return;
35337c478bd9Sstevel@tonic-gate }
35347c478bd9Sstevel@tonic-gate close_dirfd();
35357c478bd9Sstevel@tonic-gate
35367c478bd9Sstevel@tonic-gate tl_p = add_lnk(&ttl_p);
35377c478bd9Sstevel@tonic-gate l_p = ttl_p;
35387c478bd9Sstevel@tonic-gate if (l_p->L_cnt == l_p->L_gen.g_nlink)
35397c478bd9Sstevel@tonic-gate cleanup = 1;
3540ced83f9bSceastha if (!Onecopy || G_p->g_attrnam_p != NULL) {
35417c478bd9Sstevel@tonic-gate lnkem = (tl_p != l_p) ? 1 : 0;
35427c478bd9Sstevel@tonic-gate G_p = &tl_p->L_gen;
35437c478bd9Sstevel@tonic-gate if (proc_file == F_SKIP) {
35447c478bd9Sstevel@tonic-gate data_in(P_SKIP);
35457c478bd9Sstevel@tonic-gate } else {
35467c478bd9Sstevel@tonic-gate if (open_dirfd() != 0)
35477c478bd9Sstevel@tonic-gate return;
35487c478bd9Sstevel@tonic-gate if (!lnkem) {
35497c478bd9Sstevel@tonic-gate if (Aspec) {
35507c478bd9Sstevel@tonic-gate if (creat_spec(G_p->g_dirfd) > 0)
35517c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)),
35527c478bd9Sstevel@tonic-gate G_p->g_nam_p);
35537c478bd9Sstevel@tonic-gate } else if ((Ofile =
35547c478bd9Sstevel@tonic-gate openout(G_p->g_dirfd)) < 0) {
35557c478bd9Sstevel@tonic-gate data_in(P_SKIP);
35567c478bd9Sstevel@tonic-gate close_dirfd();
35577c478bd9Sstevel@tonic-gate reclaim(l_p);
35587c478bd9Sstevel@tonic-gate } else {
35597c478bd9Sstevel@tonic-gate data_in(P_PROC);
35607c478bd9Sstevel@tonic-gate close_dirfd();
35617c478bd9Sstevel@tonic-gate }
35627c478bd9Sstevel@tonic-gate } else {
35637c478bd9Sstevel@tonic-gate /*
35647c478bd9Sstevel@tonic-gate * Are we linking an attribute?
35657c478bd9Sstevel@tonic-gate */
35667c478bd9Sstevel@tonic-gate cwd = -1;
3567ced83f9bSceastha if (l_p->L_gen.g_attrnam_p != NULL) {
35687c478bd9Sstevel@tonic-gate (void) strcpy(Lnkend_p,
35697c478bd9Sstevel@tonic-gate l_p->L_gen.g_attrnam_p);
35707c478bd9Sstevel@tonic-gate (void) strcpy(Full_p,
35717c478bd9Sstevel@tonic-gate tl_p->L_gen.g_attrnam_p);
35727c478bd9Sstevel@tonic-gate cwd = save_cwd();
35737c478bd9Sstevel@tonic-gate (void) fchdir(G_p->g_dirfd);
35747c478bd9Sstevel@tonic-gate } else {
35757c478bd9Sstevel@tonic-gate (void) strcpy(Lnkend_p,
35767c478bd9Sstevel@tonic-gate l_p->L_gen.g_nam_p);
35777c478bd9Sstevel@tonic-gate (void) strcpy(Full_p,
35787c478bd9Sstevel@tonic-gate tl_p->L_gen.g_nam_p);
35797c478bd9Sstevel@tonic-gate }
35807c478bd9Sstevel@tonic-gate (void) creat_lnk(G_p->g_dirfd,
35817c478bd9Sstevel@tonic-gate Lnkend_p, Full_p);
35827c478bd9Sstevel@tonic-gate data_in(P_SKIP);
35837c478bd9Sstevel@tonic-gate close_dirfd();
3584ced83f9bSceastha l_p->L_lnk_p = NULL;
35857c478bd9Sstevel@tonic-gate free(tl_p->L_gen.g_nam_p);
35867c478bd9Sstevel@tonic-gate free(tl_p);
35877c478bd9Sstevel@tonic-gate if (cwd != -1)
35887c478bd9Sstevel@tonic-gate rest_cwd(cwd);
35897c478bd9Sstevel@tonic-gate }
35907c478bd9Sstevel@tonic-gate }
35917c478bd9Sstevel@tonic-gate } else { /* Onecopy */
35927c478bd9Sstevel@tonic-gate if (tl_p->L_gen.g_filesz)
35937c478bd9Sstevel@tonic-gate cleanup = 1;
35947c478bd9Sstevel@tonic-gate if (!cleanup) {
35957c478bd9Sstevel@tonic-gate close_dirfd();
35967c478bd9Sstevel@tonic-gate return; /* don't do anything yet */
35977c478bd9Sstevel@tonic-gate }
35987c478bd9Sstevel@tonic-gate tl_p = l_p;
35997c478bd9Sstevel@tonic-gate /*
36007c478bd9Sstevel@tonic-gate * ckname will clear aclchar. We need to keep aclchar for
36017c478bd9Sstevel@tonic-gate * all links.
36027c478bd9Sstevel@tonic-gate */
36037c478bd9Sstevel@tonic-gate savacl = aclchar;
3604ced83f9bSceastha while (tl_p != NULL) {
36057c478bd9Sstevel@tonic-gate G_p = &tl_p->L_gen;
36067c478bd9Sstevel@tonic-gate aclchar = savacl;
36077c478bd9Sstevel@tonic-gate if ((proc_file = ckname(1)) != F_SKIP) {
36087c478bd9Sstevel@tonic-gate if (open_dirfd() != 0) {
36097c478bd9Sstevel@tonic-gate return;
36107c478bd9Sstevel@tonic-gate }
36117c478bd9Sstevel@tonic-gate if (l_p->L_data) {
36127c478bd9Sstevel@tonic-gate (void) creat_lnk(G_p->g_dirfd,
36137c478bd9Sstevel@tonic-gate l_p->L_gen.g_nam_p,
36147c478bd9Sstevel@tonic-gate G_p->g_nam_p);
36157c478bd9Sstevel@tonic-gate } else if (Aspec) {
36167c478bd9Sstevel@tonic-gate (void) creat_spec(G_p->g_dirfd);
36177c478bd9Sstevel@tonic-gate l_p->L_data = 1;
36187c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)),
36197c478bd9Sstevel@tonic-gate G_p->g_nam_p);
36207c478bd9Sstevel@tonic-gate } else if ((Ofile =
36217c478bd9Sstevel@tonic-gate openout(G_p->g_dirfd)) < 0) {
36227c478bd9Sstevel@tonic-gate proc_file = F_SKIP;
36237c478bd9Sstevel@tonic-gate } else {
36247c478bd9Sstevel@tonic-gate data_in(P_PROC);
36257c478bd9Sstevel@tonic-gate l_p->L_data = 1;
36267c478bd9Sstevel@tonic-gate }
36277c478bd9Sstevel@tonic-gate } /* (proc_file = ckname(1)) != F_SKIP */
36287c478bd9Sstevel@tonic-gate
36297c478bd9Sstevel@tonic-gate tl_p = tl_p->L_lnk_p;
36307c478bd9Sstevel@tonic-gate
36317c478bd9Sstevel@tonic-gate close_dirfd();
36327c478bd9Sstevel@tonic-gate
36337c478bd9Sstevel@tonic-gate if (proc_file == F_SKIP && !cleanup) {
36347c478bd9Sstevel@tonic-gate tl_p->L_nxt_p = l_p->L_nxt_p;
36357c478bd9Sstevel@tonic-gate tl_p->L_bck_p = l_p->L_bck_p;
36367c478bd9Sstevel@tonic-gate l_p->L_bck_p->L_nxt_p = tl_p;
36377c478bd9Sstevel@tonic-gate l_p->L_nxt_p->L_bck_p = tl_p;
36387c478bd9Sstevel@tonic-gate free(l_p->L_gen.g_nam_p);
36397c478bd9Sstevel@tonic-gate free(l_p);
36407c478bd9Sstevel@tonic-gate }
3641ced83f9bSceastha } /* tl_p->L_lnk_p != NULL */
36427c478bd9Sstevel@tonic-gate if (l_p->L_data == 0) {
36437c478bd9Sstevel@tonic-gate data_in(P_SKIP);
36447c478bd9Sstevel@tonic-gate }
36457c478bd9Sstevel@tonic-gate }
36467c478bd9Sstevel@tonic-gate if (cleanup) {
36477c478bd9Sstevel@tonic-gate reclaim(l_p);
36487c478bd9Sstevel@tonic-gate }
36497c478bd9Sstevel@tonic-gate }
36507c478bd9Sstevel@tonic-gate
36517c478bd9Sstevel@tonic-gate /*
36527c478bd9Sstevel@tonic-gate * file_out: If the current file is not a special file (!Aspec) and it
36537c478bd9Sstevel@tonic-gate * is identical to the archive, skip it (do not archive the archive if it
36547c478bd9Sstevel@tonic-gate * is a regular file). If creating a TARTYP (TAR or USTAR) archive, the first
36557c478bd9Sstevel@tonic-gate * time a link to a file is encountered, write the header and file out normally.
36567c478bd9Sstevel@tonic-gate * Subsequent links to this file put this file name in their t_linkname field.
36577c478bd9Sstevel@tonic-gate * Otherwise, links are handled in one of two ways, for the old headers
36587c478bd9Sstevel@tonic-gate * (i.e. binary and -c), linked files are written out as they are encountered.
36597c478bd9Sstevel@tonic-gate * For the new headers (ASC and CRC), links are saved up until all the links
36607c478bd9Sstevel@tonic-gate * to each file are found. For a file with n links, write n - 1 headers with
36617c478bd9Sstevel@tonic-gate * g_filesz set to 0, write the final (nth) header with the correct g_filesz
36627c478bd9Sstevel@tonic-gate * value and write the data for the file to the archive.
36637c478bd9Sstevel@tonic-gate */
36647c478bd9Sstevel@tonic-gate static
36657c478bd9Sstevel@tonic-gate int
file_out(void)36667c478bd9Sstevel@tonic-gate file_out(void)
36677c478bd9Sstevel@tonic-gate {
36687c478bd9Sstevel@tonic-gate struct Lnk *l_p, *tl_p;
36697c478bd9Sstevel@tonic-gate int cleanup = 0;
36707c478bd9Sstevel@tonic-gate struct Lnk *ttl_p;
36717c478bd9Sstevel@tonic-gate
36727c478bd9Sstevel@tonic-gate G_p = &Gen;
36737c478bd9Sstevel@tonic-gate if (!Aspec && IDENT(SrcSt, ArchSt))
36747c478bd9Sstevel@tonic-gate return (1); /* do not archive the archive if it's a reg file */
36755fbb8099SNobutomo Nakano /*
36765fbb8099SNobutomo Nakano * If compressing sparse files, wait until the compressed file size
36775fbb8099SNobutomo Nakano * is known to check if file size is too big.
36785fbb8099SNobutomo Nakano */
36795fbb8099SNobutomo Nakano if (Compress_sparse == 0 && G_p->g_filesz > Max_offset) {
36805fbb8099SNobutomo Nakano msg(ERR, "%s%s%s: too large to archive in current mode",
36817c478bd9Sstevel@tonic-gate G_p->g_nam_p,
3682ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : G_p->g_rw_sysattr ?
3683ced83f9bSceastha gettext(" System Attribute ") : gettext(" Attribute "),
3684ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
3685ced83f9bSceastha ((G_p->g_attrparent_p == NULL) ? G_p->g_attrnam_p:
3686ced83f9bSceastha G_p->g_attrpath_p));
36877c478bd9Sstevel@tonic-gate return (1); /* do not archive if it's too big */
36887c478bd9Sstevel@tonic-gate }
36897c478bd9Sstevel@tonic-gate if (Hdr_type == TAR || Hdr_type == USTAR) { /* TAR and USTAR */
36907c478bd9Sstevel@tonic-gate if (Adir) {
3691ced83f9bSceastha if (Gen.g_attrnam_p != NULL) {
36927c478bd9Sstevel@tonic-gate write_xattr_hdr();
36937c478bd9Sstevel@tonic-gate }
36947c478bd9Sstevel@tonic-gate write_hdr(ARCHIVE_NORMAL, 0);
36957c478bd9Sstevel@tonic-gate return (0);
36967c478bd9Sstevel@tonic-gate }
36977c478bd9Sstevel@tonic-gate if (G_p->g_nlink == 1) {
36987c478bd9Sstevel@tonic-gate data_out();
36997c478bd9Sstevel@tonic-gate return (0);
37007c478bd9Sstevel@tonic-gate }
37017c478bd9Sstevel@tonic-gate tl_p = add_lnk(&ttl_p);
37027c478bd9Sstevel@tonic-gate l_p = ttl_p;
37037c478bd9Sstevel@tonic-gate if (tl_p == l_p) { /* first link to this file encountered */
37047c478bd9Sstevel@tonic-gate data_out();
37057c478bd9Sstevel@tonic-gate return (0);
37067c478bd9Sstevel@tonic-gate }
37077c478bd9Sstevel@tonic-gate (void) strncpy(T_lname, l_p->L_gen.g_nam_p,
37087c478bd9Sstevel@tonic-gate l_p->L_gen.g_namesz);
37097c478bd9Sstevel@tonic-gate
37107c478bd9Sstevel@tonic-gate /*
37117c478bd9Sstevel@tonic-gate * check if linkname is greater than 100 characters
37127c478bd9Sstevel@tonic-gate */
37137c478bd9Sstevel@tonic-gate if (strlen(T_lname) > NAMSIZ) {
37147c478bd9Sstevel@tonic-gate msg(EPOST, "cpio: %s: linkname %s is greater than %d",
37157c478bd9Sstevel@tonic-gate G_p->g_nam_p, T_lname, NAMSIZ);
37167c478bd9Sstevel@tonic-gate return (1);
37177c478bd9Sstevel@tonic-gate }
37187c478bd9Sstevel@tonic-gate
37197c478bd9Sstevel@tonic-gate write_hdr(ARCHIVE_NORMAL, (off_t)0);
37207c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), tl_p->L_gen.g_nam_p);
37217c478bd9Sstevel@tonic-gate
37227c478bd9Sstevel@tonic-gate /* find the lnk entry in sublist, unlink it, and free it */
37237c478bd9Sstevel@tonic-gate for (; ttl_p->L_lnk_p != NULL;
37247c478bd9Sstevel@tonic-gate ttl_p = ttl_p->L_lnk_p) {
37257c478bd9Sstevel@tonic-gate if (ttl_p->L_lnk_p == tl_p) {
37267c478bd9Sstevel@tonic-gate ttl_p->L_lnk_p = tl_p->L_lnk_p;
37277c478bd9Sstevel@tonic-gate free(tl_p->L_gen.g_nam_p);
37287c478bd9Sstevel@tonic-gate free(tl_p);
37297c478bd9Sstevel@tonic-gate break;
37307c478bd9Sstevel@tonic-gate }
37317c478bd9Sstevel@tonic-gate }
37327c478bd9Sstevel@tonic-gate
37337c478bd9Sstevel@tonic-gate return (0);
37347c478bd9Sstevel@tonic-gate }
37357c478bd9Sstevel@tonic-gate if (Adir) {
37367c478bd9Sstevel@tonic-gate /*
37377c478bd9Sstevel@tonic-gate * ACL has been retrieved in getname().
37387c478bd9Sstevel@tonic-gate */
37397c478bd9Sstevel@tonic-gate if (Pflag) {
37407c478bd9Sstevel@tonic-gate char *secinfo = NULL;
37417c478bd9Sstevel@tonic-gate int len = 0;
37427c478bd9Sstevel@tonic-gate
37437c478bd9Sstevel@tonic-gate /* append security attributes */
3744fa9e4066Sahrens if ((append_secattr(&secinfo, &len, aclp)) == -1)
37457c478bd9Sstevel@tonic-gate msg(ERR, "can create security information");
37467c478bd9Sstevel@tonic-gate
37477c478bd9Sstevel@tonic-gate /* call append_secattr() if more than one */
37487c478bd9Sstevel@tonic-gate
37497c478bd9Sstevel@tonic-gate if (len > 0) {
37507c478bd9Sstevel@tonic-gate /* write ancillary */
37515fbb8099SNobutomo Nakano write_hdr(ARCHIVE_ACL, (off_t)len);
37525fbb8099SNobutomo Nakano write_ancillary(secinfo, len, B_TRUE);
37537c478bd9Sstevel@tonic-gate }
37547c478bd9Sstevel@tonic-gate }
37557c478bd9Sstevel@tonic-gate
3756ced83f9bSceastha if (Gen.g_attrnam_p != NULL) {
37577c478bd9Sstevel@tonic-gate write_xattr_hdr();
37587c478bd9Sstevel@tonic-gate }
37597c478bd9Sstevel@tonic-gate write_hdr(ARCHIVE_NORMAL, (off_t)0);
37607c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), G_p->g_nam_p);
37617c478bd9Sstevel@tonic-gate return (0);
37627c478bd9Sstevel@tonic-gate }
37637c478bd9Sstevel@tonic-gate if (G_p->g_nlink == 1) {
37647c478bd9Sstevel@tonic-gate data_out();
37657c478bd9Sstevel@tonic-gate return (0);
37667c478bd9Sstevel@tonic-gate } else {
37677c478bd9Sstevel@tonic-gate tl_p = add_lnk(&ttl_p);
37687c478bd9Sstevel@tonic-gate l_p = ttl_p;
37697c478bd9Sstevel@tonic-gate
37707c478bd9Sstevel@tonic-gate if (l_p->L_cnt == l_p->L_gen.g_nlink)
37717c478bd9Sstevel@tonic-gate cleanup = 1;
3772ced83f9bSceastha else if (Onecopy && G_p->g_attrnam_p == NULL) {
37737c478bd9Sstevel@tonic-gate return (0); /* don't process data yet */
37747c478bd9Sstevel@tonic-gate }
37757c478bd9Sstevel@tonic-gate }
3776ced83f9bSceastha if (Onecopy && G_p->g_attrnam_p == NULL) {
37777c478bd9Sstevel@tonic-gate tl_p = l_p;
3778ced83f9bSceastha while (tl_p->L_lnk_p != NULL) {
37797c478bd9Sstevel@tonic-gate G_p = &tl_p->L_gen;
37807c478bd9Sstevel@tonic-gate G_p->g_filesz = (off_t)0;
37817c478bd9Sstevel@tonic-gate /* one link with the acl is sufficient */
37827c478bd9Sstevel@tonic-gate write_hdr(ARCHIVE_NORMAL, (off_t)0);
37837c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), G_p->g_nam_p);
37847c478bd9Sstevel@tonic-gate tl_p = tl_p->L_lnk_p;
37857c478bd9Sstevel@tonic-gate }
37867c478bd9Sstevel@tonic-gate G_p = &tl_p->L_gen;
37877c478bd9Sstevel@tonic-gate if (open_dirfd() != 0)
37887c478bd9Sstevel@tonic-gate return (1);
37897c478bd9Sstevel@tonic-gate }
37907c478bd9Sstevel@tonic-gate /* old style: has acl and data for every link */
37917c478bd9Sstevel@tonic-gate data_out();
37927c478bd9Sstevel@tonic-gate if (cleanup)
37937c478bd9Sstevel@tonic-gate reclaim(l_p);
37947c478bd9Sstevel@tonic-gate return (0);
37957c478bd9Sstevel@tonic-gate }
37967c478bd9Sstevel@tonic-gate
37977c478bd9Sstevel@tonic-gate /*
3798ced83f9bSceastha * Verify the underlying file system supports the attribute type.
3799ced83f9bSceastha * Only archive extended attribute files when '-@' was specified.
3800ced83f9bSceastha * Only archive system extended attribute files if '-/' was specified.
3801ced83f9bSceastha */
3802ced83f9bSceastha #if defined(O_XATTR)
3803ced83f9bSceastha static attr_status_t
verify_attr_support(char * filename,int attrflg,arc_action_t actflag,int * ext_attrflg)3804ced83f9bSceastha verify_attr_support(char *filename, int attrflg, arc_action_t actflag,
3805ced83f9bSceastha int *ext_attrflg)
3806ced83f9bSceastha {
3807ced83f9bSceastha /*
3808ced83f9bSceastha * Verify extended attributes are supported/exist. We only
3809ced83f9bSceastha * need to check if we are processing a base file, not an
3810ced83f9bSceastha * extended attribute.
3811ced83f9bSceastha */
3812ced83f9bSceastha if (attrflg) {
3813ced83f9bSceastha *ext_attrflg = (pathconf(filename, (actflag == ARC_CREATE) ?
3814ced83f9bSceastha _PC_XATTR_EXISTS : _PC_XATTR_ENABLED) == 1);
3815ced83f9bSceastha }
3816ced83f9bSceastha if (Atflag) {
3817ced83f9bSceastha #if defined(_PC_SATTR_ENABLED)
3818ced83f9bSceastha if (!*ext_attrflg) {
3819ced83f9bSceastha if (SysAtflag) {
3820ced83f9bSceastha /* Verify system attributes are supported */
3821ced83f9bSceastha if (sysattr_support(filename,
3822ced83f9bSceastha (actflag == ARC_CREATE) ?_PC_SATTR_EXISTS :
3823ced83f9bSceastha _PC_SATTR_ENABLED) != 1) {
3824ced83f9bSceastha return (ATTR_SATTR_ERR);
3825ced83f9bSceastha }
3826ced83f9bSceastha } else
3827ced83f9bSceastha return (ATTR_XATTR_ERR);
3828ced83f9bSceastha #else
3829ced83f9bSceastha return (ATTR_XATTR_ERR);
3830ced83f9bSceastha #endif /* _PC_SATTR_ENABLED */
3831ced83f9bSceastha }
3832ced83f9bSceastha
3833ced83f9bSceastha #if defined(_PC_SATTR_ENABLED)
3834ced83f9bSceastha } else if (SysAtflag) {
3835ced83f9bSceastha /* Verify system attributes are supported */
3836ced83f9bSceastha if (sysattr_support(filename, (actflag == ARC_CREATE) ?
3837ced83f9bSceastha _PC_SATTR_EXISTS : _PC_SATTR_ENABLED) != 1) {
3838ced83f9bSceastha return (ATTR_SATTR_ERR);
3839ced83f9bSceastha }
3840ced83f9bSceastha #endif /* _PC_SATTR_ENABLED */
3841ced83f9bSceastha } else {
3842ced83f9bSceastha return (ATTR_SKIP);
3843ced83f9bSceastha }
3844ced83f9bSceastha
3845ced83f9bSceastha return (ATTR_OK);
3846ced83f9bSceastha }
3847ced83f9bSceastha #endif
3848ced83f9bSceastha
3849ced83f9bSceastha #if defined(O_XATTR)
3850ced83f9bSceastha /*
3851ced83f9bSceastha * Verify the attribute, attrname, is an attribute we want to restore.
3852ced83f9bSceastha * Never restore read-only system attribute files. Only restore read-write
3853ced83f9bSceastha * system attributes files when -/ was specified, and only traverse into
3854ced83f9bSceastha * the 2nd level attribute directory containing only system attributes if
3855ced83f9bSceastha * -@ was specified. This keeps us from archiving
3856ced83f9bSceastha * <attribute name>/<read-write system attribute file>
3857ced83f9bSceastha * when -/ was specified without -@.
3858ced83f9bSceastha *
3859ced83f9bSceastha * attrname - attribute file name
3860ced83f9bSceastha * attrparent - attribute's parent name within the base file's
3861ced83f9bSceastha * attribute digrectory hierarchy
3862ced83f9bSceastha * arc_rwsysattr - flag that indicates that read-write system attribute
3863ced83f9bSceastha * file should be archived as it contains other than
3864ced83f9bSceastha * the default system attributes.
3865ced83f9bSceastha * rw_sysattr - on return, flag will indicate if attrname is a
3866ced83f9bSceastha * read-write system attribute file.
3867ced83f9bSceastha */
3868ced83f9bSceastha static attr_status_t
verify_attr(char * attrname,char * attrparent,int arc_rwsysattr,int * rw_sysattr)3869ced83f9bSceastha verify_attr(char *attrname, char *attrparent, int arc_rwsysattr,
3870ced83f9bSceastha int *rw_sysattr)
3871ced83f9bSceastha {
3872ced83f9bSceastha #if defined(_PC_SATTR_ENABLED)
3873ced83f9bSceastha int attr_supported;
3874ced83f9bSceastha
3875ced83f9bSceastha /* Never restore read-only system attribute files */
3876ced83f9bSceastha if ((attr_supported = sysattr_type(attrname)) == _RO_SATTR) {
3877ced83f9bSceastha *rw_sysattr = 0;
3878ced83f9bSceastha return (ATTR_SKIP);
3879ced83f9bSceastha } else {
3880ced83f9bSceastha *rw_sysattr = (attr_supported == _RW_SATTR);
3881ced83f9bSceastha }
3882ced83f9bSceastha
3883ced83f9bSceastha /*
3884ced83f9bSceastha * Don't archive a read-write system attribute file if
3885ced83f9bSceastha * it contains only the default system attributes.
3886ced83f9bSceastha */
3887ced83f9bSceastha if (*rw_sysattr && !arc_rwsysattr) {
3888ced83f9bSceastha return (ATTR_SKIP);
3889ced83f9bSceastha }
3890ced83f9bSceastha
3891ced83f9bSceastha #else
3892ced83f9bSceastha /* Never restore read-only system attribute files */
3893ced83f9bSceastha if ((*rw_sysattr = is_sysattr(attrname)) == 1) {
3894ced83f9bSceastha return (ATTR_SKIP);
3895ced83f9bSceastha }
3896ced83f9bSceastha #endif /* _PC_SATTR_ENABLED */
3897ced83f9bSceastha
3898ced83f9bSceastha /*
3899ced83f9bSceastha * Only restore read-write system attribute files
3900ced83f9bSceastha * when -/ was specified. Only restore extended
3901ced83f9bSceastha * attributes when -@ was specified.
3902ced83f9bSceastha */
3903ced83f9bSceastha if (Atflag) {
3904ced83f9bSceastha if (!SysAtflag) {
3905ced83f9bSceastha /*
3906ced83f9bSceastha * Only archive/restore the hidden directory "." if
3907ced83f9bSceastha * we're processing the top level hidden attribute
3908ced83f9bSceastha * directory. We don't want to process the
3909ced83f9bSceastha * hidden attribute directory of the attribute
3910ced83f9bSceastha * directory that contains only extended system
3911ced83f9bSceastha * attributes.
3912ced83f9bSceastha */
3913ced83f9bSceastha if (*rw_sysattr || (Hiddendir &&
3914ced83f9bSceastha (attrparent != NULL))) {
3915ced83f9bSceastha return (ATTR_SKIP);
3916ced83f9bSceastha }
3917ced83f9bSceastha }
3918ced83f9bSceastha } else if (SysAtflag) {
3919ced83f9bSceastha /*
3920ced83f9bSceastha * Only archive/restore read-write extended system attribute
3921ced83f9bSceastha * files of the base file.
3922ced83f9bSceastha */
3923ced83f9bSceastha if (!*rw_sysattr || (attrparent != NULL)) {
3924ced83f9bSceastha return (ATTR_SKIP);
3925ced83f9bSceastha }
3926ced83f9bSceastha } else {
3927ced83f9bSceastha return (ATTR_SKIP);
3928ced83f9bSceastha }
3929ced83f9bSceastha
3930ced83f9bSceastha return (ATTR_OK);
3931ced83f9bSceastha }
3932ced83f9bSceastha #endif
3933ced83f9bSceastha
3934ced83f9bSceastha #if defined(O_XATTR)
3935ced83f9bSceastha static int
retry_open_attr(int pdirfd,int cwd,char * fullname,char * pattr,char * name,int oflag,mode_t mode)3936ced83f9bSceastha retry_open_attr(int pdirfd, int cwd, char *fullname, char *pattr, char *name,
3937ced83f9bSceastha int oflag, mode_t mode)
3938ced83f9bSceastha {
3939ced83f9bSceastha int dirfd;
3940ced83f9bSceastha int ofilefd = -1;
3941ced83f9bSceastha struct timeval times[2];
3942ced83f9bSceastha mode_t newmode;
3943ced83f9bSceastha struct stat parentstat;
3944ced83f9bSceastha acl_t *aclp = NULL;
3945ced83f9bSceastha int error;
3946ced83f9bSceastha
3947ced83f9bSceastha /*
3948ced83f9bSceastha * We couldn't get to attrdir. See if its
3949ced83f9bSceastha * just a mode problem on the parent file.
3950ced83f9bSceastha * for example: a mode such as r-xr--r--
3951ced83f9bSceastha * on a ufs file system without extended
3952ced83f9bSceastha * system attribute support won't let us
3953ced83f9bSceastha * create an attribute dir if it doesn't
3954ced83f9bSceastha * already exist, and on a ufs file system
3955ced83f9bSceastha * with extended system attribute support
3956ced83f9bSceastha * won't let us open the attribute for
3957ced83f9bSceastha * write.
3958ced83f9bSceastha *
3959ced83f9bSceastha * If file has a non-trivial ACL, then save it
3960ced83f9bSceastha * off so that we can place it back on after doing
3961ced83f9bSceastha * chmod's.
3962ced83f9bSceastha */
3963ced83f9bSceastha if ((dirfd = openat(cwd, (pattr == NULL) ? fullname : pattr,
3964ced83f9bSceastha O_RDONLY)) == -1) {
3965ced83f9bSceastha return (-1);
3966ced83f9bSceastha }
3967ced83f9bSceastha if (fstat(dirfd, &parentstat) == -1) {
3968ced83f9bSceastha msg(ERRN, "Cannot stat %sfile %s",
3969ced83f9bSceastha (pdirfd == -1) ? "" : gettext("parent of "),
3970ced83f9bSceastha (pdirfd == -1) ? fullname : name);
3971ced83f9bSceastha (void) close(dirfd);
3972ced83f9bSceastha return (-1);
3973ced83f9bSceastha }
3974ced83f9bSceastha if ((error = facl_get(dirfd, ACL_NO_TRIVIAL, &aclp)) != 0) {
3975ced83f9bSceastha msg(ERRN, "Failed to retrieve ACL on %sfile %s",
3976ced83f9bSceastha (pdirfd == -1) ? "" : gettext("parent of "),
3977ced83f9bSceastha (pdirfd == -1) ? fullname : name);
3978ced83f9bSceastha (void) close(dirfd);
3979ced83f9bSceastha return (-1);
3980ced83f9bSceastha }
3981ced83f9bSceastha
3982ced83f9bSceastha newmode = S_IWUSR | parentstat.st_mode;
3983ced83f9bSceastha if (fchmod(dirfd, newmode) == -1) {
3984ced83f9bSceastha msg(ERRN, "Cannot change mode of %sfile %s to %o",
3985ced83f9bSceastha (pdirfd == -1) ? "" : gettext("parent of "),
3986ced83f9bSceastha (pdirfd == -1) ? fullname : name, newmode);
3987ced83f9bSceastha if (aclp)
3988ced83f9bSceastha acl_free(aclp);
3989ced83f9bSceastha (void) close(dirfd);
3990ced83f9bSceastha return (-1);
3991ced83f9bSceastha }
3992ced83f9bSceastha
3993ced83f9bSceastha
3994ced83f9bSceastha if (pdirfd == -1) {
3995ced83f9bSceastha /*
3996ced83f9bSceastha * We weren't able to create the attribute directory before.
3997ced83f9bSceastha * Now try again.
3998ced83f9bSceastha */
3999ced83f9bSceastha ofilefd = attropen(fullname, ".", oflag);
4000ced83f9bSceastha } else {
4001ced83f9bSceastha /*
4002ced83f9bSceastha * We weren't able to create open the attribute before.
4003ced83f9bSceastha * Now try again.
4004ced83f9bSceastha */
4005ced83f9bSceastha ofilefd = openat(pdirfd, name, oflag, mode);
4006ced83f9bSceastha }
4007ced83f9bSceastha
4008ced83f9bSceastha /*
4009ced83f9bSceastha * Put mode back to original
4010ced83f9bSceastha */
4011ced83f9bSceastha if (fchmod(dirfd, parentstat.st_mode) == -1) {
4012ced83f9bSceastha msg(ERRN, "Cannot restore permissions of %sfile %s to %o",
4013ced83f9bSceastha (pdirfd == -1) ? "" : gettext("parent of "),
4014ced83f9bSceastha (pdirfd == -1) ? fullname : name, newmode);
4015ced83f9bSceastha }
4016ced83f9bSceastha
4017ced83f9bSceastha if (aclp) {
4018ced83f9bSceastha error = facl_set(dirfd, aclp);
4019ced83f9bSceastha if (error) {
4020ced83f9bSceastha msg(ERRN, "failed to set acl entries on %sfile %s\n",
4021ced83f9bSceastha (pdirfd == -1) ? "" : gettext("parent of "),
4022ced83f9bSceastha (pdirfd == -1) ? fullname : name);
4023ced83f9bSceastha }
4024ced83f9bSceastha acl_free(aclp);
4025ced83f9bSceastha }
4026ced83f9bSceastha
4027ced83f9bSceastha /*
4028ced83f9bSceastha * Put back time stamps
4029ced83f9bSceastha */
4030ced83f9bSceastha
4031ced83f9bSceastha times[0].tv_sec = parentstat.st_atime;
4032ced83f9bSceastha times[0].tv_usec = 0;
4033ced83f9bSceastha times[1].tv_sec = parentstat.st_mtime;
4034ced83f9bSceastha times[1].tv_usec = 0;
4035ced83f9bSceastha
4036ced83f9bSceastha (void) futimesat(cwd, (pattr == NULL) ? fullname : pattr, times);
4037ced83f9bSceastha
4038ced83f9bSceastha (void) close(dirfd);
4039ced83f9bSceastha
4040ced83f9bSceastha return (ofilefd);
4041ced83f9bSceastha }
4042ced83f9bSceastha #endif
4043ced83f9bSceastha
4044ced83f9bSceastha #if defined(O_XATTR)
4045ced83f9bSceastha /*
4046ced83f9bSceastha * Recursively open attribute directories until the attribute directory
4047ced83f9bSceastha * containing the specified attribute, attrname, is opened.
4048ced83f9bSceastha *
4049ced83f9bSceastha * Currently, only 2 directory levels of attributes are supported, (i.e.,
4050ced83f9bSceastha * extended system attributes on extended attributes). The following are
4051ced83f9bSceastha * the possible input combinations:
4052ced83f9bSceastha * 1. Open the attribute directory of the base file (don't change
4053ced83f9bSceastha * into it).
4054ced83f9bSceastha * attr_parent = NULL
4055ced83f9bSceastha * attrname = '.'
4056ced83f9bSceastha * 2. Open the attribute directory of the base file and change into it.
4057ced83f9bSceastha * attr_parent = NULL
4058ced83f9bSceastha * attrname = <attr> | <sys_attr>
4059ced83f9bSceastha * 3. Open the attribute directory of the base file, change into it,
4060ced83f9bSceastha * then recursively call open_attr_dir() to open the attribute's
4061ced83f9bSceastha * parent directory (don't change into it).
4062ced83f9bSceastha * attr_parent = <attr>
4063ced83f9bSceastha * attrname = '.'
4064ced83f9bSceastha * 4. Open the attribute directory of the base file, change into it,
4065ced83f9bSceastha * then recursively call open_attr_dir() to open the attribute's
4066ced83f9bSceastha * parent directory and change into it.
4067ced83f9bSceastha * attr_parent = <attr>
4068ced83f9bSceastha * attrname = <attr> | <sys_attr>
4069ced83f9bSceastha *
4070ced83f9bSceastha * An attribute directory will be opened only if the underlying file system
4071ced83f9bSceastha * supports the attribute type, and if the command line specifications
4072ced83f9bSceastha * (f_extended_attr and f_sys_attr) enable the processing of the attribute
4073ced83f9bSceastha * type.
4074ced83f9bSceastha *
4075ced83f9bSceastha * On succesful return, attr_parentfd will be the file descriptor of the
4076ced83f9bSceastha * opened attribute directory. In addition, if the attribute is a read-write
4077ced83f9bSceastha * extended system attribute, rw_sysattr will be set to 1, otherwise
4078ced83f9bSceastha * it will be set to 0.
4079ced83f9bSceastha *
4080ced83f9bSceastha * Possible return values:
4081ced83f9bSceastha * ATTR_OK Successfully opened and, if needed, changed into the
4082ced83f9bSceastha * attribute directory containing attrname.
4083ced83f9bSceastha * ATTR_SKIP The command line specifications don't enable the
4084ced83f9bSceastha * processing of the attribute type.
4085ced83f9bSceastha * ATTR_CHDIR_ERR An error occurred while trying to change into an
4086ced83f9bSceastha * attribute directory.
4087ced83f9bSceastha * ATTR_OPEN_ERR An error occurred while trying to open an
4088ced83f9bSceastha * attribute directory.
4089ced83f9bSceastha * ATTR_XATTR_ERR The underlying file system doesn't support extended
4090ced83f9bSceastha * attributes.
4091ced83f9bSceastha * ATTR_SATTR_ERR The underlying file system doesn't support extended
4092ced83f9bSceastha * system attributes.
4093ced83f9bSceastha */
4094ced83f9bSceastha static int
open_attr_dir(char * attrname,char * dirp,int cwd,char * attr_parent,int * attr_parentfd,int * rw_sysattr)4095ced83f9bSceastha open_attr_dir(char *attrname, char *dirp, int cwd, char *attr_parent,
4096ced83f9bSceastha int *attr_parentfd, int *rw_sysattr)
4097ced83f9bSceastha {
4098ced83f9bSceastha attr_status_t rc;
4099ced83f9bSceastha int firsttime = (*attr_parentfd == -1);
4100ced83f9bSceastha int saveerrno;
4101ced83f9bSceastha int ext_attr;
4102ced83f9bSceastha
4103ced83f9bSceastha /*
4104ced83f9bSceastha * open_attr_dir() was recursively called (input combination number 4),
4105ced83f9bSceastha * close the previously opened file descriptor as we've already changed
4106ced83f9bSceastha * into it.
4107ced83f9bSceastha */
4108ced83f9bSceastha if (!firsttime) {
4109ced83f9bSceastha (void) close(*attr_parentfd);
4110ced83f9bSceastha *attr_parentfd = -1;
4111ced83f9bSceastha }
4112ced83f9bSceastha
4113ced83f9bSceastha /*
4114ced83f9bSceastha * Verify that the underlying file system supports the restoration
4115ced83f9bSceastha * of the attribute.
4116ced83f9bSceastha */
4117ced83f9bSceastha if ((rc = verify_attr_support(dirp, firsttime, ARC_RESTORE,
4118ced83f9bSceastha &ext_attr)) != ATTR_OK) {
4119ced83f9bSceastha return (rc);
4120ced83f9bSceastha }
4121ced83f9bSceastha
4122ced83f9bSceastha /* Open the base file's attribute directory */
4123ced83f9bSceastha if ((*attr_parentfd = attropen(dirp, ".", O_RDONLY)) == -1) {
4124ced83f9bSceastha /*
4125ced83f9bSceastha * Save the errno from the attropen so it can be reported
4126ced83f9bSceastha * if the retry of the attropen fails.
4127ced83f9bSceastha */
4128ced83f9bSceastha saveerrno = errno;
4129ced83f9bSceastha if ((*attr_parentfd = retry_open_attr(-1, cwd, dirp,
4130ced83f9bSceastha NULL, ".", O_RDONLY, 0)) == -1) {
4131ced83f9bSceastha (void) close(*attr_parentfd);
4132ced83f9bSceastha *attr_parentfd = -1;
4133ced83f9bSceastha errno = saveerrno;
4134ced83f9bSceastha return (ATTR_OPEN_ERR);
4135ced83f9bSceastha }
4136ced83f9bSceastha }
4137ced83f9bSceastha
4138ced83f9bSceastha /*
4139ced83f9bSceastha * Change into the parent attribute's directory unless we are
4140ced83f9bSceastha * processing the hidden attribute directory of the base file itself.
4141ced83f9bSceastha */
4142ced83f9bSceastha if ((Hiddendir == 0) || (firsttime && (attr_parent != NULL))) {
4143ced83f9bSceastha if (fchdir(*attr_parentfd) != 0) {
4144ced83f9bSceastha saveerrno = errno;
4145ced83f9bSceastha (void) close(*attr_parentfd);
4146ced83f9bSceastha *attr_parentfd = -1;
4147ced83f9bSceastha errno = saveerrno;
4148ced83f9bSceastha return (ATTR_CHDIR_ERR);
4149ced83f9bSceastha }
4150ced83f9bSceastha }
4151ced83f9bSceastha
4152ced83f9bSceastha /* Determine if the attribute should be processed */
4153ced83f9bSceastha if ((rc = verify_attr(attrname, attr_parent, 1,
4154ced83f9bSceastha rw_sysattr)) != ATTR_OK) {
4155ced83f9bSceastha saveerrno = errno;
4156ced83f9bSceastha (void) close(*attr_parentfd);
4157ced83f9bSceastha *attr_parentfd = -1;
4158ced83f9bSceastha errno = saveerrno;
4159ced83f9bSceastha return (rc);
4160ced83f9bSceastha }
4161ced83f9bSceastha
4162ced83f9bSceastha /*
4163ced83f9bSceastha * If the attribute is an extended system attribute of an attribute
4164ced83f9bSceastha * (i.e., <attr>/<sys_attr>), then recursively call open_attr_dir() to
4165ced83f9bSceastha * open the attribute directory of the parent attribute.
4166ced83f9bSceastha */
4167ced83f9bSceastha if (firsttime && (attr_parent != NULL)) {
4168ced83f9bSceastha return (open_attr_dir(attrname, attr_parent, *attr_parentfd,
4169ced83f9bSceastha attr_parent, attr_parentfd, rw_sysattr));
4170ced83f9bSceastha }
4171ced83f9bSceastha
4172ced83f9bSceastha return (ATTR_OK);
4173ced83f9bSceastha }
4174ced83f9bSceastha #endif
4175ced83f9bSceastha
4176ced83f9bSceastha /*
41777c478bd9Sstevel@tonic-gate * file_pass: If the -l option is set (link files when possible), and the
41787c478bd9Sstevel@tonic-gate * source and destination file systems are the same, link the source file
41797c478bd9Sstevel@tonic-gate * (G_p->g_nam_p) to the destination file (Fullnam) and return. If not a
41807c478bd9Sstevel@tonic-gate * linked file, transfer the data. Otherwise, the first link to a file
41817c478bd9Sstevel@tonic-gate * encountered is transferred normally and subsequent links are linked to it.
41827c478bd9Sstevel@tonic-gate */
41837c478bd9Sstevel@tonic-gate
41847c478bd9Sstevel@tonic-gate static int
file_pass(void)41857c478bd9Sstevel@tonic-gate file_pass(void)
41867c478bd9Sstevel@tonic-gate {
41877c478bd9Sstevel@tonic-gate struct Lnk *l_p, *tl_p;
41887c478bd9Sstevel@tonic-gate struct Lnk *ttl_p;
41897c478bd9Sstevel@tonic-gate char *save_name;
41907c478bd9Sstevel@tonic-gate int size;
41917c478bd9Sstevel@tonic-gate int cwd;
41927c478bd9Sstevel@tonic-gate char *lfrom, *lto;
41937c478bd9Sstevel@tonic-gate
41947c478bd9Sstevel@tonic-gate G_p = &Gen;
41957c478bd9Sstevel@tonic-gate
41967c478bd9Sstevel@tonic-gate if (Adir && !(Args & OCd)) {
41977c478bd9Sstevel@tonic-gate msg(ERR, "Use -d option to copy \"%s\"", G_p->g_nam_p);
41987c478bd9Sstevel@tonic-gate return (FILE_PASS_ERR);
41997c478bd9Sstevel@tonic-gate }
42007c478bd9Sstevel@tonic-gate
42017c478bd9Sstevel@tonic-gate save_name = G_p->g_nam_p;
42027c478bd9Sstevel@tonic-gate
42037c478bd9Sstevel@tonic-gate while (*(G_p->g_nam_p) == '/') {
42047c478bd9Sstevel@tonic-gate G_p->g_nam_p++;
42057c478bd9Sstevel@tonic-gate }
42067c478bd9Sstevel@tonic-gate
4207ced83f9bSceastha (void) strcpy(Full_p, (G_p->g_attrfnam_p == NULL) ?
42087c478bd9Sstevel@tonic-gate G_p->g_nam_p : G_p->g_attrfnam_p);
42097c478bd9Sstevel@tonic-gate
4210ced83f9bSceastha if (G_p->g_attrnam_p == NULL) {
42117c478bd9Sstevel@tonic-gate G_p->g_passdirfd = open_dir(Fullnam_p);
42127c478bd9Sstevel@tonic-gate
42137c478bd9Sstevel@tonic-gate if (G_p->g_passdirfd == -1) {
42147c478bd9Sstevel@tonic-gate msg(ERRN,
42157c478bd9Sstevel@tonic-gate "Cannot open/create \"%s\"", Fullnam_p);
42167c478bd9Sstevel@tonic-gate return (FILE_PASS_ERR);
42177c478bd9Sstevel@tonic-gate }
42187c478bd9Sstevel@tonic-gate } else {
4219ced83f9bSceastha int rw_sysattr;
42207c478bd9Sstevel@tonic-gate
4221ced83f9bSceastha /*
4222ced83f9bSceastha * Open the file's attribute directory.
4223ced83f9bSceastha * Change into the base file's starting directory then call
4224ced83f9bSceastha * open_attr_dir() to open the attribute directory of either
4225ced83f9bSceastha * the base file (if G_p->g_attrparent_p is NULL) or the
4226ced83f9bSceastha * attribute (if G_p->g_attrparent_p is set) of the base file.
4227ced83f9bSceastha */
42287c478bd9Sstevel@tonic-gate
4229ced83f9bSceastha G_p->g_passdirfd = -1;
4230ced83f9bSceastha (void) fchdir(G_p->g_baseparent_fd);
4231ced83f9bSceastha (void) open_attr_dir(G_p->g_attrnam_p, Fullnam_p,
4232ced83f9bSceastha G_p->g_baseparent_fd, (G_p->g_attrparent_p == NULL) ? NULL :
4233ced83f9bSceastha G_p->g_attrparent_p, &G_p->g_passdirfd, &rw_sysattr);
42347c478bd9Sstevel@tonic-gate if (G_p->g_passdirfd == -1) {
42357c478bd9Sstevel@tonic-gate msg(ERRN,
42367c478bd9Sstevel@tonic-gate "Cannot open attribute directory of "
4237ced83f9bSceastha "%s%s%sfile \"%s\"",
4238ced83f9bSceastha (G_p->g_attrparent_p == NULL) ? "" :
4239ced83f9bSceastha gettext("attribute \""),
4240ced83f9bSceastha (G_p->g_attrparent_p == NULL) ? "" :
4241ced83f9bSceastha G_p->g_attrparent_p,
4242ced83f9bSceastha (G_p->g_attrparent_p == NULL) ? "" :
4243ced83f9bSceastha gettext("\" of "), Fullnam_p);
42447c478bd9Sstevel@tonic-gate return (FILE_PASS_ERR);
42457c478bd9Sstevel@tonic-gate }
42467c478bd9Sstevel@tonic-gate }
42477c478bd9Sstevel@tonic-gate
42487c478bd9Sstevel@tonic-gate if (Args & OCl) {
42497c478bd9Sstevel@tonic-gate /* We are linking back to the source directory. */
42507c478bd9Sstevel@tonic-gate
42517c478bd9Sstevel@tonic-gate if (!Adir) {
42527c478bd9Sstevel@tonic-gate char *existingfile = save_name;
42537c478bd9Sstevel@tonic-gate
42547c478bd9Sstevel@tonic-gate if ((Args & OCL) && issymlink) {
42557c478bd9Sstevel@tonic-gate /* We are chasing symlinks. */
42567c478bd9Sstevel@tonic-gate
42577c478bd9Sstevel@tonic-gate if ((size = readlink(save_name, Symlnk_p,
42587c478bd9Sstevel@tonic-gate MAXPATHLEN)) < 0) {
42597c478bd9Sstevel@tonic-gate msg(ERRN,
42607c478bd9Sstevel@tonic-gate "Cannot read symbolic link \"%s\"",
42617c478bd9Sstevel@tonic-gate save_name);
42627c478bd9Sstevel@tonic-gate return (FILE_PASS_ERR);
42637c478bd9Sstevel@tonic-gate }
42647c478bd9Sstevel@tonic-gate
42657c478bd9Sstevel@tonic-gate Symlnk_p[size] = '\0';
42667c478bd9Sstevel@tonic-gate existingfile = Symlnk_p;
42677c478bd9Sstevel@tonic-gate }
42687c478bd9Sstevel@tonic-gate
4269ced83f9bSceastha if (G_p->g_attrnam_p == NULL) {
42707c478bd9Sstevel@tonic-gate if (creat_lnk(G_p->g_passdirfd,
42717c478bd9Sstevel@tonic-gate existingfile, Fullnam_p) == 0) {
42727c478bd9Sstevel@tonic-gate return (FILE_LINKED);
42737c478bd9Sstevel@tonic-gate }
42747c478bd9Sstevel@tonic-gate }
42757c478bd9Sstevel@tonic-gate }
42767c478bd9Sstevel@tonic-gate }
42777c478bd9Sstevel@tonic-gate
42787c478bd9Sstevel@tonic-gate if ((G_p->g_mode & Ftype) == S_IFLNK && !(Args & OCL)) {
42797c478bd9Sstevel@tonic-gate /* The archive file is a symlink. */
42807c478bd9Sstevel@tonic-gate
42817c478bd9Sstevel@tonic-gate errno = 0;
42827c478bd9Sstevel@tonic-gate
42837c478bd9Sstevel@tonic-gate if ((size = readlink(save_name, Symlnk_p, MAXPATHLEN)) < 0) {
42847c478bd9Sstevel@tonic-gate msg(ERRN,
42857c478bd9Sstevel@tonic-gate "Cannot read symbolic link \"%s\"", save_name);
42867c478bd9Sstevel@tonic-gate return (FILE_PASS_ERR);
42877c478bd9Sstevel@tonic-gate }
42887c478bd9Sstevel@tonic-gate
42897c478bd9Sstevel@tonic-gate errno = 0;
42907c478bd9Sstevel@tonic-gate (void) missdir(Fullnam_p);
42917c478bd9Sstevel@tonic-gate *(Symlnk_p + size) = '\0';
42927c478bd9Sstevel@tonic-gate
42937c478bd9Sstevel@tonic-gate if (symlink(Symlnk_p, Fullnam_p) < 0) {
42947c478bd9Sstevel@tonic-gate if (errno == EEXIST) {
42957c478bd9Sstevel@tonic-gate if (openout(G_p->g_passdirfd) < 0) {
4296647ab8f4Sceastha if (errno != EEXIST) {
4297647ab8f4Sceastha msg(ERRN,
4298647ab8f4Sceastha "Cannot create \"%s\"",
4299647ab8f4Sceastha Fullnam_p);
4300647ab8f4Sceastha }
43017c478bd9Sstevel@tonic-gate return (FILE_PASS_ERR);
43027c478bd9Sstevel@tonic-gate }
43037c478bd9Sstevel@tonic-gate } else {
43047c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot create \"%s\"", Fullnam_p);
43057c478bd9Sstevel@tonic-gate return (FILE_PASS_ERR);
43067c478bd9Sstevel@tonic-gate }
4307647ab8f4Sceastha } else {
4308647ab8f4Sceastha if (Args & OCR) {
4309647ab8f4Sceastha if (lchown(Fullnam_p, (int)Rpw_p->pw_uid,
4310647ab8f4Sceastha (int)Rpw_p->pw_gid) < 0) {
4311647ab8f4Sceastha msg(ERRN,
4312647ab8f4Sceastha "Error during chown() of \"%s\"",
4313647ab8f4Sceastha Fullnam_p);
43147c478bd9Sstevel@tonic-gate }
4315647ab8f4Sceastha } else if ((lchown(Fullnam_p, (int)G_p->g_uid,
4316647ab8f4Sceastha (int)G_p->g_gid) < 0) && privileged) {
43177c478bd9Sstevel@tonic-gate msg(ERRN,
43187c478bd9Sstevel@tonic-gate "Error during chown() of \"%s\"",
43197c478bd9Sstevel@tonic-gate Fullnam_p);
43207c478bd9Sstevel@tonic-gate }
43217c478bd9Sstevel@tonic-gate }
43227c478bd9Sstevel@tonic-gate
43237c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), Fullnam_p);
43247c478bd9Sstevel@tonic-gate return (FILE_PASS_ERR);
43257c478bd9Sstevel@tonic-gate }
43267c478bd9Sstevel@tonic-gate
43277c478bd9Sstevel@tonic-gate if (!Adir && G_p->g_nlink > 1) {
43287c478bd9Sstevel@tonic-gate /* The archive file has hard links. */
43297c478bd9Sstevel@tonic-gate
43307c478bd9Sstevel@tonic-gate tl_p = add_lnk(&ttl_p);
43317c478bd9Sstevel@tonic-gate l_p = ttl_p;
43327c478bd9Sstevel@tonic-gate
43337c478bd9Sstevel@tonic-gate if (tl_p == l_p) {
43347c478bd9Sstevel@tonic-gate /* The archive file was not found. */
43357c478bd9Sstevel@tonic-gate
43367c478bd9Sstevel@tonic-gate G_p = &tl_p->L_gen;
43377c478bd9Sstevel@tonic-gate } else {
43387c478bd9Sstevel@tonic-gate /* The archive file was found. */
43397c478bd9Sstevel@tonic-gate
43407c478bd9Sstevel@tonic-gate cwd = -1;
43417c478bd9Sstevel@tonic-gate
4342ced83f9bSceastha if (l_p->L_gen.g_attrnam_p != NULL) {
43437c478bd9Sstevel@tonic-gate /* We are linking an attribute */
43447c478bd9Sstevel@tonic-gate
43457c478bd9Sstevel@tonic-gate (void) strcpy(Lnkend_p, l_p->L_gen.g_attrnam_p);
43467c478bd9Sstevel@tonic-gate cwd = save_cwd();
43477c478bd9Sstevel@tonic-gate (void) fchdir(G_p->g_passdirfd);
43487c478bd9Sstevel@tonic-gate lfrom = get_component(Lnknam_p);
43497c478bd9Sstevel@tonic-gate lto = tl_p->L_gen.g_attrnam_p;
43507c478bd9Sstevel@tonic-gate } else {
43517c478bd9Sstevel@tonic-gate /* We are not linking an attribute */
43527c478bd9Sstevel@tonic-gate
43537c478bd9Sstevel@tonic-gate (void) strcpy(Lnkend_p, l_p->L_gen.g_nam_p);
43547c478bd9Sstevel@tonic-gate (void) strcpy(Full_p, tl_p->L_gen.g_nam_p);
43557c478bd9Sstevel@tonic-gate lfrom = Lnknam_p;
43567c478bd9Sstevel@tonic-gate lto = Fullnam_p;
43577c478bd9Sstevel@tonic-gate }
43587c478bd9Sstevel@tonic-gate
43597c478bd9Sstevel@tonic-gate (void) creat_lnk(G_p->g_passdirfd, lfrom, lto);
43607c478bd9Sstevel@tonic-gate
43617c478bd9Sstevel@tonic-gate if (cwd) {
43627c478bd9Sstevel@tonic-gate rest_cwd(cwd);
43637c478bd9Sstevel@tonic-gate }
43647c478bd9Sstevel@tonic-gate
4365ced83f9bSceastha l_p->L_lnk_p = NULL;
43667c478bd9Sstevel@tonic-gate free(tl_p->L_gen.g_nam_p);
43677c478bd9Sstevel@tonic-gate free(tl_p);
43687c478bd9Sstevel@tonic-gate
43697c478bd9Sstevel@tonic-gate if (l_p->L_cnt == G_p->g_nlink) {
43707c478bd9Sstevel@tonic-gate reclaim(l_p);
43717c478bd9Sstevel@tonic-gate }
43727c478bd9Sstevel@tonic-gate
43737c478bd9Sstevel@tonic-gate return (FILE_LINKED);
43747c478bd9Sstevel@tonic-gate }
43757c478bd9Sstevel@tonic-gate }
43767c478bd9Sstevel@tonic-gate
43777c478bd9Sstevel@tonic-gate if (Adir || Aspec) {
43787c478bd9Sstevel@tonic-gate /*
43797c478bd9Sstevel@tonic-gate * The archive file is a directory, block special, char
43807c478bd9Sstevel@tonic-gate * special or a fifo.
43817c478bd9Sstevel@tonic-gate */
43827c478bd9Sstevel@tonic-gate
43837c478bd9Sstevel@tonic-gate if (creat_spec(G_p->g_passdirfd) > 0) {
43847c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), Fullnam_p);
43857c478bd9Sstevel@tonic-gate }
43867c478bd9Sstevel@tonic-gate } else if ((Ofile = openout(G_p->g_passdirfd)) > 0) {
43877c478bd9Sstevel@tonic-gate data_pass();
43887c478bd9Sstevel@tonic-gate }
43897c478bd9Sstevel@tonic-gate
43907c478bd9Sstevel@tonic-gate return (FILE_COPIED);
43917c478bd9Sstevel@tonic-gate }
43927c478bd9Sstevel@tonic-gate
43937c478bd9Sstevel@tonic-gate /*
43947c478bd9Sstevel@tonic-gate * flush_lnks: With new linked file handling, linked files are not archived
43957c478bd9Sstevel@tonic-gate * until all links have been collected. When the end of the list of filenames
43967c478bd9Sstevel@tonic-gate * to archive has been reached, all files that did not encounter all their links
43977c478bd9Sstevel@tonic-gate * are written out with actual (encountered) link counts. A file with n links
43987c478bd9Sstevel@tonic-gate * (that are archived) will be represented by n headers (one for each link (the
43997c478bd9Sstevel@tonic-gate * first n - 1 have g_filesz set to 0)) followed by the data for the file.
44007c478bd9Sstevel@tonic-gate */
44017c478bd9Sstevel@tonic-gate
44027c478bd9Sstevel@tonic-gate static void
flush_lnks(void)44037c478bd9Sstevel@tonic-gate flush_lnks(void)
44047c478bd9Sstevel@tonic-gate {
44057c478bd9Sstevel@tonic-gate struct Lnk *l_p, *tl_p;
44067c478bd9Sstevel@tonic-gate off_t tfsize;
44077c478bd9Sstevel@tonic-gate
44087c478bd9Sstevel@tonic-gate l_p = Lnk_hd.L_nxt_p;
44097c478bd9Sstevel@tonic-gate while (l_p != &Lnk_hd) {
44107c478bd9Sstevel@tonic-gate (void) strcpy(Gen.g_nam_p, l_p->L_gen.g_nam_p);
44117c478bd9Sstevel@tonic-gate if (stat(Gen.g_nam_p, &SrcSt) == 0) { /* check if file exists */
44127c478bd9Sstevel@tonic-gate tl_p = l_p;
44137c478bd9Sstevel@tonic-gate (void) creat_hdr();
44147c478bd9Sstevel@tonic-gate Gen.g_nlink = l_p->L_cnt; /* "actual" link count */
44157c478bd9Sstevel@tonic-gate tfsize = Gen.g_filesz;
44167c478bd9Sstevel@tonic-gate Gen.g_filesz = (off_t)0;
44177c478bd9Sstevel@tonic-gate G_p = &Gen;
4418ced83f9bSceastha while (tl_p != NULL) {
44197c478bd9Sstevel@tonic-gate Gen.g_nam_p = tl_p->L_gen.g_nam_p;
44207c478bd9Sstevel@tonic-gate Gen.g_namesz = tl_p->L_gen.g_namesz;
4421ced83f9bSceastha if (tl_p->L_lnk_p == NULL) {
44227c478bd9Sstevel@tonic-gate Gen.g_filesz = tfsize;
44237c478bd9Sstevel@tonic-gate if (open_dirfd() != 0) {
44247c478bd9Sstevel@tonic-gate break;
44257c478bd9Sstevel@tonic-gate }
44267c478bd9Sstevel@tonic-gate data_out();
44277c478bd9Sstevel@tonic-gate break;
44287c478bd9Sstevel@tonic-gate }
44297c478bd9Sstevel@tonic-gate write_hdr(ARCHIVE_NORMAL,
44307c478bd9Sstevel@tonic-gate (off_t)0); /* header only */
44317c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), Gen.g_nam_p);
44327c478bd9Sstevel@tonic-gate tl_p = tl_p->L_lnk_p;
44337c478bd9Sstevel@tonic-gate }
44347c478bd9Sstevel@tonic-gate Gen.g_nam_p = Nam_p;
44357c478bd9Sstevel@tonic-gate } else /* stat(Gen.g_nam_p, &SrcSt) == 0 */
44367c478bd9Sstevel@tonic-gate msg(ERR, "\"%s%s%s\" has disappeared",
4437ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
44387c478bd9Sstevel@tonic-gate Gen.g_nam_p : Gen.g_attrfnam_p,
4439ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
4440ced83f9bSceastha "" : Gen.g_rw_sysattr ?
4441ced83f9bSceastha gettext(" System Attribute ") :
4442ced83f9bSceastha gettext(" Attribute "),
4443ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
44447c478bd9Sstevel@tonic-gate "" : Gen.g_attrnam_p);
44457c478bd9Sstevel@tonic-gate tl_p = l_p;
44467c478bd9Sstevel@tonic-gate l_p = l_p->L_nxt_p;
44477c478bd9Sstevel@tonic-gate reclaim(tl_p);
44487c478bd9Sstevel@tonic-gate } /* l_p != &Lnk_hd */
44497c478bd9Sstevel@tonic-gate }
44507c478bd9Sstevel@tonic-gate
4451da6c28aaSamw #if defined(O_XATTR)
4452da6c28aaSamw static int
is_sysattr(char * name)4453da6c28aaSamw is_sysattr(char *name)
4454da6c28aaSamw {
4455da6c28aaSamw return ((strcmp(name, VIEW_READONLY) == 0) ||
4456da6c28aaSamw (strcmp(name, VIEW_READWRITE) == 0));
4457da6c28aaSamw }
4458da6c28aaSamw #endif
4459da6c28aaSamw
44607c478bd9Sstevel@tonic-gate /*
44617c478bd9Sstevel@tonic-gate * gethdr: Get a header from the archive, validate it and check for the trailer.
44627c478bd9Sstevel@tonic-gate * Any user specified Hdr_type is ignored (set to NONE in main). Hdr_type is
44637c478bd9Sstevel@tonic-gate * set appropriately after a valid header is found. Unless the -k option is
44647c478bd9Sstevel@tonic-gate * set a corrupted header causes an exit with an error. I/O errors during
44657c478bd9Sstevel@tonic-gate * examination of any part of the header cause gethdr to throw away any current
44667c478bd9Sstevel@tonic-gate * data and start over. Other errors during examination of any part of the
44677c478bd9Sstevel@tonic-gate * header cause gethdr to advance one byte and continue the examination.
44687c478bd9Sstevel@tonic-gate */
44697c478bd9Sstevel@tonic-gate
44707c478bd9Sstevel@tonic-gate static int
gethdr(void)44717c478bd9Sstevel@tonic-gate gethdr(void)
44727c478bd9Sstevel@tonic-gate {
44737c478bd9Sstevel@tonic-gate ushort_t ftype;
44747c478bd9Sstevel@tonic-gate int hit = NONE, cnt = 0;
44750b9a5158SToomas Soome int goodhdr, hsize = 0, offset;
44767c478bd9Sstevel@tonic-gate int bswap = 0;
44777c478bd9Sstevel@tonic-gate char *preptr;
44787c478bd9Sstevel@tonic-gate int k = 0;
44797c478bd9Sstevel@tonic-gate int j;
4480fa9e4066Sahrens int error;
4481fa9e4066Sahrens int aclcnt;
44827c478bd9Sstevel@tonic-gate
44837c478bd9Sstevel@tonic-gate Gen.g_nam_p = Nam_p;
44847c478bd9Sstevel@tonic-gate do { /* hit == NONE && (Args & OCk) && Buffr.b_cnt > 0 */
44857c478bd9Sstevel@tonic-gate FILL(Hdrsz);
44867c478bd9Sstevel@tonic-gate switch (Hdr_type) {
44877c478bd9Sstevel@tonic-gate case NONE:
44887c478bd9Sstevel@tonic-gate case BIN:
44897c478bd9Sstevel@tonic-gate Binmag.b_byte[0] = Buffr.b_out_p[0];
44907c478bd9Sstevel@tonic-gate Binmag.b_byte[1] = Buffr.b_out_p[1];
44917c478bd9Sstevel@tonic-gate if ((Binmag.b_half == CMN_BIN) ||
44927c478bd9Sstevel@tonic-gate (Binmag.b_half == CMN_BBS)) {
44937c478bd9Sstevel@tonic-gate hit = read_hdr(BIN);
44947c478bd9Sstevel@tonic-gate if (Hdr_type == NONE)
44957c478bd9Sstevel@tonic-gate bswap = 1;
44967c478bd9Sstevel@tonic-gate hsize = HDRSZ + Gen.g_namesz;
44977c478bd9Sstevel@tonic-gate break;
44987c478bd9Sstevel@tonic-gate }
44997c478bd9Sstevel@tonic-gate if (Hdr_type != NONE)
45007c478bd9Sstevel@tonic-gate break;
45017c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/
45027c478bd9Sstevel@tonic-gate case CHR:
45037c478bd9Sstevel@tonic-gate if (!(strncmp(Buffr.b_out_p, CMS_CHR, CMS_LEN))) {
45047c478bd9Sstevel@tonic-gate hit = read_hdr(CHR);
45057c478bd9Sstevel@tonic-gate hsize = CHRSZ + Gen.g_namesz;
45067c478bd9Sstevel@tonic-gate break;
45077c478bd9Sstevel@tonic-gate }
45087c478bd9Sstevel@tonic-gate if (Hdr_type != NONE)
45097c478bd9Sstevel@tonic-gate break;
45107c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/
45117c478bd9Sstevel@tonic-gate case ASC:
45127c478bd9Sstevel@tonic-gate if (!(strncmp(Buffr.b_out_p, CMS_ASC, CMS_LEN))) {
45137c478bd9Sstevel@tonic-gate hit = read_hdr(ASC);
45147c478bd9Sstevel@tonic-gate hsize = ASCSZ + Gen.g_namesz;
45157c478bd9Sstevel@tonic-gate Max_namesz = APATH;
45167c478bd9Sstevel@tonic-gate break;
45177c478bd9Sstevel@tonic-gate }
45187c478bd9Sstevel@tonic-gate if (Hdr_type != NONE)
45197c478bd9Sstevel@tonic-gate break;
45207c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/
45217c478bd9Sstevel@tonic-gate case CRC:
45227c478bd9Sstevel@tonic-gate if (!(strncmp(Buffr.b_out_p, CMS_CRC, CMS_LEN))) {
45237c478bd9Sstevel@tonic-gate hit = read_hdr(CRC);
45247c478bd9Sstevel@tonic-gate hsize = ASCSZ + Gen.g_namesz;
45257c478bd9Sstevel@tonic-gate Max_namesz = APATH;
45267c478bd9Sstevel@tonic-gate break;
45277c478bd9Sstevel@tonic-gate }
45287c478bd9Sstevel@tonic-gate if (Hdr_type != NONE)
45297c478bd9Sstevel@tonic-gate break;
45307c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/
45317c478bd9Sstevel@tonic-gate
45327c478bd9Sstevel@tonic-gate case BAR:
45337c478bd9Sstevel@tonic-gate if (Hdr_p != NULL && strcmp(Hdr_p, "bar") == 0) {
45347c478bd9Sstevel@tonic-gate Hdrsz = BARSZ;
45357c478bd9Sstevel@tonic-gate FILL(Hdrsz);
45367c478bd9Sstevel@tonic-gate if ((hit = read_hdr(BAR)) == NONE) {
45377c478bd9Sstevel@tonic-gate Hdrsz = ASCSZ;
45387c478bd9Sstevel@tonic-gate break;
45397c478bd9Sstevel@tonic-gate }
45407c478bd9Sstevel@tonic-gate hit = BAR;
45417c478bd9Sstevel@tonic-gate hsize = BARSZ;
45427c478bd9Sstevel@tonic-gate break;
45437c478bd9Sstevel@tonic-gate }
45447c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/
45457c478bd9Sstevel@tonic-gate
45467c478bd9Sstevel@tonic-gate case USTAR:
45477c478bd9Sstevel@tonic-gate if (Hdr_p != NULL && strcmp(Hdr_p, "ustar") == 0) {
45487c478bd9Sstevel@tonic-gate Hdrsz = TARSZ;
45497c478bd9Sstevel@tonic-gate FILL(Hdrsz);
45507c478bd9Sstevel@tonic-gate if ((hit = read_hdr(USTAR)) == NONE) {
45517c478bd9Sstevel@tonic-gate Hdrsz = ASCSZ;
45527c478bd9Sstevel@tonic-gate break;
45537c478bd9Sstevel@tonic-gate }
45547c478bd9Sstevel@tonic-gate hit = USTAR;
45557c478bd9Sstevel@tonic-gate hsize = TARSZ;
45567c478bd9Sstevel@tonic-gate break;
45577c478bd9Sstevel@tonic-gate }
45587c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/
45597c478bd9Sstevel@tonic-gate case TAR:
45607c478bd9Sstevel@tonic-gate if (Hdr_p != NULL && strcmp(Hdr_p, "tar") == 0) {
45617c478bd9Sstevel@tonic-gate Hdrsz = TARSZ;
45627c478bd9Sstevel@tonic-gate FILL(Hdrsz);
45637c478bd9Sstevel@tonic-gate if ((hit = read_hdr(TAR)) == NONE) {
45647c478bd9Sstevel@tonic-gate Hdrsz = ASCSZ;
45657c478bd9Sstevel@tonic-gate break;
45667c478bd9Sstevel@tonic-gate }
45677c478bd9Sstevel@tonic-gate hit = TAR;
45687c478bd9Sstevel@tonic-gate hsize = TARSZ;
45697c478bd9Sstevel@tonic-gate break;
45707c478bd9Sstevel@tonic-gate }
45717c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/
45727c478bd9Sstevel@tonic-gate default:
45737c478bd9Sstevel@tonic-gate msg(EXT, "Impossible header type.");
45747c478bd9Sstevel@tonic-gate } /* Hdr_type */
45757c478bd9Sstevel@tonic-gate
45767c478bd9Sstevel@tonic-gate if (hit == TAR || hit == USTAR) {
45777c478bd9Sstevel@tonic-gate Gen.g_nam_p = &nambuf[0];
45787c478bd9Sstevel@tonic-gate }
45797c478bd9Sstevel@tonic-gate
45807c478bd9Sstevel@tonic-gate if (hit != NONE) {
45817c478bd9Sstevel@tonic-gate FILL(hsize);
45827c478bd9Sstevel@tonic-gate goodhdr = 1;
45837c478bd9Sstevel@tonic-gate if (Gen.g_filesz < (off_t)0 || Gen.g_namesz < 1)
45847c478bd9Sstevel@tonic-gate goodhdr = 0;
45857c478bd9Sstevel@tonic-gate if ((hit != USTAR) && (hit != TAR))
45867c478bd9Sstevel@tonic-gate if (Gen.g_namesz - 1 > Max_namesz)
45877c478bd9Sstevel@tonic-gate goodhdr = 0;
45887c478bd9Sstevel@tonic-gate /* TAR and USTAR */
45897c478bd9Sstevel@tonic-gate if ((hit == USTAR) || (hit == TAR)) {
45907c478bd9Sstevel@tonic-gate if (*Gen.g_nam_p == '\0') { /* tar trailer */
45917c478bd9Sstevel@tonic-gate goodhdr = 1;
45927c478bd9Sstevel@tonic-gate } else {
45937c478bd9Sstevel@tonic-gate
45947c478bd9Sstevel@tonic-gate G_p = &Gen;
45957c478bd9Sstevel@tonic-gate if (G_p->g_cksum !=
45967c478bd9Sstevel@tonic-gate cksum(TARTYP, 0, NULL)) {
45977c478bd9Sstevel@tonic-gate goodhdr = 0;
45987c478bd9Sstevel@tonic-gate msg(ERR,
45997c478bd9Sstevel@tonic-gate "Bad header - checksum "
46007c478bd9Sstevel@tonic-gate "error.");
46017c478bd9Sstevel@tonic-gate }
46027c478bd9Sstevel@tonic-gate }
46037c478bd9Sstevel@tonic-gate } else if (hit != BAR) { /* binary, -c, ASC and CRC */
4604*6d3b960aSAndy Fiddaman if (Gen.g_nlink <= 0)
46057c478bd9Sstevel@tonic-gate goodhdr = 0;
46067c478bd9Sstevel@tonic-gate if (*(Buffr.b_out_p + hsize - 1) != '\0')
46077c478bd9Sstevel@tonic-gate goodhdr = 0;
46087c478bd9Sstevel@tonic-gate }
46097c478bd9Sstevel@tonic-gate if (!goodhdr) {
46107c478bd9Sstevel@tonic-gate hit = NONE;
46117c478bd9Sstevel@tonic-gate if (!(Args & OCk))
46127c478bd9Sstevel@tonic-gate break;
46137c478bd9Sstevel@tonic-gate msg(ERR,
46147c478bd9Sstevel@tonic-gate "Corrupt header, file(s) may be lost.");
46157c478bd9Sstevel@tonic-gate } else {
46167c478bd9Sstevel@tonic-gate FILL(hsize);
46177c478bd9Sstevel@tonic-gate }
46187c478bd9Sstevel@tonic-gate } /* hit != NONE */
46197c478bd9Sstevel@tonic-gate if (hit == NONE) {
46207c478bd9Sstevel@tonic-gate Buffr.b_out_p++;
46217c478bd9Sstevel@tonic-gate Buffr.b_cnt--;
46227c478bd9Sstevel@tonic-gate if (!(Args & OCk))
46237c478bd9Sstevel@tonic-gate break;
46247c478bd9Sstevel@tonic-gate if (!cnt++)
46257c478bd9Sstevel@tonic-gate msg(ERR, "Searching for magic number/header.");
46267c478bd9Sstevel@tonic-gate }
46277c478bd9Sstevel@tonic-gate } while (hit == NONE);
46287c478bd9Sstevel@tonic-gate if (hit == NONE) {
46297c478bd9Sstevel@tonic-gate if (Hdr_type == NONE)
46307c478bd9Sstevel@tonic-gate msg(EXT, "Not a cpio file, bad header.");
46317c478bd9Sstevel@tonic-gate else
46327c478bd9Sstevel@tonic-gate msg(EXT, "Bad magic number/header.");
46337c478bd9Sstevel@tonic-gate } else if (cnt > 0) {
46347c478bd9Sstevel@tonic-gate msg(EPOST, "Re-synchronized on magic number/header.");
46357c478bd9Sstevel@tonic-gate }
46367c478bd9Sstevel@tonic-gate if (Hdr_type == NONE) {
46377c478bd9Sstevel@tonic-gate Hdr_type = hit;
46387c478bd9Sstevel@tonic-gate switch (Hdr_type) {
46397c478bd9Sstevel@tonic-gate case BIN:
46407c478bd9Sstevel@tonic-gate if (bswap)
46417c478bd9Sstevel@tonic-gate Args |= BSM;
46427c478bd9Sstevel@tonic-gate Hdrsz = HDRSZ;
46437c478bd9Sstevel@tonic-gate Max_namesz = CPATH;
46447c478bd9Sstevel@tonic-gate Pad_val = HALFWD;
46457c478bd9Sstevel@tonic-gate Onecopy = 0;
46467c478bd9Sstevel@tonic-gate break;
46477c478bd9Sstevel@tonic-gate case CHR:
46487c478bd9Sstevel@tonic-gate Hdrsz = CHRSZ;
46497c478bd9Sstevel@tonic-gate Max_namesz = CPATH;
46507c478bd9Sstevel@tonic-gate Pad_val = 0;
46517c478bd9Sstevel@tonic-gate Onecopy = 0;
46527c478bd9Sstevel@tonic-gate break;
46537c478bd9Sstevel@tonic-gate case ASC:
46547c478bd9Sstevel@tonic-gate case CRC:
46557c478bd9Sstevel@tonic-gate Hdrsz = ASCSZ;
46567c478bd9Sstevel@tonic-gate Max_namesz = APATH;
46577c478bd9Sstevel@tonic-gate Pad_val = FULLWD;
46587c478bd9Sstevel@tonic-gate Onecopy = 1;
46597c478bd9Sstevel@tonic-gate break;
46607c478bd9Sstevel@tonic-gate case USTAR:
46617c478bd9Sstevel@tonic-gate Hdrsz = TARSZ;
46627c478bd9Sstevel@tonic-gate Max_namesz = HNAMLEN - 1;
46637c478bd9Sstevel@tonic-gate Pad_val = FULLBK;
46647c478bd9Sstevel@tonic-gate Onecopy = 0;
46657c478bd9Sstevel@tonic-gate break;
46667c478bd9Sstevel@tonic-gate case BAR:
46677c478bd9Sstevel@tonic-gate case TAR:
46687c478bd9Sstevel@tonic-gate Hdrsz = TARSZ;
46697c478bd9Sstevel@tonic-gate Max_namesz = TNAMLEN - 1;
46707c478bd9Sstevel@tonic-gate Pad_val = FULLBK;
46717c478bd9Sstevel@tonic-gate Onecopy = 0;
46727c478bd9Sstevel@tonic-gate break;
46737c478bd9Sstevel@tonic-gate default:
46747c478bd9Sstevel@tonic-gate msg(EXT, "Impossible header type.");
46757c478bd9Sstevel@tonic-gate } /* Hdr_type */
46767c478bd9Sstevel@tonic-gate } /* Hdr_type == NONE */
46777c478bd9Sstevel@tonic-gate if ((Hdr_type == USTAR) || (Hdr_type == TAR) ||
46787c478bd9Sstevel@tonic-gate (Hdr_type == BAR)) { /* TAR, USTAR, BAR */
46797c478bd9Sstevel@tonic-gate Gen.g_namesz = 0;
46807c478bd9Sstevel@tonic-gate if (Gen.g_nam_p[0] == '\0')
46817c478bd9Sstevel@tonic-gate return (0);
46827c478bd9Sstevel@tonic-gate else {
46837c478bd9Sstevel@tonic-gate preptr = &prebuf[0];
46844c719f3bSToomas Soome if (*preptr != '\0') {
46857c478bd9Sstevel@tonic-gate k = strlen(&prebuf[0]);
46867c478bd9Sstevel@tonic-gate if (k < PRESIZ) {
46877c478bd9Sstevel@tonic-gate (void) strcpy(&fullnam[0], &prebuf[0]);
46887c478bd9Sstevel@tonic-gate j = 0;
46897c478bd9Sstevel@tonic-gate fullnam[k++] = '/';
46902ae4c13bSToomas Soome while ((j < NAMSIZ) && (nambuf[j] !=
4691ced83f9bSceastha '\0')) {
46927c478bd9Sstevel@tonic-gate fullnam[k] = nambuf[j];
46937c478bd9Sstevel@tonic-gate k++; j++;
46947c478bd9Sstevel@tonic-gate }
46957c478bd9Sstevel@tonic-gate fullnam[k] = '\0';
46967c478bd9Sstevel@tonic-gate } else if (k >= PRESIZ) {
46977c478bd9Sstevel@tonic-gate k = 0;
46987c478bd9Sstevel@tonic-gate while ((k < PRESIZ) && (prebuf[k] !=
46997c478bd9Sstevel@tonic-gate '\0')) {
47007c478bd9Sstevel@tonic-gate fullnam[k] = prebuf[k];
47017c478bd9Sstevel@tonic-gate k++;
47027c478bd9Sstevel@tonic-gate }
47037c478bd9Sstevel@tonic-gate fullnam[k++] = '/';
47047c478bd9Sstevel@tonic-gate j = 0;
47057c478bd9Sstevel@tonic-gate while ((j < NAMSIZ) && (nambuf[j] !=
47067c478bd9Sstevel@tonic-gate '\0')) {
47077c478bd9Sstevel@tonic-gate fullnam[k] = nambuf[j];
47087c478bd9Sstevel@tonic-gate k++; j++;
47097c478bd9Sstevel@tonic-gate }
47107c478bd9Sstevel@tonic-gate fullnam[k] = '\0';
47117c478bd9Sstevel@tonic-gate }
47127c478bd9Sstevel@tonic-gate Gen.g_nam_p = &fullnam[0];
47137c478bd9Sstevel@tonic-gate } else
47147c478bd9Sstevel@tonic-gate Gen.g_nam_p = &nambuf[0];
47157c478bd9Sstevel@tonic-gate
47167c478bd9Sstevel@tonic-gate /*
47177c478bd9Sstevel@tonic-gate * initialize the buffer so that the prefix will not
47187c478bd9Sstevel@tonic-gate * applied to the next entry in the archive
47197c478bd9Sstevel@tonic-gate */
47207c478bd9Sstevel@tonic-gate (void) memset(prebuf, 0, sizeof (prebuf));
47217c478bd9Sstevel@tonic-gate }
47227c478bd9Sstevel@tonic-gate } else if (Hdr_type != BAR) {
47237c478bd9Sstevel@tonic-gate (void) memcpy(Gen.g_nam_p, Buffr.b_out_p + Hdrsz, Gen.g_namesz);
47247c478bd9Sstevel@tonic-gate if (!(strcmp(Gen.g_nam_p, "TRAILER!!!")))
47257c478bd9Sstevel@tonic-gate return (0);
47267c478bd9Sstevel@tonic-gate }
47277c478bd9Sstevel@tonic-gate offset = ((hsize + Pad_val) & ~Pad_val);
47287c478bd9Sstevel@tonic-gate FILL(offset + Hdrsz);
47297c478bd9Sstevel@tonic-gate Thdr_p = (union tblock *)Buffr.b_out_p;
47307c478bd9Sstevel@tonic-gate Buffr.b_out_p += offset;
47317c478bd9Sstevel@tonic-gate Buffr.b_cnt -= (off_t)offset;
47327c478bd9Sstevel@tonic-gate ftype = Gen.g_mode & Ftype;
47337c478bd9Sstevel@tonic-gate
47347c478bd9Sstevel@tonic-gate #if defined(O_XATTR)
47357c478bd9Sstevel@tonic-gate /* extended attribute support */
47367c478bd9Sstevel@tonic-gate if (((Gen.g_mode & S_IFMT) == _XATTR_CPIO_MODE) ||
47377c478bd9Sstevel@tonic-gate ((Hdr_type == USTAR || Hdr_type == TAR) &&
47387c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_typeflag == _XATTR_HDRTYPE)) {
4739ced83f9bSceastha char *aname;
4740ced83f9bSceastha char *attrparent = NULL;
4741ced83f9bSceastha char *attrpath = NULL;
4742da6c28aaSamw char *tapath;
4743ced83f9bSceastha char *taname;
4744da6c28aaSamw
4745ced83f9bSceastha if (xattrp != NULL) {
47467c478bd9Sstevel@tonic-gate if (xattrbadhead) {
47477c478bd9Sstevel@tonic-gate free(xattrhead);
47487c478bd9Sstevel@tonic-gate xattrp = NULL;
47497c478bd9Sstevel@tonic-gate xattr_linkp = NULL;
47507c478bd9Sstevel@tonic-gate xattrhead = NULL;
47517c478bd9Sstevel@tonic-gate return (1);
47527c478bd9Sstevel@tonic-gate }
4753da6c28aaSamw
4754da6c28aaSamw /*
4755ced83f9bSceastha * At this point, the attribute path contains
4756ced83f9bSceastha * the path to the attribute rooted at the hidden
4757ced83f9bSceastha * attribute directory of the base file. This can
4758ced83f9bSceastha * be a simple attribute or extended attribute name,
4759ced83f9bSceastha * or it can be something like <attr>/<sys attr> if
4760ced83f9bSceastha * we are processing a system attribute of an attribute.
4761ced83f9bSceastha * Determine the attribute name and attribute parent
4762ced83f9bSceastha * (if there is one). When we are processing a simple
4763ced83f9bSceastha * attribute or extended attribute name, the attribute
4764ced83f9bSceastha * parent will be set to NULL. When we are processing
4765ced83f9bSceastha * something like <attr>/<sys attr>, the attribute
4766ced83f9bSceastha * parent will be contain <attr>, and the attribute
4767ced83f9bSceastha * name will contain <sys attr>.
4768da6c28aaSamw */
4769ced83f9bSceastha tapath = xattrp->h_names +
4770ced83f9bSceastha strlen(xattrp->h_names) + 1;
4771ced83f9bSceastha attrpath = e_strdup(E_EXIT, tapath);
4772ced83f9bSceastha if ((taname = strpbrk(tapath, "/")) != NULL) {
4773ced83f9bSceastha aname = taname + 1;
4774ced83f9bSceastha *taname = '\0';
4775ced83f9bSceastha attrparent = tapath;
4776ced83f9bSceastha } else {
4777ced83f9bSceastha aname = tapath;
47787c478bd9Sstevel@tonic-gate }
47797c478bd9Sstevel@tonic-gate
4780ced83f9bSceastha Gen.g_rw_sysattr = is_sysattr(aname);
4781ced83f9bSceastha Gen.g_baseparent_fd = attr_baseparent_fd;
4782ced83f9bSceastha
4783ced83f9bSceastha if (Gen.g_attrfnam_p != NULL) {
47847c478bd9Sstevel@tonic-gate free(Gen.g_attrfnam_p);
4785ced83f9bSceastha Gen.g_attrfnam_p = NULL;
47867c478bd9Sstevel@tonic-gate }
4787ced83f9bSceastha if (Gen.g_attrnam_p != NULL) {
47887c478bd9Sstevel@tonic-gate free(Gen.g_attrnam_p);
4789ced83f9bSceastha Gen.g_attrnam_p = NULL;
4790ced83f9bSceastha }
4791ced83f9bSceastha if (Gen.g_attrparent_p != NULL) {
4792ced83f9bSceastha free(Gen.g_attrparent_p);
4793ced83f9bSceastha Gen.g_attrparent_p = NULL;
4794ced83f9bSceastha }
4795ced83f9bSceastha if (Gen.g_attrpath_p != NULL) {
4796ced83f9bSceastha free(Gen.g_attrpath_p);
4797ced83f9bSceastha Gen.g_attrpath_p = NULL;
47987c478bd9Sstevel@tonic-gate }
47997c478bd9Sstevel@tonic-gate if (Renam_p && Renam_p[0] != '\0') {
48007c478bd9Sstevel@tonic-gate Gen.g_attrfnam_p = e_strdup(E_EXIT, Renam_p);
48017c478bd9Sstevel@tonic-gate } else {
48027c478bd9Sstevel@tonic-gate Gen.g_attrfnam_p = e_strdup(E_EXIT,
48037c478bd9Sstevel@tonic-gate xattrp->h_names);
48047c478bd9Sstevel@tonic-gate }
4805ced83f9bSceastha Gen.g_attrnam_p = e_strdup(E_EXIT, aname);
48067c478bd9Sstevel@tonic-gate
4807ced83f9bSceastha if (attrparent != NULL) {
4808ced83f9bSceastha if (Renam_attr_p && Renam_attr_p[0] != '\0') {
4809ced83f9bSceastha size_t apathlen = strlen(attrparent) +
4810ced83f9bSceastha strlen(aname) + 2;
4811ced83f9bSceastha Gen.g_attrparent_p = e_strdup(E_EXIT,
4812ced83f9bSceastha Renam_attr_p);
4813ced83f9bSceastha Gen.g_attrpath_p = e_zalloc(E_EXIT,
4814ced83f9bSceastha apathlen);
4815ced83f9bSceastha (void) snprintf(Gen.g_attrpath_p,
4816ced83f9bSceastha apathlen, "%s/%s", Renam_attr_p,
4817ced83f9bSceastha aname);
4818ced83f9bSceastha (void) free(attrparent);
4819ced83f9bSceastha (void) free(attrpath);
4820ced83f9bSceastha } else {
4821ced83f9bSceastha Gen.g_attrparent_p = attrparent;
4822ced83f9bSceastha Gen.g_attrpath_p = attrpath;
4823ced83f9bSceastha }
4824ced83f9bSceastha } else {
4825ced83f9bSceastha Gen.g_attrpath_p = attrpath;
4826ced83f9bSceastha }
48277c478bd9Sstevel@tonic-gate
4828ced83f9bSceastha if (xattr_linkp != NULL) {
4829ced83f9bSceastha if (Gen.g_linktoattrfnam_p != NULL) {
4830ced83f9bSceastha free(Gen.g_linktoattrfnam_p);
4831ced83f9bSceastha Gen.g_linktoattrfnam_p = NULL;
4832ced83f9bSceastha }
4833ced83f9bSceastha if (Gen.g_linktoattrnam_p != NULL) {
4834ced83f9bSceastha free(Gen.g_linktoattrnam_p);
4835ced83f9bSceastha Gen.g_linktoattrnam_p = NULL;
4836ced83f9bSceastha }
4837ced83f9bSceastha if (Renam_attr_p && Renam_attr_p[0] != '\0') {
4838ced83f9bSceastha Gen.g_linktoattrfnam_p = e_strdup(
4839ced83f9bSceastha E_EXIT, Renam_attr_p);
4840ced83f9bSceastha } else {
4841ced83f9bSceastha Gen.g_linktoattrfnam_p = e_strdup(
4842ced83f9bSceastha E_EXIT, xattr_linkp->h_names);
4843ced83f9bSceastha }
4844ced83f9bSceastha Gen.g_linktoattrnam_p = e_strdup(E_EXIT,
4845ced83f9bSceastha aname);
4846ced83f9bSceastha xattr_linkp = NULL;
4847ced83f9bSceastha }
48487c478bd9Sstevel@tonic-gate if (Hdr_type != USTAR && Hdr_type != TAR) {
48497c478bd9Sstevel@tonic-gate Gen.g_mode = Gen.g_mode & (~_XATTR_CPIO_MODE);
48507c478bd9Sstevel@tonic-gate Gen.g_mode |= attrmode(xattrp->h_typeflag);
48517c478bd9Sstevel@tonic-gate } else if (Hdr_type == USTAR || Hdr_type == TAR) {
48527c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_typeflag = xattrp->h_typeflag;
48537c478bd9Sstevel@tonic-gate }
4854ced83f9bSceastha
48557c478bd9Sstevel@tonic-gate ftype = Gen.g_mode & Ftype;
48567c478bd9Sstevel@tonic-gate Adir = ftype == S_IFDIR;
4857cdd68f5aSceastha Aspec = (ftype == S_IFBLK || ftype == S_IFCHR ||
4858cdd68f5aSceastha ftype == S_IFIFO || ftype == S_IFSOCK);
48597c478bd9Sstevel@tonic-gate
48607c478bd9Sstevel@tonic-gate if (Gen.g_attrnam_p[0] == '.' &&
48617c478bd9Sstevel@tonic-gate Gen.g_attrnam_p[1] == '\0' &&
48627c478bd9Sstevel@tonic-gate xattrp->h_typeflag == DIRTYPE) {
48637c478bd9Sstevel@tonic-gate Hiddendir = 1;
48647c478bd9Sstevel@tonic-gate } else {
48657c478bd9Sstevel@tonic-gate Hiddendir = 0;
48667c478bd9Sstevel@tonic-gate }
48677c478bd9Sstevel@tonic-gate
48687c478bd9Sstevel@tonic-gate free(xattrhead);
48697c478bd9Sstevel@tonic-gate xattrhead = NULL;
48707c478bd9Sstevel@tonic-gate xattrp = NULL;
48717c478bd9Sstevel@tonic-gate } else {
48727c478bd9Sstevel@tonic-gate if (xattrbadhead == 0) {
48737c478bd9Sstevel@tonic-gate (void) read_xattr_hdr();
48747c478bd9Sstevel@tonic-gate return (2);
48757c478bd9Sstevel@tonic-gate }
48767c478bd9Sstevel@tonic-gate }
4877ced83f9bSceastha } else {
4878ced83f9bSceastha Hiddendir = 0;
48797c478bd9Sstevel@tonic-gate }
48807c478bd9Sstevel@tonic-gate #endif /* O_XATTR */
48817c478bd9Sstevel@tonic-gate
48827c478bd9Sstevel@tonic-gate /* acl support: grab acl info */
48837c478bd9Sstevel@tonic-gate if ((Gen.g_mode == SECMODE) || ((Hdr_type == USTAR ||
48847c478bd9Sstevel@tonic-gate Hdr_type == TAR) && Thdr_p->tbuf.t_typeflag == 'A')) {
48857c478bd9Sstevel@tonic-gate /* this is an ancillary file */
48867c478bd9Sstevel@tonic-gate off_t bytes;
48877c478bd9Sstevel@tonic-gate char *secp;
48887c478bd9Sstevel@tonic-gate int pad;
48897c478bd9Sstevel@tonic-gate int cnt;
48907c478bd9Sstevel@tonic-gate char *tp;
48910b9a5158SToomas Soome int attrsize = 0;
48927c478bd9Sstevel@tonic-gate
48937c478bd9Sstevel@tonic-gate if (Pflag) {
48947c478bd9Sstevel@tonic-gate bytes = Gen.g_filesz;
48957c478bd9Sstevel@tonic-gate secp = e_zalloc(E_EXIT, (uint_t)bytes);
48967c478bd9Sstevel@tonic-gate tp = secp;
48977c478bd9Sstevel@tonic-gate
48987c478bd9Sstevel@tonic-gate while (bytes > 0) {
48997c478bd9Sstevel@tonic-gate cnt = (int)(bytes > CPIOBSZ) ? CPIOBSZ : bytes;
49007c478bd9Sstevel@tonic-gate FILL(cnt);
49017c478bd9Sstevel@tonic-gate (void) memcpy(tp, Buffr.b_out_p, cnt);
49027c478bd9Sstevel@tonic-gate tp += cnt;
49037c478bd9Sstevel@tonic-gate Buffr.b_out_p += cnt;
49047c478bd9Sstevel@tonic-gate Buffr.b_cnt -= (off_t)cnt;
49057c478bd9Sstevel@tonic-gate bytes -= (off_t)cnt;
49067c478bd9Sstevel@tonic-gate }
49077c478bd9Sstevel@tonic-gate
49087c478bd9Sstevel@tonic-gate pad = (Pad_val + 1 - (Gen.g_filesz & Pad_val)) &
49097c478bd9Sstevel@tonic-gate Pad_val;
49107c478bd9Sstevel@tonic-gate if (pad != 0) {
49117c478bd9Sstevel@tonic-gate FILL(pad);
49127c478bd9Sstevel@tonic-gate Buffr.b_out_p += pad;
49137c478bd9Sstevel@tonic-gate Buffr.b_cnt -= (off_t)pad;
49147c478bd9Sstevel@tonic-gate }
49157c478bd9Sstevel@tonic-gate
49167c478bd9Sstevel@tonic-gate /* got all attributes in secp */
49177c478bd9Sstevel@tonic-gate tp = secp;
49187c478bd9Sstevel@tonic-gate do {
49197c478bd9Sstevel@tonic-gate attr = (struct sec_attr *)tp;
49207c478bd9Sstevel@tonic-gate switch (attr->attr_type) {
49217c478bd9Sstevel@tonic-gate case UFSD_ACL:
4922fa9e4066Sahrens case ACE_ACL:
4923*6d3b960aSAndy Fiddaman (void) sscanf(attr->attr_len, "%7o",
4924*6d3b960aSAndy Fiddaman (uint_t *)&aclcnt);
49257c478bd9Sstevel@tonic-gate /* header is 8 */
49267c478bd9Sstevel@tonic-gate attrsize = 8 +
49277c478bd9Sstevel@tonic-gate strlen(&attr->attr_info[0])
49287c478bd9Sstevel@tonic-gate + 1;
4929fa9e4066Sahrens
4930fa9e4066Sahrens error =
4931fa9e4066Sahrens acl_fromtext(&attr->attr_info[0],
4932fa9e4066Sahrens &aclp);
4933fa9e4066Sahrens
4934fa9e4066Sahrens if (error != 0) {
4935fa9e4066Sahrens msg(ERR,
4936fa9e4066Sahrens "aclfromtext failed: %s",
4937fa9e4066Sahrens acl_strerror(error));
4938fa9e4066Sahrens bytes -= attrsize;
49397c478bd9Sstevel@tonic-gate break;
49407c478bd9Sstevel@tonic-gate }
4941fa9e4066Sahrens
4942fa9e4066Sahrens if (aclcnt != acl_cnt(aclp)) {
49437c478bd9Sstevel@tonic-gate msg(ERR, "acl count error");
4944fa9e4066Sahrens bytes -= attrsize;
49457c478bd9Sstevel@tonic-gate break;
49467c478bd9Sstevel@tonic-gate }
49477c478bd9Sstevel@tonic-gate bytes -= attrsize;
49487c478bd9Sstevel@tonic-gate break;
49497c478bd9Sstevel@tonic-gate
49507c478bd9Sstevel@tonic-gate /* SunFed case goes here */
49517c478bd9Sstevel@tonic-gate
49527c478bd9Sstevel@tonic-gate default:
49537c478bd9Sstevel@tonic-gate msg(EXT, "unrecognized attr type");
49547c478bd9Sstevel@tonic-gate break;
49557c478bd9Sstevel@tonic-gate }
49567c478bd9Sstevel@tonic-gate /* next attributes */
49577c478bd9Sstevel@tonic-gate tp += attrsize;
49587c478bd9Sstevel@tonic-gate } while (bytes > 0);
49597c478bd9Sstevel@tonic-gate free(secp);
49607c478bd9Sstevel@tonic-gate } else {
49617c478bd9Sstevel@tonic-gate /* skip security info */
49627c478bd9Sstevel@tonic-gate G_p = &Gen;
49637c478bd9Sstevel@tonic-gate data_in(P_SKIP);
49647c478bd9Sstevel@tonic-gate }
49657c478bd9Sstevel@tonic-gate /*
49667c478bd9Sstevel@tonic-gate * We already got the file content, dont call file_in()
49677c478bd9Sstevel@tonic-gate * when return. The new return code(2) is used to
49687c478bd9Sstevel@tonic-gate * indicate that.
49697c478bd9Sstevel@tonic-gate */
49707c478bd9Sstevel@tonic-gate VERBOSE((Args & OCt), Gen.g_nam_p);
49717c478bd9Sstevel@tonic-gate return (2);
49727c478bd9Sstevel@tonic-gate } /* acl */
49737c478bd9Sstevel@tonic-gate
49745fbb8099SNobutomo Nakano /*
49755fbb8099SNobutomo Nakano * Sparse file support
49765fbb8099SNobutomo Nakano * Read header of holesdata to get original file size.
49775fbb8099SNobutomo Nakano * This is necessary because ckname() or file_in() shows file size
49785fbb8099SNobutomo Nakano * with OCt before data_in() extracts the holesdata. data_in()
49795fbb8099SNobutomo Nakano * actually doesn't extract the holesdata since proc_mode will be
49805fbb8099SNobutomo Nakano * P_SKIP in the OCt mode.
49815fbb8099SNobutomo Nakano */
49825fbb8099SNobutomo Nakano if ((Hdr_type == CHR || Hdr_type == ASC) &&
49835fbb8099SNobutomo Nakano S_ISSPARSE(Gen.g_mode) && Gen.g_filesz > MIN_HOLES_HDRSIZE) {
49845fbb8099SNobutomo Nakano char holesdata[MIN_HOLES_HDRSIZE + 1];
49855fbb8099SNobutomo Nakano
49865fbb8099SNobutomo Nakano FILL(MIN_HOLES_HDRSIZE);
49875fbb8099SNobutomo Nakano (void) memcpy(holesdata, Buffr.b_out_p, MIN_HOLES_HDRSIZE);
49885fbb8099SNobutomo Nakano holesdata[MIN_HOLES_HDRSIZE] = '\0';
49895fbb8099SNobutomo Nakano
49905fbb8099SNobutomo Nakano Gen.g_holes = read_holes_header(holesdata, Gen.g_filesz);
49915fbb8099SNobutomo Nakano if (Gen.g_holes == NULL) {
49925fbb8099SNobutomo Nakano msg(EXT, "invalid sparse file information");
49935fbb8099SNobutomo Nakano } else {
49945fbb8099SNobutomo Nakano Buffr.b_out_p += MIN_HOLES_HDRSIZE;
49955fbb8099SNobutomo Nakano Buffr.b_cnt -= MIN_HOLES_HDRSIZE;
49965fbb8099SNobutomo Nakano }
49975fbb8099SNobutomo Nakano }
49985fbb8099SNobutomo Nakano
49997c478bd9Sstevel@tonic-gate Adir = (ftype == S_IFDIR);
5000cdd68f5aSceastha Aspec = (ftype == S_IFBLK || ftype == S_IFCHR || ftype == S_IFIFO ||
5001cdd68f5aSceastha ftype == S_IFSOCK);
50027c478bd9Sstevel@tonic-gate
50037c478bd9Sstevel@tonic-gate /*
50047c478bd9Sstevel@tonic-gate * Skip any trailing slashes
50057c478bd9Sstevel@tonic-gate */
50067c478bd9Sstevel@tonic-gate chop_endslashes(Gen.g_nam_p);
50077c478bd9Sstevel@tonic-gate return (1);
50087c478bd9Sstevel@tonic-gate }
50097c478bd9Sstevel@tonic-gate
50107c478bd9Sstevel@tonic-gate /*
50117c478bd9Sstevel@tonic-gate * getname: Get file names for inclusion in the archive. When end of file
50127c478bd9Sstevel@tonic-gate * on the input stream of file names is reached, flush the link buffer out.
50137c478bd9Sstevel@tonic-gate * For each filename, remove leading "./"s and multiple "/"s, and remove
5014da6c28aaSamw * any trailing newline "\n". Finally, verify the existence of the file,
50157c478bd9Sstevel@tonic-gate * and call creat_hdr() to fill in the gen_hdr structure.
50167c478bd9Sstevel@tonic-gate */
50177c478bd9Sstevel@tonic-gate
50187c478bd9Sstevel@tonic-gate static int
getname(void)50197c478bd9Sstevel@tonic-gate getname(void)
50207c478bd9Sstevel@tonic-gate {
50217c478bd9Sstevel@tonic-gate int goodfile = 0, lastchar, err;
50227c478bd9Sstevel@tonic-gate char *s;
50237c478bd9Sstevel@tonic-gate char *dir;
50247c478bd9Sstevel@tonic-gate
50257c478bd9Sstevel@tonic-gate Gen.g_nam_p = Nam_p;
5026ced83f9bSceastha Hiddendir = 0;
50277c478bd9Sstevel@tonic-gate
50287c478bd9Sstevel@tonic-gate while (!goodfile) {
50297c478bd9Sstevel@tonic-gate err = 0;
50307c478bd9Sstevel@tonic-gate
5031ced83f9bSceastha while ((s = fgets(Gen.g_nam_p, APATH+1, In_p)) != NULL) {
50327c478bd9Sstevel@tonic-gate lastchar = strlen(s) - 1;
50337c478bd9Sstevel@tonic-gate issymlink = 0;
50347c478bd9Sstevel@tonic-gate
50357c478bd9Sstevel@tonic-gate if (s[lastchar] != '\n') {
50367c478bd9Sstevel@tonic-gate if (lastchar == APATH - 1) {
50377c478bd9Sstevel@tonic-gate if (!err) {
50387c478bd9Sstevel@tonic-gate msg(ERR,
50397c478bd9Sstevel@tonic-gate "%s name too long.",
50407c478bd9Sstevel@tonic-gate Nam_p);
50417c478bd9Sstevel@tonic-gate }
50427c478bd9Sstevel@tonic-gate goodfile = 0;
50437c478bd9Sstevel@tonic-gate err = 1;
50447c478bd9Sstevel@tonic-gate } else {
50457c478bd9Sstevel@tonic-gate break;
50467c478bd9Sstevel@tonic-gate }
50477c478bd9Sstevel@tonic-gate } else {
50487c478bd9Sstevel@tonic-gate s[lastchar] = '\0';
50497c478bd9Sstevel@tonic-gate break;
50507c478bd9Sstevel@tonic-gate }
50517c478bd9Sstevel@tonic-gate }
50527c478bd9Sstevel@tonic-gate
5053ced83f9bSceastha if (s == NULL) {
50547c478bd9Sstevel@tonic-gate if (Gen.g_dirfd != -1) {
50557c478bd9Sstevel@tonic-gate (void) close(Gen.g_dirfd);
50567c478bd9Sstevel@tonic-gate Gen.g_dirfd = -1;
50577c478bd9Sstevel@tonic-gate }
50587c478bd9Sstevel@tonic-gate if (Onecopy && (Args & OCo)) {
50597c478bd9Sstevel@tonic-gate flush_lnks();
50607c478bd9Sstevel@tonic-gate }
50617c478bd9Sstevel@tonic-gate return (0);
50627c478bd9Sstevel@tonic-gate }
50637c478bd9Sstevel@tonic-gate
50647c478bd9Sstevel@tonic-gate while (*Gen.g_nam_p == '.' && Gen.g_nam_p[1] == '/') {
50657c478bd9Sstevel@tonic-gate Gen.g_nam_p += 2;
50667c478bd9Sstevel@tonic-gate while (*Gen.g_nam_p == '/')
50677c478bd9Sstevel@tonic-gate Gen.g_nam_p++;
50687c478bd9Sstevel@tonic-gate }
50697c478bd9Sstevel@tonic-gate
50707c478bd9Sstevel@tonic-gate /*
50717c478bd9Sstevel@tonic-gate * Skip any trailing slashes
50727c478bd9Sstevel@tonic-gate */
50737c478bd9Sstevel@tonic-gate chop_endslashes(Gen.g_nam_p);
50747c478bd9Sstevel@tonic-gate
50757c478bd9Sstevel@tonic-gate /*
50767c478bd9Sstevel@tonic-gate * Figure out parent directory
50777c478bd9Sstevel@tonic-gate */
50787c478bd9Sstevel@tonic-gate
5079ced83f9bSceastha if (Gen.g_attrnam_p != NULL) {
50807c478bd9Sstevel@tonic-gate if (Gen.g_dirfd != -1) {
50817c478bd9Sstevel@tonic-gate (void) close(Gen.g_dirfd);
50827c478bd9Sstevel@tonic-gate }
50837c478bd9Sstevel@tonic-gate Gen.g_dirfd = attropen(Gen.g_attrfnam_p, ".", O_RDONLY);
50847c478bd9Sstevel@tonic-gate if (Gen.g_dirfd == -1) {
50857c478bd9Sstevel@tonic-gate msg(ERRN,
50867c478bd9Sstevel@tonic-gate "Cannot open attribute directory"
50877c478bd9Sstevel@tonic-gate " of file %s", Gen.g_attrfnam_p);
50887c478bd9Sstevel@tonic-gate continue;
50897c478bd9Sstevel@tonic-gate }
50907c478bd9Sstevel@tonic-gate } else {
50917c478bd9Sstevel@tonic-gate #ifdef O_XATTR
50927c478bd9Sstevel@tonic-gate char dirpath[PATH_MAX];
50937c478bd9Sstevel@tonic-gate
50947c478bd9Sstevel@tonic-gate get_parent(Gen.g_nam_p, dirpath);
5095ced83f9bSceastha if (Atflag || SysAtflag) {
50967c478bd9Sstevel@tonic-gate dir = dirpath;
50977c478bd9Sstevel@tonic-gate if (Gen.g_dirfd != -1) {
50987c478bd9Sstevel@tonic-gate (void) close(Gen.g_dirfd);
50997c478bd9Sstevel@tonic-gate }
51007c478bd9Sstevel@tonic-gate Gen.g_dirfd = open(dir, O_RDONLY);
51017c478bd9Sstevel@tonic-gate if (Gen.g_dirfd == -1) {
51027c478bd9Sstevel@tonic-gate msg(ERRN,
51037c478bd9Sstevel@tonic-gate "Cannot open directory %s", dir);
51047c478bd9Sstevel@tonic-gate continue;
51057c478bd9Sstevel@tonic-gate }
51067c478bd9Sstevel@tonic-gate } else {
51077c478bd9Sstevel@tonic-gate /*
51087c478bd9Sstevel@tonic-gate * g_dirpath is the pathname cache maintaining
51097c478bd9Sstevel@tonic-gate * the dirname which is currently opened.
51107c478bd9Sstevel@tonic-gate * We first check the g_dirpath to see if the
51117c478bd9Sstevel@tonic-gate * given dirname matches. If so, we don't need
51127c478bd9Sstevel@tonic-gate * to open the dir, but we can use the g_dirfd
51137c478bd9Sstevel@tonic-gate * as is if it is still available.
51147c478bd9Sstevel@tonic-gate */
51157c478bd9Sstevel@tonic-gate dir = NULL;
51167c478bd9Sstevel@tonic-gate if (Gen.g_dirpath == NULL ||
51177c478bd9Sstevel@tonic-gate Gen.g_dirfd == -1) {
51187c478bd9Sstevel@tonic-gate /*
51197c478bd9Sstevel@tonic-gate * It's the first time or it has
51207c478bd9Sstevel@tonic-gate * all gone.
51217c478bd9Sstevel@tonic-gate */
51227c478bd9Sstevel@tonic-gate dir = e_strdup(E_EXIT, dirpath);
51237c478bd9Sstevel@tonic-gate } else {
51247c478bd9Sstevel@tonic-gate if (strcmp(Gen.g_dirpath,
51257c478bd9Sstevel@tonic-gate dirpath) != 0) {
51267c478bd9Sstevel@tonic-gate /* different directory */
51277c478bd9Sstevel@tonic-gate dir = e_strdup(E_EXIT, dirpath);
51287c478bd9Sstevel@tonic-gate }
51297c478bd9Sstevel@tonic-gate }
51307c478bd9Sstevel@tonic-gate if (dir != NULL) {
51317c478bd9Sstevel@tonic-gate /*
51327c478bd9Sstevel@tonic-gate * We need to open the new directory.
51337c478bd9Sstevel@tonic-gate * discard the pathname and dirfd
51347c478bd9Sstevel@tonic-gate * for the previous directory.
51357c478bd9Sstevel@tonic-gate */
51367c478bd9Sstevel@tonic-gate if (Gen.g_dirpath != NULL) {
51377c478bd9Sstevel@tonic-gate free(Gen.g_dirpath);
51387c478bd9Sstevel@tonic-gate Gen.g_dirpath = NULL;
51397c478bd9Sstevel@tonic-gate }
51407c478bd9Sstevel@tonic-gate if (Gen.g_dirfd != -1) {
51417c478bd9Sstevel@tonic-gate (void) close(Gen.g_dirfd);
51427c478bd9Sstevel@tonic-gate }
51437c478bd9Sstevel@tonic-gate /* open the new dir */
51447c478bd9Sstevel@tonic-gate Gen.g_dirfd = open(dir, O_RDONLY);
51457c478bd9Sstevel@tonic-gate if (Gen.g_dirfd == -1) {
51467c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot open "
51477c478bd9Sstevel@tonic-gate "directory %s", dir);
51487c478bd9Sstevel@tonic-gate continue;
51497c478bd9Sstevel@tonic-gate }
51507c478bd9Sstevel@tonic-gate Gen.g_dirpath = dir;
51517c478bd9Sstevel@tonic-gate }
51527c478bd9Sstevel@tonic-gate }
51537c478bd9Sstevel@tonic-gate #else
51547c478bd9Sstevel@tonic-gate Gen.g_dirfd = -1;
51557c478bd9Sstevel@tonic-gate #endif
51567c478bd9Sstevel@tonic-gate }
51577c478bd9Sstevel@tonic-gate
51587c478bd9Sstevel@tonic-gate /* creat_hdr checks for USTAR filename length */
51597c478bd9Sstevel@tonic-gate
51607c478bd9Sstevel@tonic-gate if (Hdr_type != USTAR && strlen(Gen.g_nam_p) >
51617c478bd9Sstevel@tonic-gate Max_namesz) {
51627c478bd9Sstevel@tonic-gate if (!err) {
51637c478bd9Sstevel@tonic-gate msg(ERR, "%s%s%s name too long.",
5164ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
51657c478bd9Sstevel@tonic-gate Nam_p : Gen.g_attrfnam_p,
5166ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
5167ced83f9bSceastha "" : Gen.g_rw_sysattr ?
5168ced83f9bSceastha gettext(" System Attribute ") :
5169ced83f9bSceastha gettext(" Attribute "),
5170ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
51717c478bd9Sstevel@tonic-gate "" : Gen.g_attrnam_p);
51727c478bd9Sstevel@tonic-gate }
51737c478bd9Sstevel@tonic-gate goodfile = 0;
51747c478bd9Sstevel@tonic-gate err = 1;
51757c478bd9Sstevel@tonic-gate }
51767c478bd9Sstevel@tonic-gate
51777c478bd9Sstevel@tonic-gate if (err) {
51787c478bd9Sstevel@tonic-gate continue;
51797c478bd9Sstevel@tonic-gate } else {
51807c478bd9Sstevel@tonic-gate G_p = &Gen;
51817c478bd9Sstevel@tonic-gate if (!LSTAT(Gen.g_dirfd, Gen.g_nam_p, &SrcSt)) {
51827c478bd9Sstevel@tonic-gate goodfile = 1;
51837c478bd9Sstevel@tonic-gate
51847c478bd9Sstevel@tonic-gate if ((SrcSt.st_mode & Ftype) == S_IFLNK) {
51857c478bd9Sstevel@tonic-gate issymlink = 1;
51867c478bd9Sstevel@tonic-gate
51877c478bd9Sstevel@tonic-gate if ((Args & OCL)) {
51887c478bd9Sstevel@tonic-gate errno = 0;
51897c478bd9Sstevel@tonic-gate if (STAT(Gen.g_dirfd,
51907c478bd9Sstevel@tonic-gate G_p->g_nam_p,
51917c478bd9Sstevel@tonic-gate &SrcSt) < 0) {
51927c478bd9Sstevel@tonic-gate msg(ERRN,
51937c478bd9Sstevel@tonic-gate "Cannot follow"
51947c478bd9Sstevel@tonic-gate " \"%s%s%s\"",
51957c478bd9Sstevel@tonic-gate (Gen.g_attrnam_p ==
5196ced83f9bSceastha NULL) ?
51977c478bd9Sstevel@tonic-gate Gen.g_nam_p :
51987c478bd9Sstevel@tonic-gate Gen.g_attrfnam_p,
51997c478bd9Sstevel@tonic-gate (Gen.g_attrnam_p ==
5200ced83f9bSceastha NULL) ? "" :
5201ced83f9bSceastha Gen.g_rw_sysattr ?
5202ced83f9bSceastha gettext(
5203ced83f9bSceastha " System "
5204ced83f9bSceastha "Attribute ") :
52057c478bd9Sstevel@tonic-gate gettext(
52067c478bd9Sstevel@tonic-gate " Attribute "),
52077c478bd9Sstevel@tonic-gate (Gen.g_attrnam_p ==
5208ced83f9bSceastha NULL) ? "" :
52097c478bd9Sstevel@tonic-gate Gen.g_attrnam_p);
52107c478bd9Sstevel@tonic-gate goodfile = 0;
52117c478bd9Sstevel@tonic-gate }
52127c478bd9Sstevel@tonic-gate }
52137c478bd9Sstevel@tonic-gate }
52147c478bd9Sstevel@tonic-gate
52157c478bd9Sstevel@tonic-gate if (Use_old_stat) {
52167c478bd9Sstevel@tonic-gate OldSt = convert_to_old_stat(&SrcSt,
52177c478bd9Sstevel@tonic-gate Gen.g_nam_p, Gen.g_attrnam_p);
52187c478bd9Sstevel@tonic-gate
52197c478bd9Sstevel@tonic-gate if (OldSt == NULL) {
52207c478bd9Sstevel@tonic-gate goodfile = 0;
52217c478bd9Sstevel@tonic-gate }
52227c478bd9Sstevel@tonic-gate }
52237c478bd9Sstevel@tonic-gate } else {
52247c478bd9Sstevel@tonic-gate msg(ERRN,
52257c478bd9Sstevel@tonic-gate "Error with fstatat() of \"%s%s%s\"",
5226ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
52277c478bd9Sstevel@tonic-gate Gen.g_nam_p : Gen.g_attrfnam_p,
5228ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? "" :
5229ced83f9bSceastha Gen.g_rw_sysattr ?
5230ced83f9bSceastha gettext(" System Attribute ") :
5231ced83f9bSceastha gettext(" Attribute "),
5232ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
52337c478bd9Sstevel@tonic-gate "" : Gen.g_attrnam_p);
52347c478bd9Sstevel@tonic-gate }
52357c478bd9Sstevel@tonic-gate }
52367c478bd9Sstevel@tonic-gate }
52377c478bd9Sstevel@tonic-gate
52387c478bd9Sstevel@tonic-gate /*
52397c478bd9Sstevel@tonic-gate * Get ACL info: dont bother allocating space if there are only
52407c478bd9Sstevel@tonic-gate * standard permissions, i.e. ACL count < 4
52417c478bd9Sstevel@tonic-gate */
52427c478bd9Sstevel@tonic-gate if ((SrcSt.st_mode & Ftype) != S_IFLNK && Pflag) {
5243fa9e4066Sahrens if (acl_get(Gen.g_nam_p, ACL_NO_TRIVIAL, &aclp) != 0)
52447c478bd9Sstevel@tonic-gate msg(ERRN, "Error with acl() of \"%s\"", Gen.g_nam_p);
52457c478bd9Sstevel@tonic-gate }
52467c478bd9Sstevel@tonic-gate /* else: only traditional permissions, so proceed as usual */
52477c478bd9Sstevel@tonic-gate if (creat_hdr())
52487c478bd9Sstevel@tonic-gate return (1);
52497c478bd9Sstevel@tonic-gate else return (2);
52507c478bd9Sstevel@tonic-gate }
52517c478bd9Sstevel@tonic-gate
52527c478bd9Sstevel@tonic-gate /*
52537c478bd9Sstevel@tonic-gate * getpats: Save any filenames/patterns specified as arguments.
52547c478bd9Sstevel@tonic-gate * Read additional filenames/patterns from the file specified by the
52557c478bd9Sstevel@tonic-gate * user. The filenames/patterns must occur one per line.
52567c478bd9Sstevel@tonic-gate */
52577c478bd9Sstevel@tonic-gate
52587c478bd9Sstevel@tonic-gate static void
getpats(int largc,char ** largv)52597c478bd9Sstevel@tonic-gate getpats(int largc, char **largv)
52607c478bd9Sstevel@tonic-gate {
52617c478bd9Sstevel@tonic-gate char **t_pp;
52627c478bd9Sstevel@tonic-gate size_t len;
52637c478bd9Sstevel@tonic-gate unsigned numpat = largc, maxpat = largc + 2;
52647c478bd9Sstevel@tonic-gate
52657c478bd9Sstevel@tonic-gate Pat_pp = e_zalloc(E_EXIT, maxpat * sizeof (char *));
52667c478bd9Sstevel@tonic-gate t_pp = Pat_pp;
52677c478bd9Sstevel@tonic-gate while (*largv) {
52687c478bd9Sstevel@tonic-gate *t_pp = e_zalloc(E_EXIT, strlen(*largv) + 1);
52697c478bd9Sstevel@tonic-gate (void) strcpy(*t_pp, *largv);
52707c478bd9Sstevel@tonic-gate t_pp++;
52717c478bd9Sstevel@tonic-gate largv++;
52727c478bd9Sstevel@tonic-gate }
5273ced83f9bSceastha while (fgets(Nam_p, Max_namesz + 1, Ef_p) != NULL) {
52747c478bd9Sstevel@tonic-gate if (numpat == maxpat - 1) {
52757c478bd9Sstevel@tonic-gate maxpat += 10;
52767c478bd9Sstevel@tonic-gate Pat_pp = e_realloc(E_EXIT, Pat_pp,
52777c478bd9Sstevel@tonic-gate maxpat * sizeof (char *));
52787c478bd9Sstevel@tonic-gate t_pp = Pat_pp + numpat;
52797c478bd9Sstevel@tonic-gate }
52807c478bd9Sstevel@tonic-gate len = strlen(Nam_p); /* includes the \n */
52817c478bd9Sstevel@tonic-gate *(Nam_p + len - 1) = '\0'; /* remove the \n */
52827c478bd9Sstevel@tonic-gate *t_pp = e_zalloc(E_EXIT, len);
52837c478bd9Sstevel@tonic-gate (void) strcpy(*t_pp, Nam_p);
52847c478bd9Sstevel@tonic-gate t_pp++;
52857c478bd9Sstevel@tonic-gate numpat++;
52867c478bd9Sstevel@tonic-gate }
5287ced83f9bSceastha *t_pp = NULL;
52887c478bd9Sstevel@tonic-gate }
52897c478bd9Sstevel@tonic-gate
52907c478bd9Sstevel@tonic-gate static void
ioerror(int dir)52917c478bd9Sstevel@tonic-gate ioerror(int dir)
52927c478bd9Sstevel@tonic-gate {
52937c478bd9Sstevel@tonic-gate int t_errno;
52947c478bd9Sstevel@tonic-gate
52957c478bd9Sstevel@tonic-gate t_errno = errno;
52967c478bd9Sstevel@tonic-gate errno = 0;
52977c478bd9Sstevel@tonic-gate if (fstat(Archive, &ArchSt) < 0)
52987c478bd9Sstevel@tonic-gate msg(EXTN, "Error during stat() of archive");
52997c478bd9Sstevel@tonic-gate errno = t_errno;
53007c478bd9Sstevel@tonic-gate if ((ArchSt.st_mode & Ftype) != S_IFCHR) {
53017c478bd9Sstevel@tonic-gate if (dir) {
53027c478bd9Sstevel@tonic-gate if (errno == EFBIG)
53037c478bd9Sstevel@tonic-gate msg(EXT, "ulimit reached for output file.");
53047c478bd9Sstevel@tonic-gate else if (errno == ENOSPC)
53057c478bd9Sstevel@tonic-gate msg(EXT, "No space left for output file.");
53067c478bd9Sstevel@tonic-gate else
53077c478bd9Sstevel@tonic-gate msg(EXTN, "I/O error - cannot continue");
53087c478bd9Sstevel@tonic-gate } else
53097c478bd9Sstevel@tonic-gate msg(EXT, "Unexpected end-of-file encountered.");
53107c478bd9Sstevel@tonic-gate } else
53117c478bd9Sstevel@tonic-gate msg(EXTN, "\007I/O error on \"%s\"", dir ? "output" : "input");
53127c478bd9Sstevel@tonic-gate }
53137c478bd9Sstevel@tonic-gate
53147c478bd9Sstevel@tonic-gate /*
53157c478bd9Sstevel@tonic-gate * matched: Determine if a filename matches the specified pattern(s). If the
53167c478bd9Sstevel@tonic-gate * pattern is matched (the second return), return 0 if -f was specified, else
53177c478bd9Sstevel@tonic-gate * return != 0. If the pattern is not matched (the first and third
53187c478bd9Sstevel@tonic-gate * returns), return 0 if -f was not specified, else return != 0.
53197c478bd9Sstevel@tonic-gate */
53207c478bd9Sstevel@tonic-gate
53217c478bd9Sstevel@tonic-gate static int
matched(void)53227c478bd9Sstevel@tonic-gate matched(void)
53237c478bd9Sstevel@tonic-gate {
53247c478bd9Sstevel@tonic-gate char *str_p = G_p->g_nam_p;
53257c478bd9Sstevel@tonic-gate char **pat_pp = Pat_pp;
53267c478bd9Sstevel@tonic-gate int negatep, result;
53277c478bd9Sstevel@tonic-gate
53287c478bd9Sstevel@tonic-gate /*
53297c478bd9Sstevel@tonic-gate * Check for attribute
53307c478bd9Sstevel@tonic-gate */
5331ced83f9bSceastha if (G_p->g_attrfnam_p != NULL)
53327c478bd9Sstevel@tonic-gate str_p = G_p->g_attrfnam_p;
53337c478bd9Sstevel@tonic-gate
53347c478bd9Sstevel@tonic-gate for (pat_pp = Pat_pp; *pat_pp; pat_pp++) {
53357c478bd9Sstevel@tonic-gate negatep = (**pat_pp == '!');
53367c478bd9Sstevel@tonic-gate
53377c478bd9Sstevel@tonic-gate result = fnmatch(negatep ? (*pat_pp+1) : *pat_pp, str_p, 0);
53387c478bd9Sstevel@tonic-gate
53397c478bd9Sstevel@tonic-gate if (result != 0 && result != FNM_NOMATCH) {
53407c478bd9Sstevel@tonic-gate msg(POST, "error matching file %s with pattern"
53417c478bd9Sstevel@tonic-gate " %s\n", str_p, *pat_pp);
53427c478bd9Sstevel@tonic-gate return (Args & OCf);
53437c478bd9Sstevel@tonic-gate }
53447c478bd9Sstevel@tonic-gate
53457c478bd9Sstevel@tonic-gate if ((result == 0 && ! negatep) ||
53467c478bd9Sstevel@tonic-gate (result == FNM_NOMATCH && negatep)) {
5347da6c28aaSamw /* match occurred */
53487c478bd9Sstevel@tonic-gate return (!(Args & OCf));
53497c478bd9Sstevel@tonic-gate }
53507c478bd9Sstevel@tonic-gate }
53517c478bd9Sstevel@tonic-gate return (Args & OCf); /* not matched */
53527c478bd9Sstevel@tonic-gate }
53537c478bd9Sstevel@tonic-gate
53547c478bd9Sstevel@tonic-gate /*
53557c478bd9Sstevel@tonic-gate * missdir: Create missing directories for files.
53567c478bd9Sstevel@tonic-gate * (Possible future performance enhancement, if missdir is called, we know
53577c478bd9Sstevel@tonic-gate * that at least the very last directory of the path does not exist, therefore,
53587c478bd9Sstevel@tonic-gate * scan the path from the end
53597c478bd9Sstevel@tonic-gate */
53607c478bd9Sstevel@tonic-gate
53617c478bd9Sstevel@tonic-gate static int
missdir(char * nam_p)53627c478bd9Sstevel@tonic-gate missdir(char *nam_p)
53637c478bd9Sstevel@tonic-gate {
53647c478bd9Sstevel@tonic-gate char *c_p;
53657c478bd9Sstevel@tonic-gate int cnt = 2;
53667c478bd9Sstevel@tonic-gate char *lastp;
53677c478bd9Sstevel@tonic-gate
53687c478bd9Sstevel@tonic-gate if (*(c_p = nam_p) == '/') /* skip over 'root slash' */
53697c478bd9Sstevel@tonic-gate c_p++;
53707c478bd9Sstevel@tonic-gate
53717c478bd9Sstevel@tonic-gate lastp = c_p + strlen(nam_p) - 1;
53727c478bd9Sstevel@tonic-gate if (*lastp == '/')
53737c478bd9Sstevel@tonic-gate *lastp = '\0';
53747c478bd9Sstevel@tonic-gate
53757c478bd9Sstevel@tonic-gate for (; *c_p; ++c_p) {
53767c478bd9Sstevel@tonic-gate if (*c_p == '/') {
53777c478bd9Sstevel@tonic-gate *c_p = '\0';
53787c478bd9Sstevel@tonic-gate if (stat(nam_p, &DesSt) < 0) {
53797c478bd9Sstevel@tonic-gate if (Args & OCd) {
53807c478bd9Sstevel@tonic-gate cnt = mkdir(nam_p, Def_mode);
53817c478bd9Sstevel@tonic-gate if (cnt != 0) {
53827c478bd9Sstevel@tonic-gate *c_p = '/';
53837c478bd9Sstevel@tonic-gate return (cnt);
53847c478bd9Sstevel@tonic-gate }
53857c478bd9Sstevel@tonic-gate } else {
53867c478bd9Sstevel@tonic-gate msg(ERR, "Missing -d option.");
53877c478bd9Sstevel@tonic-gate *c_p = '/';
53887c478bd9Sstevel@tonic-gate return (-1);
53897c478bd9Sstevel@tonic-gate }
53907c478bd9Sstevel@tonic-gate }
53917c478bd9Sstevel@tonic-gate *c_p = '/';
53927c478bd9Sstevel@tonic-gate }
53937c478bd9Sstevel@tonic-gate }
53947c478bd9Sstevel@tonic-gate if (cnt == 2) /* the file already exists */
53957c478bd9Sstevel@tonic-gate cnt = 0;
53967c478bd9Sstevel@tonic-gate return (cnt);
53977c478bd9Sstevel@tonic-gate }
53987c478bd9Sstevel@tonic-gate
53997c478bd9Sstevel@tonic-gate /*
54007c478bd9Sstevel@tonic-gate * mklong: Convert two shorts into one long. For VAX, Interdata ...
54017c478bd9Sstevel@tonic-gate */
54027c478bd9Sstevel@tonic-gate
54037c478bd9Sstevel@tonic-gate static long
mklong(short v[])54047c478bd9Sstevel@tonic-gate mklong(short v[])
54057c478bd9Sstevel@tonic-gate {
54067c478bd9Sstevel@tonic-gate
54077c478bd9Sstevel@tonic-gate union swpbuf swp_b;
54087c478bd9Sstevel@tonic-gate
54097c478bd9Sstevel@tonic-gate swp_b.s_word = 1;
54107c478bd9Sstevel@tonic-gate if (swp_b.s_byte[0]) {
54117c478bd9Sstevel@tonic-gate swp_b.s_half[0] = v[1];
54127c478bd9Sstevel@tonic-gate swp_b.s_half[1] = v[0];
54137c478bd9Sstevel@tonic-gate } else {
54147c478bd9Sstevel@tonic-gate swp_b.s_half[0] = v[0];
54157c478bd9Sstevel@tonic-gate swp_b.s_half[1] = v[1];
54167c478bd9Sstevel@tonic-gate }
54177c478bd9Sstevel@tonic-gate return (swp_b.s_word);
54187c478bd9Sstevel@tonic-gate }
54197c478bd9Sstevel@tonic-gate
54207c478bd9Sstevel@tonic-gate /*
54217c478bd9Sstevel@tonic-gate * mkshort: Convert a long into 2 shorts, for VAX, Interdata ...
54227c478bd9Sstevel@tonic-gate */
54237c478bd9Sstevel@tonic-gate
54247c478bd9Sstevel@tonic-gate static void
mkshort(short sval[],long v)54257c478bd9Sstevel@tonic-gate mkshort(short sval[], long v)
54267c478bd9Sstevel@tonic-gate {
54277c478bd9Sstevel@tonic-gate union swpbuf *swp_p, swp_b;
54287c478bd9Sstevel@tonic-gate
54297c478bd9Sstevel@tonic-gate swp_p = (union swpbuf *)sval;
54307c478bd9Sstevel@tonic-gate swp_b.s_word = 1;
54317c478bd9Sstevel@tonic-gate if (swp_b.s_byte[0]) {
54327c478bd9Sstevel@tonic-gate swp_b.s_word = v;
54337c478bd9Sstevel@tonic-gate swp_p->s_half[0] = swp_b.s_half[1];
54347c478bd9Sstevel@tonic-gate swp_p->s_half[1] = swp_b.s_half[0];
54357c478bd9Sstevel@tonic-gate } else {
54367c478bd9Sstevel@tonic-gate swp_b.s_word = v;
54377c478bd9Sstevel@tonic-gate swp_p->s_half[0] = swp_b.s_half[0];
54387c478bd9Sstevel@tonic-gate swp_p->s_half[1] = swp_b.s_half[1];
54397c478bd9Sstevel@tonic-gate }
54407c478bd9Sstevel@tonic-gate }
54417c478bd9Sstevel@tonic-gate
54427c478bd9Sstevel@tonic-gate /*
54437c478bd9Sstevel@tonic-gate * msg: Print either a message (no error) (POST), an error message with or
54447c478bd9Sstevel@tonic-gate * without the errno (ERRN or ERR), or print an error message with or without
54457c478bd9Sstevel@tonic-gate * the errno and exit (EXTN or EXT).
54467c478bd9Sstevel@tonic-gate */
54475fbb8099SNobutomo Nakano void
msg(int severity,const char * fmt,...)54487c478bd9Sstevel@tonic-gate msg(int severity, const char *fmt, ...)
54497c478bd9Sstevel@tonic-gate {
54507c478bd9Sstevel@tonic-gate FILE *file_p;
54517c478bd9Sstevel@tonic-gate va_list ap;
54527c478bd9Sstevel@tonic-gate
54537c478bd9Sstevel@tonic-gate if ((Args & OCV) && Verbcnt) { /* clear current line of dots */
54547c478bd9Sstevel@tonic-gate (void) fputc('\n', Out_p);
54557c478bd9Sstevel@tonic-gate Verbcnt = 0;
54567c478bd9Sstevel@tonic-gate }
54577c478bd9Sstevel@tonic-gate va_start(ap, fmt);
54587c478bd9Sstevel@tonic-gate if (severity == POST)
54597c478bd9Sstevel@tonic-gate file_p = Out_p;
54607c478bd9Sstevel@tonic-gate else
54617c478bd9Sstevel@tonic-gate if (severity == EPOST)
54627c478bd9Sstevel@tonic-gate file_p = Err_p;
54637c478bd9Sstevel@tonic-gate else {
54647c478bd9Sstevel@tonic-gate file_p = Err_p;
54657c478bd9Sstevel@tonic-gate Error_cnt++;
54667c478bd9Sstevel@tonic-gate }
54677c478bd9Sstevel@tonic-gate (void) fflush(Out_p);
54687c478bd9Sstevel@tonic-gate (void) fflush(Err_p);
54697c478bd9Sstevel@tonic-gate if ((severity != POST) && (severity != EPOST))
54707c478bd9Sstevel@tonic-gate (void) fprintf(file_p, "cpio: ");
54717c478bd9Sstevel@tonic-gate
54727c478bd9Sstevel@tonic-gate /* gettext replaces version of string */
54737c478bd9Sstevel@tonic-gate
54747c478bd9Sstevel@tonic-gate (void) vfprintf(file_p, gettext(fmt), ap);
54757c478bd9Sstevel@tonic-gate if (severity == ERRN || severity == EXTN) {
54764582e5eaSchin if (G_p && (G_p->g_attrnam_p != NULL) && G_p->g_rw_sysattr) {
5477ced83f9bSceastha if (errno == EPERM) {
5478ced83f9bSceastha (void) fprintf(file_p, ", errno %d, %s", errno,
5479ced83f9bSceastha gettext("insufficient privileges\n"));
5480ced83f9bSceastha } else if (errno == EINVAL) {
5481ced83f9bSceastha (void) fprintf(file_p, ", errno %d, %s",
5482ced83f9bSceastha errno, gettext(
5483ced83f9bSceastha "unsupported on underlying file system\n"));
5484ced83f9bSceastha } else {
54857c478bd9Sstevel@tonic-gate (void) fprintf(file_p, ", errno %d, ", errno);
54867c478bd9Sstevel@tonic-gate perror("");
5487ced83f9bSceastha }
5488ced83f9bSceastha } else {
5489ced83f9bSceastha (void) fprintf(file_p, ", errno %d, ", errno);
5490ced83f9bSceastha perror("");
5491ced83f9bSceastha }
54927c478bd9Sstevel@tonic-gate } else
54937c478bd9Sstevel@tonic-gate (void) fprintf(file_p, "\n");
54947c478bd9Sstevel@tonic-gate (void) fflush(file_p);
54957c478bd9Sstevel@tonic-gate va_end(ap);
54967c478bd9Sstevel@tonic-gate if (severity == EXT || severity == EXTN) {
54977c478bd9Sstevel@tonic-gate (void) fprintf(file_p, gettext("%d errors\n"), Error_cnt);
54987c478bd9Sstevel@tonic-gate exit(EXIT_CODE);
54997c478bd9Sstevel@tonic-gate }
55007c478bd9Sstevel@tonic-gate }
55017c478bd9Sstevel@tonic-gate
55027c478bd9Sstevel@tonic-gate /*
55037c478bd9Sstevel@tonic-gate * openout: Open files for output and set all necessary information.
55047c478bd9Sstevel@tonic-gate * If the u option is set (unconditionally overwrite existing files),
55057c478bd9Sstevel@tonic-gate * and the current file exists, get a temporary file name from mktemp(3C),
55067c478bd9Sstevel@tonic-gate * link the temporary file to the existing file, and remove the existing file.
55077c478bd9Sstevel@tonic-gate * Finally either creat(2), mkdir(2) or mknod(2) as appropriate.
55087c478bd9Sstevel@tonic-gate *
55097c478bd9Sstevel@tonic-gate */
55107c478bd9Sstevel@tonic-gate
55117c478bd9Sstevel@tonic-gate static int
openout(int dirfd)55127c478bd9Sstevel@tonic-gate openout(int dirfd)
55137c478bd9Sstevel@tonic-gate {
55147c478bd9Sstevel@tonic-gate char *nam_p;
55157c478bd9Sstevel@tonic-gate int cnt, result;
55167c478bd9Sstevel@tonic-gate
55177c478bd9Sstevel@tonic-gate Do_rename = 0; /* creat_tmp() may reset this */
55187c478bd9Sstevel@tonic-gate
5519ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
55207c478bd9Sstevel@tonic-gate nam_p = G_p->g_attrnam_p;
55217c478bd9Sstevel@tonic-gate } else {
55227c478bd9Sstevel@tonic-gate if (Args & OCp) {
55237c478bd9Sstevel@tonic-gate nam_p = Fullnam_p;
55247c478bd9Sstevel@tonic-gate } else {
55257c478bd9Sstevel@tonic-gate nam_p = G_p->g_nam_p;
55267c478bd9Sstevel@tonic-gate }
55277c478bd9Sstevel@tonic-gate }
55287c478bd9Sstevel@tonic-gate
55297c478bd9Sstevel@tonic-gate
55307c478bd9Sstevel@tonic-gate if ((Max_filesz != RLIM_INFINITY) &&
55317c478bd9Sstevel@tonic-gate (Max_filesz < (G_p->g_filesz >> 9))) {
55327c478bd9Sstevel@tonic-gate /* ... divided by 512 ... */
55337c478bd9Sstevel@tonic-gate msg(ERR, "Skipping \"%s%s%s\": exceeds ulimit by %lld bytes",
5534ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? nam_p : G_p->g_attrfnam_p,
5535ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : G_p->g_rw_sysattr ?
5536ced83f9bSceastha gettext(" System Attribute ") : gettext(" Attribute "),
5537ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : nam_p,
55387c478bd9Sstevel@tonic-gate (off_t)(G_p->g_filesz - (Max_filesz << 9)));
55397c478bd9Sstevel@tonic-gate return (-1);
55407c478bd9Sstevel@tonic-gate }
55417c478bd9Sstevel@tonic-gate
55427c478bd9Sstevel@tonic-gate if (LSTAT(dirfd, nam_p, &DesSt) == 0) {
55437c478bd9Sstevel@tonic-gate /*
55447c478bd9Sstevel@tonic-gate * A file by the same name exists. Move it to a temporary
5545ced83f9bSceastha * file unless it's a system attribute file. If we are
5546ced83f9bSceastha * restoring a system attribute file on a file system that
5547ced83f9bSceastha * supports system attributes, then the system attribute file
5548ced83f9bSceastha * will already exist (a default system attribute file will
5549ced83f9bSceastha * get created when the file it is associated with is created).
5550ced83f9bSceastha * If we create a temporary system attribute file, we can't
5551ced83f9bSceastha * overwrite the existing system attribute file using
5552ced83f9bSceastha * renameat(). In addition, only system attributes can exist
5553ced83f9bSceastha * for an attribute of a file, therefore, a temporary file
5554ced83f9bSceastha * cannot be created for a system attribute of an attribute.
5555ced83f9bSceastha * Thus, when restoring a system attribute, we won't move it
5556ced83f9bSceastha * to a temporary file, but will attempt to process it as if
5557ced83f9bSceastha * it didn't already exist.
55587c478bd9Sstevel@tonic-gate */
55597c478bd9Sstevel@tonic-gate
5560ced83f9bSceastha #if defined(_PC_SATTR_ENABLED)
5561ced83f9bSceastha if (G_p->g_rw_sysattr == 0)
5562ced83f9bSceastha #endif /* _PC_SATTR_ENABLED */
55637c478bd9Sstevel@tonic-gate if (creat_tmp(nam_p) < 0) {
55647c478bd9Sstevel@tonic-gate /*
5565ced83f9bSceastha * We weren't able to create the temp file.
5566ced83f9bSceastha * Report failure.
55677c478bd9Sstevel@tonic-gate */
55687c478bd9Sstevel@tonic-gate
55697c478bd9Sstevel@tonic-gate return (-1);
55707c478bd9Sstevel@tonic-gate }
55717c478bd9Sstevel@tonic-gate }
55727c478bd9Sstevel@tonic-gate
55737c478bd9Sstevel@tonic-gate if (Do_rename) {
55747c478bd9Sstevel@tonic-gate /* nam_p was changed by creat_tmp() above. */
55757c478bd9Sstevel@tonic-gate
55767c478bd9Sstevel@tonic-gate if (Args & OCp) {
5577ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
55787c478bd9Sstevel@tonic-gate nam_p = Attrfile_p;
55797c478bd9Sstevel@tonic-gate } else {
55807c478bd9Sstevel@tonic-gate nam_p = Fullnam_p;
55817c478bd9Sstevel@tonic-gate }
55827c478bd9Sstevel@tonic-gate } else {
55837c478bd9Sstevel@tonic-gate nam_p = G_p->g_nam_p;
55847c478bd9Sstevel@tonic-gate }
55857c478bd9Sstevel@tonic-gate }
55867c478bd9Sstevel@tonic-gate
55877c478bd9Sstevel@tonic-gate /*
55887c478bd9Sstevel@tonic-gate * This pile tries to create the file directly, and, if there is a
55897c478bd9Sstevel@tonic-gate * problem, creates missing directories, and then tries to create the
55907c478bd9Sstevel@tonic-gate * file again. Two strikes and you're out.
55917c478bd9Sstevel@tonic-gate *
55927c478bd9Sstevel@tonic-gate * On XATTR system, the directory has already been created by
55937c478bd9Sstevel@tonic-gate * open_dirfd(), so error shouldn't happen in the loop. However,
55947c478bd9Sstevel@tonic-gate * on non-XATTR system, symlink/open may fail with ENOENT. In such
55957c478bd9Sstevel@tonic-gate * case, we go to create missing directories.
55967c478bd9Sstevel@tonic-gate */
55977c478bd9Sstevel@tonic-gate
55987c478bd9Sstevel@tonic-gate cnt = 0;
55997c478bd9Sstevel@tonic-gate
56007c478bd9Sstevel@tonic-gate do {
56017c478bd9Sstevel@tonic-gate errno = 0;
56027c478bd9Sstevel@tonic-gate
56037c478bd9Sstevel@tonic-gate if (Hdr_type == TAR && Thdr_p->tbuf.t_typeflag == SYMTYPE) {
56047c478bd9Sstevel@tonic-gate /* The archive file is a TAR symlink. */
56057c478bd9Sstevel@tonic-gate if ((result =
56067c478bd9Sstevel@tonic-gate symlink(Thdr_p->tbuf.t_linkname, nam_p)) >= 0) {
56077c478bd9Sstevel@tonic-gate cnt = 0;
56087c478bd9Sstevel@tonic-gate if (Over_p != NULL) {
56097c478bd9Sstevel@tonic-gate (void) unlinkat(dirfd,
56107c478bd9Sstevel@tonic-gate get_component(Over_p), 0);
56117c478bd9Sstevel@tonic-gate *Over_p = '\0';
56127c478bd9Sstevel@tonic-gate }
56137c478bd9Sstevel@tonic-gate break;
56147c478bd9Sstevel@tonic-gate } else if (errno != ENOENT) {
56157c478bd9Sstevel@tonic-gate /* The attempt to symlink failed. */
56167c478bd9Sstevel@tonic-gate msg(ERRN,
56177c478bd9Sstevel@tonic-gate "Cannot create symbolic link \"%s\" -> "
56187c478bd9Sstevel@tonic-gate "\"%s\"",
56197c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_linkname, nam_p);
56207c478bd9Sstevel@tonic-gate
56217c478bd9Sstevel@tonic-gate if (*Over_p != '\0') {
56227c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, dirfd);
56237c478bd9Sstevel@tonic-gate }
56247c478bd9Sstevel@tonic-gate return (-1);
56257c478bd9Sstevel@tonic-gate }
56267c478bd9Sstevel@tonic-gate } else if (Hdr_type == BAR && bar_linkflag == SYMTYPE) {
56277c478bd9Sstevel@tonic-gate if ((result = symlink(bar_linkname, nam_p)) >= 0) {
56287c478bd9Sstevel@tonic-gate cnt = 0;
56297c478bd9Sstevel@tonic-gate if (Over_p != NULL) {
56307c478bd9Sstevel@tonic-gate (void) unlinkat(dirfd,
56317c478bd9Sstevel@tonic-gate get_component(Over_p), 0);
56327c478bd9Sstevel@tonic-gate *Over_p = '\0';
56337c478bd9Sstevel@tonic-gate }
56347c478bd9Sstevel@tonic-gate break;
56357c478bd9Sstevel@tonic-gate } else if (errno != ENOENT) {
56367c478bd9Sstevel@tonic-gate /* The attempt to symlink failed. */
56377c478bd9Sstevel@tonic-gate msg(ERRN,
56387c478bd9Sstevel@tonic-gate "Cannot create symbolic link \"%s\" -> "
56397c478bd9Sstevel@tonic-gate "\"%s\"",
56407c478bd9Sstevel@tonic-gate bar_linkname, nam_p);
56417c478bd9Sstevel@tonic-gate if (*Over_p != '\0') {
56427c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, dirfd);
56437c478bd9Sstevel@tonic-gate }
56447c478bd9Sstevel@tonic-gate return (-1);
56457c478bd9Sstevel@tonic-gate }
56467c478bd9Sstevel@tonic-gate } else if ((G_p->g_mode & Ftype) == S_IFLNK) {
56477c478bd9Sstevel@tonic-gate if ((!(Args & OCp)) && !(Hdr_type == USTAR)) {
564832fd2847Snakanon FILL(G_p->g_filesz);
56497c478bd9Sstevel@tonic-gate (void) strncpy(Symlnk_p,
56507c478bd9Sstevel@tonic-gate Buffr.b_out_p, G_p->g_filesz);
56517c478bd9Sstevel@tonic-gate *(Symlnk_p + G_p->g_filesz) = '\0';
56527c478bd9Sstevel@tonic-gate } else if ((!(Args & OCp)) && (Hdr_type == USTAR)) {
56537c478bd9Sstevel@tonic-gate Symlnk_p[NAMSIZ] = '\0';
56547c478bd9Sstevel@tonic-gate (void) strncpy(Symlnk_p,
56557c478bd9Sstevel@tonic-gate &Thdr_p->tbuf.t_linkname[0], NAMSIZ);
56567c478bd9Sstevel@tonic-gate }
56577c478bd9Sstevel@tonic-gate if ((result = symlink(Symlnk_p, nam_p)) >= 0) {
56587c478bd9Sstevel@tonic-gate cnt = 0;
56597c478bd9Sstevel@tonic-gate if (Over_p != NULL) {
56607c478bd9Sstevel@tonic-gate (void) unlinkat(dirfd,
56617c478bd9Sstevel@tonic-gate get_component(Over_p), 0);
56627c478bd9Sstevel@tonic-gate *Over_p = '\0';
56637c478bd9Sstevel@tonic-gate }
56647c478bd9Sstevel@tonic-gate break;
56657c478bd9Sstevel@tonic-gate } else if (errno != ENOENT) {
56667c478bd9Sstevel@tonic-gate /* The attempt to symlink failed. */
56677c478bd9Sstevel@tonic-gate msg(ERRN,
56687c478bd9Sstevel@tonic-gate "Cannot create symbolic link \"%s\" -> "
56697c478bd9Sstevel@tonic-gate "\"%s\"",
56707c478bd9Sstevel@tonic-gate Symlnk_p, nam_p);
56717c478bd9Sstevel@tonic-gate
56727c478bd9Sstevel@tonic-gate if (*Over_p != '\0') {
56737c478bd9Sstevel@tonic-gate rstfiles(U_KEEP, dirfd);
56747c478bd9Sstevel@tonic-gate }
56757c478bd9Sstevel@tonic-gate return (-1);
56767c478bd9Sstevel@tonic-gate }
56777c478bd9Sstevel@tonic-gate } else {
5678ced83f9bSceastha int saveerrno;
5679ced83f9bSceastha
56807c478bd9Sstevel@tonic-gate if ((result = openat(dirfd, get_component(nam_p),
5681ced83f9bSceastha O_CREAT|O_RDWR|O_TRUNC, (int)G_p->g_mode)) < 0) {
5682ced83f9bSceastha saveerrno = errno;
5683ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
5684ced83f9bSceastha result = retry_open_attr(dirfd,
5685ced83f9bSceastha Gen.g_baseparent_fd, Fullnam_p,
5686ced83f9bSceastha (G_p->g_attrparent_p == NULL) ?
5687ced83f9bSceastha NULL : G_p->g_attrparent_p, nam_p,
5688ced83f9bSceastha O_CREAT|O_RDWR|O_TRUNC,
5689ced83f9bSceastha (int)G_p->g_mode);
5690ced83f9bSceastha }
5691ced83f9bSceastha }
5692ced83f9bSceastha if (result < 0) {
5693ced83f9bSceastha errno = saveerrno;
5694ced83f9bSceastha if (errno != ENOENT) {
5695ced83f9bSceastha /* The attempt to open failed. */
5696ced83f9bSceastha msg(ERRN, "Cannot open file \"%s\"",
5697ced83f9bSceastha nam_p);
5698ced83f9bSceastha if (*Over_p != '\0') {
5699ced83f9bSceastha rstfiles(U_KEEP, dirfd);
5700ced83f9bSceastha }
5701ced83f9bSceastha return (-1);
5702ced83f9bSceastha }
5703ced83f9bSceastha } else {
57047c478bd9Sstevel@tonic-gate /* acl support */
5705fa9e4066Sahrens acl_is_set = 0;
57067c478bd9Sstevel@tonic-gate if (Pflag && aclp != NULL) {
5707fa9e4066Sahrens if (facl_set(result, aclp) < 0) {
57087c478bd9Sstevel@tonic-gate msg(ERRN,
57097c478bd9Sstevel@tonic-gate "\"%s\": failed to set acl",
57107c478bd9Sstevel@tonic-gate nam_p);
57117c478bd9Sstevel@tonic-gate } else {
5712fa9e4066Sahrens acl_is_set = 1;
57137c478bd9Sstevel@tonic-gate }
5714fa9e4066Sahrens acl_free(aclp);
57157c478bd9Sstevel@tonic-gate aclp = NULL;
57167c478bd9Sstevel@tonic-gate }
57177c478bd9Sstevel@tonic-gate cnt = 0;
57187c478bd9Sstevel@tonic-gate break;
57197c478bd9Sstevel@tonic-gate }
57207c478bd9Sstevel@tonic-gate }
57217c478bd9Sstevel@tonic-gate cnt++;
57227c478bd9Sstevel@tonic-gate } while (cnt < 2 && missdir(nam_p) == 0);
57237c478bd9Sstevel@tonic-gate
57247c478bd9Sstevel@tonic-gate switch (cnt) {
57257c478bd9Sstevel@tonic-gate case 0:
57267c478bd9Sstevel@tonic-gate if ((Args & OCi) && (Hdr_type == USTAR)) {
57277c478bd9Sstevel@tonic-gate setpasswd(nam_p);
57287c478bd9Sstevel@tonic-gate }
57297c478bd9Sstevel@tonic-gate if ((G_p->g_mode & Ftype) == S_IFLNK ||
57307c478bd9Sstevel@tonic-gate (Hdr_type == BAR && bar_linkflag == SYMTYPE)) {
5731647ab8f4Sceastha if (Args & OCR) {
5732647ab8f4Sceastha if (fchownat(dirfd,
5733647ab8f4Sceastha get_component(nam_p),
5734647ab8f4Sceastha (int)Rpw_p->pw_uid,
5735647ab8f4Sceastha (int)Rpw_p->pw_gid,
57367c478bd9Sstevel@tonic-gate AT_SYMLINK_NOFOLLOW) < 0) {
57377c478bd9Sstevel@tonic-gate msg(ERRN,
57387c478bd9Sstevel@tonic-gate "Error during chown() of "
57397c478bd9Sstevel@tonic-gate "\"%s%s%s\"",
5740ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
57417c478bd9Sstevel@tonic-gate nam_p : G_p->g_attrfnam_p,
5742ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
5743ced83f9bSceastha "" : G_p->g_rw_sysattr ?
5744ced83f9bSceastha gettext(" System Attribute ") :
5745ced83f9bSceastha gettext(" Attribute "),
5746ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
57477c478bd9Sstevel@tonic-gate "" : nam_p);
57487c478bd9Sstevel@tonic-gate }
5749647ab8f4Sceastha } else if ((fchownat(dirfd, get_component(nam_p),
5750647ab8f4Sceastha (int)G_p->g_uid, (int)G_p->g_gid,
5751647ab8f4Sceastha AT_SYMLINK_NOFOLLOW) < 0) && privileged) {
57527c478bd9Sstevel@tonic-gate msg(ERRN,
57537c478bd9Sstevel@tonic-gate "Error during chown() of \"%s%s%s\"",
5754ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
57557c478bd9Sstevel@tonic-gate nam_p : G_p->g_attrfnam_p,
5756ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
5757ced83f9bSceastha G_p->g_rw_sysattr ?
5758ced83f9bSceastha gettext(" System Attribute ") :
5759ced83f9bSceastha gettext(" Attribute "),
5760ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : nam_p);
57617c478bd9Sstevel@tonic-gate }
57627c478bd9Sstevel@tonic-gate }
57637c478bd9Sstevel@tonic-gate break;
57647c478bd9Sstevel@tonic-gate
57657c478bd9Sstevel@tonic-gate case 1:
57667c478bd9Sstevel@tonic-gate if (Do_rename) {
57677c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot create directory for \"%s%s%s\"",
5768ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? Over_p :
57697c478bd9Sstevel@tonic-gate G_p->g_attrfnam_p,
5770ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
5771ced83f9bSceastha G_p->g_rw_sysattr ?
5772ced83f9bSceastha gettext(" System Attribute ") :
57737c478bd9Sstevel@tonic-gate gettext(" Attribute "),
5774ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : Over_p);
57757c478bd9Sstevel@tonic-gate } else {
57767c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot create directory for \"%s%s%s\"",
5777ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? nam_p :
57787c478bd9Sstevel@tonic-gate G_p->g_attrfnam_p,
5779ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
5780ced83f9bSceastha G_p->g_rw_sysattr ?
5781ced83f9bSceastha gettext(" System Attribute ") :
57827c478bd9Sstevel@tonic-gate gettext(" Attribute "),
5783ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : nam_p);
57847c478bd9Sstevel@tonic-gate }
57857c478bd9Sstevel@tonic-gate break;
57867c478bd9Sstevel@tonic-gate
57877c478bd9Sstevel@tonic-gate case 2:
57887c478bd9Sstevel@tonic-gate if (Do_rename) {
57897c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot create \"%s%s%s\"",
5790ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? Over_p :
57917c478bd9Sstevel@tonic-gate G_p->g_attrfnam_p,
5792ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
5793ced83f9bSceastha G_p->g_rw_sysattr ?
5794ced83f9bSceastha gettext(" System Attribute ") :
57957c478bd9Sstevel@tonic-gate gettext(" Attribute "),
5796ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
57977c478bd9Sstevel@tonic-gate Over_p);
57987c478bd9Sstevel@tonic-gate } else {
57997c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot create \"%s%s%s\"",
5800ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? nam_p :
58017c478bd9Sstevel@tonic-gate G_p->g_attrfnam_p,
5802ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
5803ced83f9bSceastha G_p->g_rw_sysattr ?
5804ced83f9bSceastha gettext(" System Attribute ") :
58057c478bd9Sstevel@tonic-gate gettext(" Attribute "),
5806ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : nam_p);
58077c478bd9Sstevel@tonic-gate }
58087c478bd9Sstevel@tonic-gate break;
58097c478bd9Sstevel@tonic-gate
58107c478bd9Sstevel@tonic-gate default:
58117c478bd9Sstevel@tonic-gate msg(EXT, "Impossible case.");
58127c478bd9Sstevel@tonic-gate }
58137c478bd9Sstevel@tonic-gate
58147c478bd9Sstevel@tonic-gate Finished = 0;
58157c478bd9Sstevel@tonic-gate return (result);
58167c478bd9Sstevel@tonic-gate }
58177c478bd9Sstevel@tonic-gate
58187c478bd9Sstevel@tonic-gate /*
58197c478bd9Sstevel@tonic-gate * read_hdr: Transfer headers from the selected format
58207c478bd9Sstevel@tonic-gate * in the archive I/O buffer to the generic structure.
58217c478bd9Sstevel@tonic-gate */
58227c478bd9Sstevel@tonic-gate
58237c478bd9Sstevel@tonic-gate static
58247c478bd9Sstevel@tonic-gate int
read_hdr(int hdr)58257c478bd9Sstevel@tonic-gate read_hdr(int hdr)
58267c478bd9Sstevel@tonic-gate {
58277c478bd9Sstevel@tonic-gate int rv = NONE;
58287c478bd9Sstevel@tonic-gate major_t maj, rmaj;
58297c478bd9Sstevel@tonic-gate minor_t min, rmin;
58300b9a5158SToomas Soome char tmpnull = '\0';
58317c478bd9Sstevel@tonic-gate static int bar_read_cnt = 0;
58327c478bd9Sstevel@tonic-gate
58337c478bd9Sstevel@tonic-gate if (hdr != BAR) {
58347c478bd9Sstevel@tonic-gate if (Buffr.b_end_p != (Buffr.b_out_p + Hdrsz)) {
58357c478bd9Sstevel@tonic-gate tmpnull = *(Buffr.b_out_p + Hdrsz);
58367c478bd9Sstevel@tonic-gate *(Buffr.b_out_p + Hdrsz) = '\0';
58377c478bd9Sstevel@tonic-gate }
58387c478bd9Sstevel@tonic-gate }
58397c478bd9Sstevel@tonic-gate
58407c478bd9Sstevel@tonic-gate switch (hdr) {
58417c478bd9Sstevel@tonic-gate case BIN:
58427c478bd9Sstevel@tonic-gate (void) memcpy(&Hdr, Buffr.b_out_p, HDRSZ);
58437c478bd9Sstevel@tonic-gate if (Hdr.h_magic == (short)CMN_BBS) {
58447c478bd9Sstevel@tonic-gate swap((char *)&Hdr, HDRSZ);
58457c478bd9Sstevel@tonic-gate }
58467c478bd9Sstevel@tonic-gate Gen.g_magic = Hdr.h_magic;
58477c478bd9Sstevel@tonic-gate Gen.g_mode = Hdr.h_mode;
58487c478bd9Sstevel@tonic-gate Gen.g_uid = Hdr.h_uid;
58497c478bd9Sstevel@tonic-gate Gen.g_gid = Hdr.h_gid;
58507c478bd9Sstevel@tonic-gate Gen.g_nlink = Hdr.h_nlink;
58517c478bd9Sstevel@tonic-gate Gen.g_mtime = mklong(Hdr.h_mtime);
58527c478bd9Sstevel@tonic-gate Gen.g_ino = Hdr.h_ino;
58537c478bd9Sstevel@tonic-gate Gen.g_dev = Hdr.h_dev;
58547c478bd9Sstevel@tonic-gate Gen.g_rdev = Hdr.h_rdev;
5855*6d3b960aSAndy Fiddaman maj = SVR3_MAJOR(Gen.g_dev);
5856*6d3b960aSAndy Fiddaman rmaj = SVR3_MAJOR(Gen.g_rdev);
5857*6d3b960aSAndy Fiddaman min = SVR3_MINOR(Gen.g_dev);
5858*6d3b960aSAndy Fiddaman rmin = SVR3_MINOR(Gen.g_rdev);
5859*6d3b960aSAndy Fiddaman Gen.g_dev = makedev(maj, min);
5860*6d3b960aSAndy Fiddaman Gen.g_rdev = makedev(rmaj, rmin);
58617c478bd9Sstevel@tonic-gate Gen.g_cksum = 0L;
58627c478bd9Sstevel@tonic-gate Gen.g_filesz = (off_t)mklong(Hdr.h_filesize);
58637c478bd9Sstevel@tonic-gate Gen.g_namesz = Hdr.h_namesize;
58647c478bd9Sstevel@tonic-gate rv = BIN;
58657c478bd9Sstevel@tonic-gate break;
58667c478bd9Sstevel@tonic-gate case CHR:
58677c478bd9Sstevel@tonic-gate if (sscanf(Buffr.b_out_p,
5868*6d3b960aSAndy Fiddaman "%6o%6o%6o%6o"
5869*6d3b960aSAndy Fiddaman "%6" _SCNoID "%6" _SCNoID
5870*6d3b960aSAndy Fiddaman "%6o%6o%11o%6o%11lo",
58717c478bd9Sstevel@tonic-gate &Gen.g_magic, &Gen.g_dev, &Gen.g_ino, &Gen.g_mode,
5872*6d3b960aSAndy Fiddaman &Gen.g_uid, &Gen.g_gid,
5873*6d3b960aSAndy Fiddaman &Gen.g_nlink, &Gen.g_rdev,
5874*6d3b960aSAndy Fiddaman (uint_t *)&Gen.g_mtime, (uint_t *)&Gen.g_namesz,
58757c478bd9Sstevel@tonic-gate (u_off_t *)&Gen.g_filesz) == CHR_CNT) {
58767c478bd9Sstevel@tonic-gate rv = CHR;
5877*6d3b960aSAndy Fiddaman maj = SVR3_MAJOR(Gen.g_dev);
5878*6d3b960aSAndy Fiddaman rmaj = SVR3_MAJOR(Gen.g_rdev);
5879*6d3b960aSAndy Fiddaman min = SVR3_MINOR(Gen.g_dev);
5880*6d3b960aSAndy Fiddaman rmin = SVR3_MINOR(Gen.g_rdev);
58817c478bd9Sstevel@tonic-gate Gen.g_dev = makedev(maj, min);
58827c478bd9Sstevel@tonic-gate Gen.g_rdev = makedev(rmaj, rmin);
58837c478bd9Sstevel@tonic-gate }
58847c478bd9Sstevel@tonic-gate break;
58857c478bd9Sstevel@tonic-gate case ASC:
58867c478bd9Sstevel@tonic-gate case CRC:
58877c478bd9Sstevel@tonic-gate if (sscanf(Buffr.b_out_p,
5888*6d3b960aSAndy Fiddaman "%6x%8x%8x"
5889*6d3b960aSAndy Fiddaman "%8" _SCNxID "%8" _SCNxID
5890*6d3b960aSAndy Fiddaman "%8x%8x%8lx%8x%8x%8x%8x%8x%8x",
5891*6d3b960aSAndy Fiddaman &Gen.g_magic, &Gen.g_ino, &Gen.g_mode,
5892*6d3b960aSAndy Fiddaman &Gen.g_uid, &Gen.g_gid,
5893*6d3b960aSAndy Fiddaman &Gen.g_nlink, &Gen.g_mtime,
58947c478bd9Sstevel@tonic-gate (u_off_t *)&Gen.g_filesz, (uint_t *)&maj, (uint_t *)&min,
58957c478bd9Sstevel@tonic-gate (uint_t *)&rmaj, (uint_t *)&rmin, (uint_t *)&Gen.g_namesz,
58967c478bd9Sstevel@tonic-gate &Gen.g_cksum) == ASC_CNT) {
58977c478bd9Sstevel@tonic-gate Gen.g_dev = makedev(maj, min);
58987c478bd9Sstevel@tonic-gate Gen.g_rdev = makedev(rmaj, rmin);
58997c478bd9Sstevel@tonic-gate rv = hdr;
59007c478bd9Sstevel@tonic-gate }
59017c478bd9Sstevel@tonic-gate break;
59027c478bd9Sstevel@tonic-gate case USTAR: /* TAR and USTAR */
59037c478bd9Sstevel@tonic-gate if (*Buffr.b_out_p == '\0') {
59047c478bd9Sstevel@tonic-gate *Gen.g_nam_p = '\0';
59057c478bd9Sstevel@tonic-gate nambuf[0] = '\0';
59067c478bd9Sstevel@tonic-gate } else {
59077c478bd9Sstevel@tonic-gate Thdr_p = (union tblock *)Buffr.b_out_p;
59087c478bd9Sstevel@tonic-gate Gen.g_nam_p[0] = '\0';
59097c478bd9Sstevel@tonic-gate (void) strncpy((char *)&nambuf,
59107c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_name, NAMSIZ);
5911*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_mode, "%8o",
59127c478bd9Sstevel@tonic-gate &Gen.g_mode);
5913*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_uid, "%8" _SCNoID,
5914*6d3b960aSAndy Fiddaman &Gen.g_uid);
5915*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_gid, "%8" _SCNoID,
5916*6d3b960aSAndy Fiddaman &Gen.g_gid);
5917*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_size, "%12lo",
59187c478bd9Sstevel@tonic-gate (u_off_t *)&Gen.g_filesz);
5919*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_mtime, "%12o",
5920*6d3b960aSAndy Fiddaman (uint_t *)&Gen.g_mtime);
5921*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_cksum, "%8o",
5922*6d3b960aSAndy Fiddaman (uint_t *)&Gen.g_cksum);
5923ced83f9bSceastha if (Thdr_p->tbuf.t_linkname[0] != '\0')
59247c478bd9Sstevel@tonic-gate Gen.g_nlink = 1;
59257c478bd9Sstevel@tonic-gate else
59267c478bd9Sstevel@tonic-gate Gen.g_nlink = 0;
59277c478bd9Sstevel@tonic-gate
59287c478bd9Sstevel@tonic-gate switch (Thdr_p->tbuf.t_typeflag) {
59297c478bd9Sstevel@tonic-gate case SYMTYPE:
59307c478bd9Sstevel@tonic-gate /* Symbolic Link */
59317c478bd9Sstevel@tonic-gate Gen.g_nlink = 2;
59327c478bd9Sstevel@tonic-gate break;
59337c478bd9Sstevel@tonic-gate case CHRTYPE:
59347c478bd9Sstevel@tonic-gate Gen.g_mode |= (S_IFMT & S_IFCHR);
59357c478bd9Sstevel@tonic-gate break;
59367c478bd9Sstevel@tonic-gate case BLKTYPE:
59377c478bd9Sstevel@tonic-gate Gen.g_mode |= (S_IFMT & S_IFBLK);
59387c478bd9Sstevel@tonic-gate break;
59397c478bd9Sstevel@tonic-gate case DIRTYPE:
59407c478bd9Sstevel@tonic-gate Gen.g_mode |= (S_IFMT & S_IFDIR);
59417c478bd9Sstevel@tonic-gate break;
59427c478bd9Sstevel@tonic-gate case FIFOTYPE:
59437c478bd9Sstevel@tonic-gate Gen.g_mode |= (S_IFMT & S_IFIFO);
59447c478bd9Sstevel@tonic-gate break;
59457c478bd9Sstevel@tonic-gate }
59467c478bd9Sstevel@tonic-gate
5947*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_magic, "%6o",
5948*6d3b960aSAndy Fiddaman (uint_t *)&Gen.g_tmagic);
5949*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_version, "%2o",
5950*6d3b960aSAndy Fiddaman (uint_t *)&Gen.g_version);
59517c478bd9Sstevel@tonic-gate (void) sscanf(Thdr_p->tbuf.t_uname, "%32s",
59527c478bd9Sstevel@tonic-gate (char *)&Gen.g_uname);
59537c478bd9Sstevel@tonic-gate (void) sscanf(Thdr_p->tbuf.t_gname, "%32s",
59547c478bd9Sstevel@tonic-gate (char *)&Gen.g_gname);
5955*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_devmajor, "%8o", &maj);
5956*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_devminor, "%8o", &min);
59577c478bd9Sstevel@tonic-gate (void) strncpy((char *)&prebuf,
59587c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_prefix, PRESIZ);
59597c478bd9Sstevel@tonic-gate Gen.g_namesz = strlen(Gen.g_nam_p) + 1;
5960*6d3b960aSAndy Fiddaman Gen.g_rdev = makedev(maj, min);
59617c478bd9Sstevel@tonic-gate }
59627c478bd9Sstevel@tonic-gate rv = USTAR;
59637c478bd9Sstevel@tonic-gate break;
59647c478bd9Sstevel@tonic-gate case TAR:
59657c478bd9Sstevel@tonic-gate if (*Buffr.b_out_p == '\0') {
59667c478bd9Sstevel@tonic-gate *Gen.g_nam_p = '\0';
59677c478bd9Sstevel@tonic-gate nambuf[0] = '\0';
59687c478bd9Sstevel@tonic-gate } else {
59697c478bd9Sstevel@tonic-gate Thdr_p = (union tblock *)Buffr.b_out_p;
59707c478bd9Sstevel@tonic-gate Gen.g_nam_p[0] = '\0';
5971*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_mode, "%8o", &Gen.g_mode);
5972*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_uid, "%8" _SCNoID,
5973*6d3b960aSAndy Fiddaman &Gen.g_uid);
5974*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_gid, "%8" _SCNoID,
5975*6d3b960aSAndy Fiddaman &Gen.g_gid);
5976*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_size, "%12" SCNo64,
59777c478bd9Sstevel@tonic-gate (u_off_t *)&Gen.g_filesz);
5978*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_mtime, "%12o",
59797c478bd9Sstevel@tonic-gate &Gen.g_mtime);
5980*6d3b960aSAndy Fiddaman (void) sscanf(Thdr_p->tbuf.t_cksum, "%8o",
59817c478bd9Sstevel@tonic-gate &Gen.g_cksum);
59827c478bd9Sstevel@tonic-gate if (Thdr_p->tbuf.t_typeflag == '1') /* hardlink */
59837c478bd9Sstevel@tonic-gate Gen.g_nlink = 1;
59847c478bd9Sstevel@tonic-gate else
59857c478bd9Sstevel@tonic-gate Gen.g_nlink = 0;
59867c478bd9Sstevel@tonic-gate (void) strncpy(Gen.g_nam_p,
59877c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_name, NAMSIZ);
59887c478bd9Sstevel@tonic-gate Gen.g_namesz = strlen(Gen.g_nam_p) + 1;
59897c478bd9Sstevel@tonic-gate (void) strcpy(nambuf, Gen.g_nam_p);
59907c478bd9Sstevel@tonic-gate }
59917c478bd9Sstevel@tonic-gate rv = TAR;
59927c478bd9Sstevel@tonic-gate break;
59937c478bd9Sstevel@tonic-gate case BAR:
59947c478bd9Sstevel@tonic-gate if (Bar_vol_num == 0 && bar_read_cnt == 0) {
59957c478bd9Sstevel@tonic-gate read_bar_vol_hdr();
59967c478bd9Sstevel@tonic-gate bar_read_cnt++;
5997*6d3b960aSAndy Fiddaman } else {
59987c478bd9Sstevel@tonic-gate read_bar_file_hdr();
5999*6d3b960aSAndy Fiddaman }
60007c478bd9Sstevel@tonic-gate rv = BAR;
60017c478bd9Sstevel@tonic-gate break;
60027c478bd9Sstevel@tonic-gate default:
60037c478bd9Sstevel@tonic-gate msg(EXT, "Impossible header type.");
60047c478bd9Sstevel@tonic-gate }
60057c478bd9Sstevel@tonic-gate
60067c478bd9Sstevel@tonic-gate if (hdr != BAR) {
60077c478bd9Sstevel@tonic-gate if (Buffr.b_end_p != (Buffr.b_out_p + Hdrsz))
60087c478bd9Sstevel@tonic-gate *(Buffr.b_out_p + Hdrsz) = tmpnull;
60097c478bd9Sstevel@tonic-gate }
60107c478bd9Sstevel@tonic-gate
60117c478bd9Sstevel@tonic-gate return (rv);
60127c478bd9Sstevel@tonic-gate }
60137c478bd9Sstevel@tonic-gate
60147c478bd9Sstevel@tonic-gate /*
60157c478bd9Sstevel@tonic-gate * reclaim: Reclaim linked file structure storage.
60167c478bd9Sstevel@tonic-gate */
60177c478bd9Sstevel@tonic-gate
60187c478bd9Sstevel@tonic-gate static void
reclaim(struct Lnk * p)60197c478bd9Sstevel@tonic-gate reclaim(struct Lnk *p)
60207c478bd9Sstevel@tonic-gate {
60217c478bd9Sstevel@tonic-gate p->L_bck_p->L_nxt_p = p->L_nxt_p;
60227c478bd9Sstevel@tonic-gate p->L_nxt_p->L_bck_p = p->L_bck_p;
60237c478bd9Sstevel@tonic-gate
60247c478bd9Sstevel@tonic-gate while (p != NULL) {
60257c478bd9Sstevel@tonic-gate struct Lnk *new_p = p->L_lnk_p;
60267c478bd9Sstevel@tonic-gate
60277c478bd9Sstevel@tonic-gate free(p->L_gen.g_nam_p);
60287c478bd9Sstevel@tonic-gate free(p);
60297c478bd9Sstevel@tonic-gate p = new_p;
60307c478bd9Sstevel@tonic-gate }
60317c478bd9Sstevel@tonic-gate }
60327c478bd9Sstevel@tonic-gate
60337c478bd9Sstevel@tonic-gate /*
60347c478bd9Sstevel@tonic-gate * rstbuf: Reset the I/O buffer, move incomplete potential headers to
60357c478bd9Sstevel@tonic-gate * the front of the buffer and force bread() to refill the buffer. The
60367c478bd9Sstevel@tonic-gate * return value from bread() is returned (to identify I/O errors). On the
60377c478bd9Sstevel@tonic-gate * 3B2, reads must begin on a word boundary, therefore, with the -i option,
60387c478bd9Sstevel@tonic-gate * any remaining bytes in the buffer must be moved to the base of the buffer
60397c478bd9Sstevel@tonic-gate * in such a way that the destination locations of subsequent reads are
60407c478bd9Sstevel@tonic-gate * word aligned.
60417c478bd9Sstevel@tonic-gate */
60427c478bd9Sstevel@tonic-gate
60437c478bd9Sstevel@tonic-gate static void
rstbuf(void)60447c478bd9Sstevel@tonic-gate rstbuf(void)
60457c478bd9Sstevel@tonic-gate {
60467c478bd9Sstevel@tonic-gate int pad;
60477c478bd9Sstevel@tonic-gate
60487c478bd9Sstevel@tonic-gate if ((Args & OCi) || Append) {
60497c478bd9Sstevel@tonic-gate if (Buffr.b_out_p != Buffr.b_base_p) {
60507c478bd9Sstevel@tonic-gate pad = ((Buffr.b_cnt + FULLWD) & ~FULLWD);
60517c478bd9Sstevel@tonic-gate Buffr.b_in_p = Buffr.b_base_p + pad;
60527c478bd9Sstevel@tonic-gate pad -= Buffr.b_cnt;
60537c478bd9Sstevel@tonic-gate (void) memcpy(Buffr.b_base_p + pad, Buffr.b_out_p,
60547c478bd9Sstevel@tonic-gate (int)Buffr.b_cnt);
60557c478bd9Sstevel@tonic-gate Buffr.b_out_p = Buffr.b_base_p + pad;
60567c478bd9Sstevel@tonic-gate }
60577c478bd9Sstevel@tonic-gate if (bfill() < 0)
60587c478bd9Sstevel@tonic-gate msg(EXT, "Unexpected end-of-archive encountered.");
60597c478bd9Sstevel@tonic-gate } else { /* OCo */
60607c478bd9Sstevel@tonic-gate (void) memcpy(Buffr.b_base_p, Buffr.b_out_p, (int)Buffr.b_cnt);
60617c478bd9Sstevel@tonic-gate Buffr.b_out_p = Buffr.b_base_p;
60627c478bd9Sstevel@tonic-gate Buffr.b_in_p = Buffr.b_base_p + Buffr.b_cnt;
60637c478bd9Sstevel@tonic-gate }
60647c478bd9Sstevel@tonic-gate }
60657c478bd9Sstevel@tonic-gate
60667c478bd9Sstevel@tonic-gate static void
setpasswd(char * nam)60677c478bd9Sstevel@tonic-gate setpasswd(char *nam)
60687c478bd9Sstevel@tonic-gate {
6069ced83f9bSceastha if ((dpasswd = getpwnam(&Gen.g_uname[0])) == NULL) {
60707c478bd9Sstevel@tonic-gate msg(EPOST, "cpio: problem reading passwd entry");
60717c478bd9Sstevel@tonic-gate msg(EPOST, "cpio: %s: owner not changed", nam);
60727c478bd9Sstevel@tonic-gate if (Gen.g_uid == UID_NOBODY && S_ISREG(Gen.g_mode))
60737c478bd9Sstevel@tonic-gate Gen.g_mode &= ~S_ISUID;
60747c478bd9Sstevel@tonic-gate } else
60757c478bd9Sstevel@tonic-gate Gen.g_uid = dpasswd->pw_uid;
60767c478bd9Sstevel@tonic-gate
6077ced83f9bSceastha if ((dgroup = getgrnam(&Gen.g_gname[0])) == NULL) {
60787c478bd9Sstevel@tonic-gate msg(EPOST, "cpio: problem reading group entry");
60797c478bd9Sstevel@tonic-gate msg(EPOST, "cpio: %s: group not changed", nam);
60807c478bd9Sstevel@tonic-gate if (Gen.g_gid == GID_NOBODY && S_ISREG(Gen.g_mode))
60817c478bd9Sstevel@tonic-gate Gen.g_mode &= ~S_ISGID;
60827c478bd9Sstevel@tonic-gate } else
60837c478bd9Sstevel@tonic-gate Gen.g_gid = dgroup->gr_gid;
60847c478bd9Sstevel@tonic-gate G_p = &Gen;
60857c478bd9Sstevel@tonic-gate }
60867c478bd9Sstevel@tonic-gate
60877c478bd9Sstevel@tonic-gate /*
60887c478bd9Sstevel@tonic-gate * rstfiles: Perform final changes to the file. If the -u option is set,
60897c478bd9Sstevel@tonic-gate * and overwrite == U_OVER, remove the temporary file, else if overwrite
60907c478bd9Sstevel@tonic-gate * == U_KEEP, unlink the current file, and restore the existing version
60917c478bd9Sstevel@tonic-gate * of the file. In addition, where appropriate, set the access or modification
60927c478bd9Sstevel@tonic-gate * times, change the owner and change the modes of the file.
60937c478bd9Sstevel@tonic-gate *
60947c478bd9Sstevel@tonic-gate * Note that if Do_rename is set, then the roles of original and temporary
60957c478bd9Sstevel@tonic-gate * file are reversed. If all went well, we will rename() the temporary file
6096da6c28aaSamw * over the original in order to accommodate potentially executing files.
60977c478bd9Sstevel@tonic-gate */
60987c478bd9Sstevel@tonic-gate static void
rstfiles(int over,int dirfd)60997c478bd9Sstevel@tonic-gate rstfiles(int over, int dirfd)
61007c478bd9Sstevel@tonic-gate {
61017c478bd9Sstevel@tonic-gate char *inam_p, *onam_p, *nam_p;
61027c478bd9Sstevel@tonic-gate int error;
61037c478bd9Sstevel@tonic-gate
6104ced83f9bSceastha #if defined(_PC_SATTR_ENABLED)
6105ced83f9bSceastha /* Time or permissions cannot be set on system attribute files */
6106ced83f9bSceastha if ((Gen.g_attrnam_p != NULL) && (Gen.g_rw_sysattr == 1)) {
6107ced83f9bSceastha return;
6108ced83f9bSceastha }
6109ced83f9bSceastha #endif /* _PC_SATTR_ENABLED */
6110ced83f9bSceastha
61117c478bd9Sstevel@tonic-gate if (Args & OCp) {
6112ced83f9bSceastha if (G_p->g_attrnam_p == NULL) {
61137c478bd9Sstevel@tonic-gate nam_p = Fullnam_p;
61147c478bd9Sstevel@tonic-gate } else {
61157c478bd9Sstevel@tonic-gate nam_p = G_p->g_attrnam_p;
61167c478bd9Sstevel@tonic-gate }
61177c478bd9Sstevel@tonic-gate } else {
6118*6d3b960aSAndy Fiddaman if (Gen.g_nlink > 0) {
61197c478bd9Sstevel@tonic-gate nam_p = G_p->g_nam_p;
61207c478bd9Sstevel@tonic-gate } else {
61217c478bd9Sstevel@tonic-gate nam_p = Gen.g_nam_p;
61227c478bd9Sstevel@tonic-gate }
61237c478bd9Sstevel@tonic-gate }
6124ced83f9bSceastha if (Gen.g_attrnam_p != NULL) {
61257c478bd9Sstevel@tonic-gate nam_p = Gen.g_attrnam_p;
61267c478bd9Sstevel@tonic-gate }
61277c478bd9Sstevel@tonic-gate
61287c478bd9Sstevel@tonic-gate if ((Args & OCi) && (Hdr_type == USTAR)) {
61297c478bd9Sstevel@tonic-gate setpasswd(nam_p);
61307c478bd9Sstevel@tonic-gate }
61317c478bd9Sstevel@tonic-gate if (over == U_KEEP && *Over_p != '\0') {
61327c478bd9Sstevel@tonic-gate if (Do_rename) {
61337c478bd9Sstevel@tonic-gate msg(POST, "Restoring existing \"%s%s%s\"",
6134ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? Over_p : Fullnam_p,
6135ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
6136ced83f9bSceastha G_p->g_rw_sysattr ? gettext(" System Attribute ") :
6137ced83f9bSceastha gettext(" Attribute "),
6138ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : Over_p);
61397c478bd9Sstevel@tonic-gate } else {
61407c478bd9Sstevel@tonic-gate msg(POST, "Restoring existing \"%s%s%s\"",
6141ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? nam_p : Fullnam_p,
6142ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
6143ced83f9bSceastha G_p->g_rw_sysattr ? gettext(" System Attribute ") :
6144ced83f9bSceastha gettext(" Attribute "),
6145ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : nam_p);
61467c478bd9Sstevel@tonic-gate }
61477c478bd9Sstevel@tonic-gate
61487c478bd9Sstevel@tonic-gate /* delete what we just built */
61497c478bd9Sstevel@tonic-gate (void) unlinkat(dirfd, get_component(nam_p), 0);
61507c478bd9Sstevel@tonic-gate
61517c478bd9Sstevel@tonic-gate /* If the old file needs restoring, do the necessary links */
61527c478bd9Sstevel@tonic-gate if (Do_rename) {
61537c478bd9Sstevel@tonic-gate char *tmp_ptr;
61547c478bd9Sstevel@tonic-gate
61557c478bd9Sstevel@tonic-gate if (Args & OCp) {
61567c478bd9Sstevel@tonic-gate tmp_ptr = Fullnam_p;
61577c478bd9Sstevel@tonic-gate Fullnam_p = Over_p;
61587c478bd9Sstevel@tonic-gate } else {
61597c478bd9Sstevel@tonic-gate tmp_ptr = G_p->g_nam_p;
61607c478bd9Sstevel@tonic-gate G_p->g_nam_p = Over_p;
61617c478bd9Sstevel@tonic-gate }
61627c478bd9Sstevel@tonic-gate Over_p = tmp_ptr;
61637c478bd9Sstevel@tonic-gate
61647c478bd9Sstevel@tonic-gate Do_rename = 0; /* names now have original values */
61657c478bd9Sstevel@tonic-gate } else {
61667c478bd9Sstevel@tonic-gate if (rename(Over_p, nam_p) < 0) {
61677c478bd9Sstevel@tonic-gate if (link(Over_p, nam_p) < 0) {
61687c478bd9Sstevel@tonic-gate msg(EXTN,
61697c478bd9Sstevel@tonic-gate "Cannot recover original version"
61707c478bd9Sstevel@tonic-gate " of \"%s%s%s\"",
6171ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
61727c478bd9Sstevel@tonic-gate nam_p : Fullnam_p,
6173ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
6174ced83f9bSceastha G_p->g_rw_sysattr ?
6175ced83f9bSceastha gettext(" System Attribute ") :
6176ced83f9bSceastha gettext(" Attribute "),
6177ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
61787c478bd9Sstevel@tonic-gate "" : nam_p);
61797c478bd9Sstevel@tonic-gate }
61807c478bd9Sstevel@tonic-gate if (unlinkat(dirfd, get_component(Over_p), 0)) {
61817c478bd9Sstevel@tonic-gate msg(ERRN,
61827c478bd9Sstevel@tonic-gate "Cannot remove temp file "
61837c478bd9Sstevel@tonic-gate "\"%s%s%s\"",
6184ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
61857c478bd9Sstevel@tonic-gate Over_p : Fullnam_p,
6186ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
6187ced83f9bSceastha G_p->g_rw_sysattr ?
6188ced83f9bSceastha gettext(" System Attribute ") :
6189ced83f9bSceastha gettext(" Attribute "),
6190ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
61917c478bd9Sstevel@tonic-gate "" : Over_p);
61927c478bd9Sstevel@tonic-gate }
61937c478bd9Sstevel@tonic-gate }
61947c478bd9Sstevel@tonic-gate }
61957c478bd9Sstevel@tonic-gate *Over_p = '\0';
61967c478bd9Sstevel@tonic-gate return;
61977c478bd9Sstevel@tonic-gate } else if (over == U_OVER && *Over_p != '\0') {
61987c478bd9Sstevel@tonic-gate if (Do_rename) {
61997c478bd9Sstevel@tonic-gate char *tmp_ptr;
62007c478bd9Sstevel@tonic-gate
62017c478bd9Sstevel@tonic-gate (void) renameat(dirfd, get_component(nam_p),
62027c478bd9Sstevel@tonic-gate dirfd, get_component(Over_p));
62037c478bd9Sstevel@tonic-gate if (Args & OCp) {
6204ced83f9bSceastha if (G_p->g_attrnam_p == NULL) {
62057c478bd9Sstevel@tonic-gate tmp_ptr = Fullnam_p;
62067c478bd9Sstevel@tonic-gate Fullnam_p = Over_p;
62077c478bd9Sstevel@tonic-gate Over_p = tmp_ptr;
62087c478bd9Sstevel@tonic-gate } else {
62097c478bd9Sstevel@tonic-gate /*
62107c478bd9Sstevel@tonic-gate * Over_p is pointing at g_attrnam_p
62117c478bd9Sstevel@tonic-gate * which must be preserved.
62127c478bd9Sstevel@tonic-gate *
62137c478bd9Sstevel@tonic-gate * We don't want the tmp_ptr and so
62147c478bd9Sstevel@tonic-gate * on to throw away our only copy of
62157c478bd9Sstevel@tonic-gate * the name.
62167c478bd9Sstevel@tonic-gate */
62177c478bd9Sstevel@tonic-gate Over_p = Attrfile_p;
62187c478bd9Sstevel@tonic-gate }
62197c478bd9Sstevel@tonic-gate } else {
62207c478bd9Sstevel@tonic-gate tmp_ptr = G_p->g_nam_p;
62217c478bd9Sstevel@tonic-gate G_p->g_nam_p = Over_p;
62227c478bd9Sstevel@tonic-gate Over_p = tmp_ptr;
62237c478bd9Sstevel@tonic-gate }
62247c478bd9Sstevel@tonic-gate Do_rename = 0; /* names now have original values */
62257c478bd9Sstevel@tonic-gate } else {
62267c478bd9Sstevel@tonic-gate if (unlinkat(dirfd, get_component(Over_p), 0) < 0) {
62277c478bd9Sstevel@tonic-gate msg(ERRN,
62287c478bd9Sstevel@tonic-gate "Cannot unlink() temp file \"%s%s%s\"",
6229ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
62307c478bd9Sstevel@tonic-gate Over_p : Fullnam_p,
6231ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
6232ced83f9bSceastha G_p->g_rw_sysattr ?
6233ced83f9bSceastha gettext(" System Attribute ") :
6234ced83f9bSceastha gettext(" Attribute "),
6235ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : Over_p);
62367c478bd9Sstevel@tonic-gate }
62377c478bd9Sstevel@tonic-gate }
62387c478bd9Sstevel@tonic-gate *Over_p = '\0';
62397c478bd9Sstevel@tonic-gate }
62407c478bd9Sstevel@tonic-gate if (Args & OCp) {
6241ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
62427c478bd9Sstevel@tonic-gate inam_p = G_p->g_attrfnam_p;
62437c478bd9Sstevel@tonic-gate onam_p = G_p->g_attrnam_p;
62447c478bd9Sstevel@tonic-gate } else {
62457c478bd9Sstevel@tonic-gate inam_p = Nam_p;
62467c478bd9Sstevel@tonic-gate onam_p = Fullnam_p;
62477c478bd9Sstevel@tonic-gate }
62487c478bd9Sstevel@tonic-gate } else /* OCi only uses onam_p, OCo only uses inam_p */
6249ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
62507c478bd9Sstevel@tonic-gate inam_p = onam_p = G_p->g_attrnam_p;
62517c478bd9Sstevel@tonic-gate } else {
62527c478bd9Sstevel@tonic-gate inam_p = onam_p = G_p->g_nam_p;
62537c478bd9Sstevel@tonic-gate }
62547c478bd9Sstevel@tonic-gate
62557c478bd9Sstevel@tonic-gate /*
6256647ab8f4Sceastha * Change the owner, time, and mode to those of the file
6257647ab8f4Sceastha * originally created in the archive. Note: time and
6258647ab8f4Sceastha * mode do not need to be restored for a symbolic link
6259647ab8f4Sceastha * since rstfiles() is not called when the archived file
6260647ab8f4Sceastha * is a symlink.
62617c478bd9Sstevel@tonic-gate */
6262647ab8f4Sceastha if (!(Args & OCo)) {
6263647ab8f4Sceastha if (Args & OCR) {
6264647ab8f4Sceastha if (fchownat(dirfd, get_component(onam_p),
6265647ab8f4Sceastha Rpw_p->pw_uid, Rpw_p->pw_gid,
6266647ab8f4Sceastha AT_SYMLINK_NOFOLLOW) < 0) {
6267647ab8f4Sceastha msg(ERRN, "Cannot chown() \"%s%s%s\"",
6268647ab8f4Sceastha onam_p,
6269ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
6270ced83f9bSceastha G_p->g_rw_sysattr ?
6271ced83f9bSceastha gettext(" System Attribute ") :
6272ced83f9bSceastha gettext(" Attribute "),
6273ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : onam_p);
6274647ab8f4Sceastha }
6275647ab8f4Sceastha } else {
6276647ab8f4Sceastha if ((fchownat(dirfd, get_component(onam_p),
6277647ab8f4Sceastha G_p->g_uid, G_p->g_gid,
6278647ab8f4Sceastha AT_SYMLINK_NOFOLLOW) < 0) && privileged) {
6279647ab8f4Sceastha msg(ERRN, "Cannot chown() \"%s%s%s\"",
6280647ab8f4Sceastha onam_p,
6281ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
6282ced83f9bSceastha G_p->g_rw_sysattr ?
6283ced83f9bSceastha gettext(" System Attribute ") :
6284ced83f9bSceastha gettext(" Attribute "),
6285ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : onam_p);
6286647ab8f4Sceastha }
6287647ab8f4Sceastha }
62887c478bd9Sstevel@tonic-gate
6289647ab8f4Sceastha if (Args & OCm) {
6290647ab8f4Sceastha set_tym(dirfd, get_component(onam_p),
6291647ab8f4Sceastha G_p->g_mtime, G_p->g_mtime);
6292647ab8f4Sceastha }
6293647ab8f4Sceastha
62947c478bd9Sstevel@tonic-gate /* Acl was not set, so we must chmod */
6295647ab8f4Sceastha if (!acl_is_set) {
62960b9a5158SToomas Soome mode_t orig_mask = 0, new_mask;
62977c478bd9Sstevel@tonic-gate
62987c478bd9Sstevel@tonic-gate /*
62997c478bd9Sstevel@tonic-gate * use fchmod for attributes, since
63007c478bd9Sstevel@tonic-gate * we known they are always regular
63017c478bd9Sstevel@tonic-gate * files, whereas when it isn't an
63027c478bd9Sstevel@tonic-gate * attribute it could be for a fifo
63037c478bd9Sstevel@tonic-gate * or something other that we don't
63047c478bd9Sstevel@tonic-gate * open and don't have a valid Ofile
63057c478bd9Sstevel@tonic-gate * for.
63067c478bd9Sstevel@tonic-gate */
6307647ab8f4Sceastha if (privileged) {
6308647ab8f4Sceastha new_mask = G_p->g_mode;
6309647ab8f4Sceastha } else {
6310647ab8f4Sceastha orig_mask = umask(0);
6311647ab8f4Sceastha new_mask = G_p->g_mode & ~orig_mask;
6312647ab8f4Sceastha }
6313647ab8f4Sceastha
6314ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
63157c478bd9Sstevel@tonic-gate error = fchmod(Ofile, new_mask);
63167c478bd9Sstevel@tonic-gate } else {
6317647ab8f4Sceastha error = chmod(onam_p, new_mask);
63187c478bd9Sstevel@tonic-gate }
63197c478bd9Sstevel@tonic-gate if (error < 0) {
63207c478bd9Sstevel@tonic-gate msg(ERRN,
63217c478bd9Sstevel@tonic-gate "Cannot chmod() \"%s%s%s\"",
6322ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
6323647ab8f4Sceastha onam_p : G_p->g_attrfnam_p,
6324ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
6325ced83f9bSceastha G_p->g_rw_sysattr ?
6326ced83f9bSceastha gettext(" System Attribute ") :
6327ced83f9bSceastha gettext(" Attribute "),
6328ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : onam_p);
63297c478bd9Sstevel@tonic-gate }
6330647ab8f4Sceastha if (!privileged) {
63317c478bd9Sstevel@tonic-gate (void) umask(orig_mask);
63327c478bd9Sstevel@tonic-gate }
63337c478bd9Sstevel@tonic-gate }
63347c478bd9Sstevel@tonic-gate }
63357c478bd9Sstevel@tonic-gate
63367c478bd9Sstevel@tonic-gate if (!(Args & OCi) && (Args & OCa)) {
63377c478bd9Sstevel@tonic-gate /*
63387c478bd9Sstevel@tonic-gate * Use dirfd since we are updating original file
63397c478bd9Sstevel@tonic-gate * and not just created file
63407c478bd9Sstevel@tonic-gate */
63417c478bd9Sstevel@tonic-gate set_tym(G_p->g_dirfd, get_component(inam_p),
6342*6d3b960aSAndy Fiddaman (uint_t)SrcSt.st_atime, (uint_t)SrcSt.st_mtime);
63437c478bd9Sstevel@tonic-gate }
63447c478bd9Sstevel@tonic-gate }
63457c478bd9Sstevel@tonic-gate
63467c478bd9Sstevel@tonic-gate /*
63477c478bd9Sstevel@tonic-gate * scan4trail: Scan the archive looking for the trailer.
63487c478bd9Sstevel@tonic-gate * When found, back the archive up over the trailer and overwrite
63497c478bd9Sstevel@tonic-gate * the trailer with the files to be added to the archive.
63507c478bd9Sstevel@tonic-gate */
63517c478bd9Sstevel@tonic-gate
63527c478bd9Sstevel@tonic-gate static void
scan4trail(void)63537c478bd9Sstevel@tonic-gate scan4trail(void)
63547c478bd9Sstevel@tonic-gate {
63557c478bd9Sstevel@tonic-gate int rv;
63567c478bd9Sstevel@tonic-gate off_t off1, off2;
63577c478bd9Sstevel@tonic-gate
63587c478bd9Sstevel@tonic-gate Append = 1;
63597c478bd9Sstevel@tonic-gate Hdr_type = NONE;
6360ced83f9bSceastha G_p = NULL;
63617c478bd9Sstevel@tonic-gate while (gethdr()) {
63627c478bd9Sstevel@tonic-gate G_p = &Gen;
63637c478bd9Sstevel@tonic-gate data_in(P_SKIP);
63647c478bd9Sstevel@tonic-gate }
63657c478bd9Sstevel@tonic-gate off1 = Buffr.b_cnt;
63667c478bd9Sstevel@tonic-gate off2 = Bufsize - (Buffr.b_cnt % Bufsize);
63677c478bd9Sstevel@tonic-gate Buffr.b_out_p = Buffr.b_in_p = Buffr.b_base_p;
63687c478bd9Sstevel@tonic-gate Buffr.b_cnt = (off_t)0;
63697c478bd9Sstevel@tonic-gate if (lseek(Archive, -(off1 + off2), SEEK_REL) < 0)
63707c478bd9Sstevel@tonic-gate msg(EXTN, "Unable to append to this archive");
63717c478bd9Sstevel@tonic-gate if ((rv = g_read(Device, Archive, Buffr.b_in_p, Bufsize)) < 0)
63727c478bd9Sstevel@tonic-gate msg(EXTN, "Cannot append to this archive");
63737c478bd9Sstevel@tonic-gate if (lseek(Archive, (off_t)-rv, SEEK_REL) < 0)
63747c478bd9Sstevel@tonic-gate msg(EXTN, "Unable to append to this archive");
63757c478bd9Sstevel@tonic-gate Buffr.b_cnt = off2;
63767c478bd9Sstevel@tonic-gate Buffr.b_in_p = Buffr.b_base_p + Buffr.b_cnt;
63777c478bd9Sstevel@tonic-gate Append = 0;
63787c478bd9Sstevel@tonic-gate }
63797c478bd9Sstevel@tonic-gate
63807c478bd9Sstevel@tonic-gate /*
63817c478bd9Sstevel@tonic-gate * setup: Perform setup and initialization functions. Parse the options
63827c478bd9Sstevel@tonic-gate * using getopt(3C), call ckopts to check the options and initialize various
63837c478bd9Sstevel@tonic-gate * structures and pointers. Specifically, for the -i option, save any
63847c478bd9Sstevel@tonic-gate * patterns, for the -o option, check (via stat(2)) the archive, and for
63857c478bd9Sstevel@tonic-gate * the -p option, validate the destination directory.
63867c478bd9Sstevel@tonic-gate */
63877c478bd9Sstevel@tonic-gate
63887c478bd9Sstevel@tonic-gate static void
setup(int largc,char ** largv)63897c478bd9Sstevel@tonic-gate setup(int largc, char **largv)
63907c478bd9Sstevel@tonic-gate {
63917c478bd9Sstevel@tonic-gate extern int optind;
63927c478bd9Sstevel@tonic-gate extern char *optarg;
63937c478bd9Sstevel@tonic-gate
63947c478bd9Sstevel@tonic-gate #if defined(O_XATTR)
6395ced83f9bSceastha #if defined(_PC_SATTR_ENABLED)
6396ced83f9bSceastha #ifdef WAITAROUND
6397b0ee9efaSGary Mills char *opts_p = "zabcdfiklmopqrstuvABC:DE:H:I:LM:O:PR:SV6@/";
6398ced83f9bSceastha #else
6399b0ee9efaSGary Mills char *opts_p = "abcdfiklmopqrstuvABC:DE:H:I:LM:O:PR:SV6@/";
6400ced83f9bSceastha #endif /* WAITAROUND */
6401ced83f9bSceastha
6402ced83f9bSceastha #else /* _PC_SATTR_ENABLED */
64037c478bd9Sstevel@tonic-gate #ifdef WAITAROUND
6404b0ee9efaSGary Mills char *opts_p = "zabcdfiklmopqrstuvABC:DE:H:I:LM:O:PR:SV6@";
64057c478bd9Sstevel@tonic-gate #else
6406b0ee9efaSGary Mills char *opts_p = "abcdfiklmopqrstuvABC:DE:H:I:LM:O:PR:SV6@";
6407ced83f9bSceastha #endif /* WAITAROUND */
6408ced83f9bSceastha #endif /* _PC_SATTR_ENABLED */
6409ced83f9bSceastha
6410ced83f9bSceastha #else /* O_XATTR */
64117c478bd9Sstevel@tonic-gate #ifdef WAITAROUND
6412b0ee9efaSGary Mills char *opts_p = "zabcdfiklmopqrstuvABC:DE:H:I:LM:O:PR:SV6";
64137c478bd9Sstevel@tonic-gate #else
6414b0ee9efaSGary Mills char *opts_p = "abcdfiklmopqrstuvABC:DE:H:I:LM:O:PR:SV6";
6415ced83f9bSceastha #endif /* WAITAROUND */
6416ced83f9bSceastha #endif /* O_XATTR */
64177c478bd9Sstevel@tonic-gate
64187c478bd9Sstevel@tonic-gate char *dupl_p = "Only one occurrence of -%c allowed";
64197c478bd9Sstevel@tonic-gate int option;
64207c478bd9Sstevel@tonic-gate int blk_cnt, blk_cnt_max;
64217c478bd9Sstevel@tonic-gate struct rlimit rlim;
64227c478bd9Sstevel@tonic-gate
64237c478bd9Sstevel@tonic-gate /* Remember the native page size. */
64247c478bd9Sstevel@tonic-gate
64257c478bd9Sstevel@tonic-gate PageSize = sysconf(_SC_PAGESIZE);
64267c478bd9Sstevel@tonic-gate
64277c478bd9Sstevel@tonic-gate if (PageSize == -1) {
64287c478bd9Sstevel@tonic-gate /*
64297c478bd9Sstevel@tonic-gate * This sysconf call will almost certainly never fail. The
64307c478bd9Sstevel@tonic-gate * symbol PAGESIZE itself resolves to the above sysconf call,
64317c478bd9Sstevel@tonic-gate * so we should go ahead and define our own constant.
64327c478bd9Sstevel@tonic-gate */
64337c478bd9Sstevel@tonic-gate PageSize = 8192;
64347c478bd9Sstevel@tonic-gate }
64357c478bd9Sstevel@tonic-gate
64367c478bd9Sstevel@tonic-gate Hdr_type = BIN;
64377c478bd9Sstevel@tonic-gate Max_offset = (off_t)(BIN_OFFSET_MAX);
64387c478bd9Sstevel@tonic-gate Efil_p = Hdr_p = Own_p = IOfil_p = NULL;
64397c478bd9Sstevel@tonic-gate while ((option = getopt(largc, largv, opts_p)) != EOF) {
64407c478bd9Sstevel@tonic-gate switch (option) {
64417c478bd9Sstevel@tonic-gate #ifdef WAITAROUND
64427c478bd9Sstevel@tonic-gate case 'z':
64437c478bd9Sstevel@tonic-gate /* rendezvous with the debugger */
64447c478bd9Sstevel@tonic-gate waitaround = 1;
64457c478bd9Sstevel@tonic-gate break;
64467c478bd9Sstevel@tonic-gate #endif
64477c478bd9Sstevel@tonic-gate case 'a': /* reset access time */
64487c478bd9Sstevel@tonic-gate Args |= OCa;
64497c478bd9Sstevel@tonic-gate break;
64507c478bd9Sstevel@tonic-gate case 'b': /* swap bytes and halfwords */
64517c478bd9Sstevel@tonic-gate Args |= OCb;
64527c478bd9Sstevel@tonic-gate break;
64537c478bd9Sstevel@tonic-gate case 'c': /* select character header */
64547c478bd9Sstevel@tonic-gate Args |= OCc;
64557c478bd9Sstevel@tonic-gate Hdr_type = ASC;
64567c478bd9Sstevel@tonic-gate Max_namesz = APATH;
64577c478bd9Sstevel@tonic-gate Onecopy = 1;
64587c478bd9Sstevel@tonic-gate break;
64597c478bd9Sstevel@tonic-gate case 'd': /* create directories as needed */
64607c478bd9Sstevel@tonic-gate Args |= OCd;
64617c478bd9Sstevel@tonic-gate break;
64627c478bd9Sstevel@tonic-gate case 'f': /* select files not in patterns */
64637c478bd9Sstevel@tonic-gate Args |= OCf;
64647c478bd9Sstevel@tonic-gate break;
64657c478bd9Sstevel@tonic-gate case 'i': /* "copy in" */
64667c478bd9Sstevel@tonic-gate Args |= OCi;
64677c478bd9Sstevel@tonic-gate Archive = 0;
64687c478bd9Sstevel@tonic-gate break;
64697c478bd9Sstevel@tonic-gate case 'k': /* retry after I/O errors */
64707c478bd9Sstevel@tonic-gate Args |= OCk;
64717c478bd9Sstevel@tonic-gate break;
64727c478bd9Sstevel@tonic-gate case 'l': /* link files when possible */
64737c478bd9Sstevel@tonic-gate Args |= OCl;
64747c478bd9Sstevel@tonic-gate break;
64757c478bd9Sstevel@tonic-gate case 'm': /* retain modification time */
64767c478bd9Sstevel@tonic-gate Args |= OCm;
64777c478bd9Sstevel@tonic-gate break;
64787c478bd9Sstevel@tonic-gate case 'o': /* "copy out" */
64797c478bd9Sstevel@tonic-gate Args |= OCo;
64807c478bd9Sstevel@tonic-gate Archive = 1;
64817c478bd9Sstevel@tonic-gate break;
64827c478bd9Sstevel@tonic-gate case 'p': /* "pass" */
64837c478bd9Sstevel@tonic-gate Max_namesz = APATH;
64847c478bd9Sstevel@tonic-gate Args |= OCp;
64857c478bd9Sstevel@tonic-gate break;
6486b0ee9efaSGary Mills case 'q': /* "quiet" */
6487b0ee9efaSGary Mills Args |= OCq;
6488b0ee9efaSGary Mills break;
64897c478bd9Sstevel@tonic-gate case 'r': /* rename files interactively */
64907c478bd9Sstevel@tonic-gate Args |= OCr;
64917c478bd9Sstevel@tonic-gate break;
64927c478bd9Sstevel@tonic-gate case 's': /* swap bytes */
64937c478bd9Sstevel@tonic-gate Args |= OCs;
64947c478bd9Sstevel@tonic-gate break;
64957c478bd9Sstevel@tonic-gate case 't': /* table of contents */
64967c478bd9Sstevel@tonic-gate Args |= OCt;
64977c478bd9Sstevel@tonic-gate break;
64987c478bd9Sstevel@tonic-gate case 'u': /* copy unconditionally */
64997c478bd9Sstevel@tonic-gate Args |= OCu;
65007c478bd9Sstevel@tonic-gate break;
65017c478bd9Sstevel@tonic-gate case 'v': /* verbose - print file names */
65027c478bd9Sstevel@tonic-gate Args |= OCv;
65037c478bd9Sstevel@tonic-gate break;
65047c478bd9Sstevel@tonic-gate case 'A': /* append to existing archive */
65057c478bd9Sstevel@tonic-gate Args |= OCA;
65067c478bd9Sstevel@tonic-gate break;
65077c478bd9Sstevel@tonic-gate case 'B': /* set block size to 5120 bytes */
65087c478bd9Sstevel@tonic-gate Args |= OCB;
65097c478bd9Sstevel@tonic-gate Bufsize = 5120;
65107c478bd9Sstevel@tonic-gate break;
65117c478bd9Sstevel@tonic-gate case 'C': /* set arbitrary block size */
65127c478bd9Sstevel@tonic-gate if (Args & OCC)
65137c478bd9Sstevel@tonic-gate msg(ERR, dupl_p, 'C');
65147c478bd9Sstevel@tonic-gate else {
65157c478bd9Sstevel@tonic-gate Args |= OCC;
65167c478bd9Sstevel@tonic-gate Bufsize = atoi(optarg);
65177c478bd9Sstevel@tonic-gate }
65187c478bd9Sstevel@tonic-gate break;
65197c478bd9Sstevel@tonic-gate case 'D':
65207c478bd9Sstevel@tonic-gate Dflag = 1;
65217c478bd9Sstevel@tonic-gate break;
65227c478bd9Sstevel@tonic-gate case 'E': /* alternate file for pattern input */
65237c478bd9Sstevel@tonic-gate if (Args & OCE)
65247c478bd9Sstevel@tonic-gate msg(ERR, dupl_p, 'E');
65257c478bd9Sstevel@tonic-gate else {
65267c478bd9Sstevel@tonic-gate Args |= OCE;
65277c478bd9Sstevel@tonic-gate Efil_p = optarg;
65287c478bd9Sstevel@tonic-gate }
65297c478bd9Sstevel@tonic-gate break;
65307c478bd9Sstevel@tonic-gate case 'H': /* select header type */
65317c478bd9Sstevel@tonic-gate if (Args & OCH)
65327c478bd9Sstevel@tonic-gate msg(ERR, dupl_p, 'H');
65337c478bd9Sstevel@tonic-gate else {
65347c478bd9Sstevel@tonic-gate Args |= OCH;
65357c478bd9Sstevel@tonic-gate Hdr_p = optarg;
65367c478bd9Sstevel@tonic-gate }
65377c478bd9Sstevel@tonic-gate break;
65387c478bd9Sstevel@tonic-gate case 'I': /* alternate file for archive input */
65397c478bd9Sstevel@tonic-gate if (Args & OCI)
65407c478bd9Sstevel@tonic-gate msg(ERR, dupl_p, 'I');
65417c478bd9Sstevel@tonic-gate else {
65427c478bd9Sstevel@tonic-gate Args |= OCI;
65437c478bd9Sstevel@tonic-gate IOfil_p = optarg;
65447c478bd9Sstevel@tonic-gate }
65457c478bd9Sstevel@tonic-gate break;
65467c478bd9Sstevel@tonic-gate case 'L': /* follow symbolic links */
65477c478bd9Sstevel@tonic-gate Args |= OCL;
65487c478bd9Sstevel@tonic-gate break;
65497c478bd9Sstevel@tonic-gate case 'M': /* specify new end-of-media message */
65507c478bd9Sstevel@tonic-gate if (Args & OCM)
65517c478bd9Sstevel@tonic-gate msg(ERR, dupl_p, 'M');
65527c478bd9Sstevel@tonic-gate else {
65537c478bd9Sstevel@tonic-gate Args |= OCM;
65547c478bd9Sstevel@tonic-gate Eom_p = optarg;
65557c478bd9Sstevel@tonic-gate }
65567c478bd9Sstevel@tonic-gate break;
65577c478bd9Sstevel@tonic-gate case 'O': /* alternate file for archive output */
65587c478bd9Sstevel@tonic-gate if (Args & OCO)
65597c478bd9Sstevel@tonic-gate msg(ERR, dupl_p, 'O');
65607c478bd9Sstevel@tonic-gate else {
65617c478bd9Sstevel@tonic-gate Args |= OCO;
65627c478bd9Sstevel@tonic-gate IOfil_p = optarg;
65637c478bd9Sstevel@tonic-gate }
65647c478bd9Sstevel@tonic-gate break;
65657c478bd9Sstevel@tonic-gate case 'P': /* preserve acls */
65667c478bd9Sstevel@tonic-gate Args |= OCP;
65677c478bd9Sstevel@tonic-gate Pflag++;
65687c478bd9Sstevel@tonic-gate break;
65697c478bd9Sstevel@tonic-gate case 'R': /* change owner/group of files */
65707c478bd9Sstevel@tonic-gate if (Args & OCR)
65717c478bd9Sstevel@tonic-gate msg(ERR, dupl_p, 'R');
65727c478bd9Sstevel@tonic-gate else {
65737c478bd9Sstevel@tonic-gate Args |= OCR;
65747c478bd9Sstevel@tonic-gate Own_p = optarg;
65757c478bd9Sstevel@tonic-gate }
65767c478bd9Sstevel@tonic-gate break;
65777c478bd9Sstevel@tonic-gate case 'S': /* swap halfwords */
65787c478bd9Sstevel@tonic-gate Args |= OCS;
65797c478bd9Sstevel@tonic-gate break;
65807c478bd9Sstevel@tonic-gate case 'V': /* print a dot '.' for each file */
65817c478bd9Sstevel@tonic-gate Args |= OCV;
65827c478bd9Sstevel@tonic-gate break;
65837c478bd9Sstevel@tonic-gate case '6': /* for old, sixth-edition files */
65847c478bd9Sstevel@tonic-gate Args |= OC6;
65857c478bd9Sstevel@tonic-gate Ftype = SIXTH;
65867c478bd9Sstevel@tonic-gate break;
65877c478bd9Sstevel@tonic-gate #if defined(O_XATTR)
65887c478bd9Sstevel@tonic-gate case '@':
65897c478bd9Sstevel@tonic-gate Atflag++;
65907c478bd9Sstevel@tonic-gate break;
6591ced83f9bSceastha #if defined(_PC_SATTR_ENABLED)
6592ced83f9bSceastha case '/':
6593ced83f9bSceastha SysAtflag++;
6594ced83f9bSceastha break;
6595ced83f9bSceastha #endif /* _PC_SATTR_ENABLED */
6596ced83f9bSceastha #endif /* O_XATTR */
65977c478bd9Sstevel@tonic-gate default:
65987c478bd9Sstevel@tonic-gate Error_cnt++;
65997c478bd9Sstevel@tonic-gate } /* option */
66007c478bd9Sstevel@tonic-gate } /* (option = getopt(largc, largv, opts_p)) != EOF */
66017c478bd9Sstevel@tonic-gate
66027c478bd9Sstevel@tonic-gate #ifdef WAITAROUND
66037c478bd9Sstevel@tonic-gate if (waitaround) {
66047c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("Rendezvous with cpio on pid"
66057c478bd9Sstevel@tonic-gate " %d\n"), getpid());
66067c478bd9Sstevel@tonic-gate
66077c478bd9Sstevel@tonic-gate while (waitaround) {
66087c478bd9Sstevel@tonic-gate (void) sleep(10);
66097c478bd9Sstevel@tonic-gate }
66107c478bd9Sstevel@tonic-gate }
66117c478bd9Sstevel@tonic-gate #endif
66127c478bd9Sstevel@tonic-gate
66137c478bd9Sstevel@tonic-gate largc -= optind;
66147c478bd9Sstevel@tonic-gate largv += optind;
66157c478bd9Sstevel@tonic-gate ckopts(Args);
66167c478bd9Sstevel@tonic-gate if (!Error_cnt) {
66177c478bd9Sstevel@tonic-gate if (Args & OCr) {
66187c478bd9Sstevel@tonic-gate Renam_p = e_zalloc(E_EXIT, APATH + 1);
66197c478bd9Sstevel@tonic-gate Renametmp_p = e_zalloc(E_EXIT, APATH + 1);
6620ced83f9bSceastha #if defined(_PC_SATTR_ENABLED)
6621ced83f9bSceastha Renam_attr_p = e_zalloc(E_EXIT, APATH + 1);
6622ced83f9bSceastha #endif
66237c478bd9Sstevel@tonic-gate }
66247c478bd9Sstevel@tonic-gate Symlnk_p = e_zalloc(E_EXIT, APATH);
66257c478bd9Sstevel@tonic-gate Over_p = e_zalloc(E_EXIT, APATH);
66267c478bd9Sstevel@tonic-gate Nam_p = e_zalloc(E_EXIT, APATH + 1);
66277c478bd9Sstevel@tonic-gate if (Args & OCp) {
66287c478bd9Sstevel@tonic-gate Savenam_p = e_zalloc(E_EXIT, APATH + 1);
66297c478bd9Sstevel@tonic-gate }
66307c478bd9Sstevel@tonic-gate Fullnam_p = e_zalloc(E_EXIT, APATH);
66317c478bd9Sstevel@tonic-gate Lnknam_p = e_zalloc(E_EXIT, APATH);
66327c478bd9Sstevel@tonic-gate Gen.g_nam_p = Nam_p;
6633ced83f9bSceastha if ((Fullnam_p = getcwd(NULL, APATH)) == NULL)
66347c478bd9Sstevel@tonic-gate msg(EXT, "Unable to determine current directory.");
66357c478bd9Sstevel@tonic-gate if (Args & OCi) {
66367c478bd9Sstevel@tonic-gate if (largc > 0) /* save patterns for -i option, if any */
66377c478bd9Sstevel@tonic-gate Pat_pp = largv;
66387c478bd9Sstevel@tonic-gate if (Args & OCE)
66397c478bd9Sstevel@tonic-gate getpats(largc, largv);
66407c478bd9Sstevel@tonic-gate } else if (Args & OCo) {
66417c478bd9Sstevel@tonic-gate if (largc != 0) /* error if arguments left with -o */
66427c478bd9Sstevel@tonic-gate Error_cnt++;
66437c478bd9Sstevel@tonic-gate else if (fstat(Archive, &ArchSt) < 0)
66447c478bd9Sstevel@tonic-gate msg(ERRN, "Error during stat() of archive");
66457c478bd9Sstevel@tonic-gate switch (Hdr_type) {
66467c478bd9Sstevel@tonic-gate case BIN:
66477c478bd9Sstevel@tonic-gate Hdrsz = HDRSZ;
66487c478bd9Sstevel@tonic-gate Pad_val = HALFWD;
66497c478bd9Sstevel@tonic-gate break;
66507c478bd9Sstevel@tonic-gate case CHR:
66517c478bd9Sstevel@tonic-gate Hdrsz = CHRSZ;
66527c478bd9Sstevel@tonic-gate Pad_val = 0;
66537c478bd9Sstevel@tonic-gate Max_offset = (off_t)(CHAR_OFFSET_MAX);
66547c478bd9Sstevel@tonic-gate break;
66557c478bd9Sstevel@tonic-gate case ASC:
66567c478bd9Sstevel@tonic-gate case CRC:
66577c478bd9Sstevel@tonic-gate Hdrsz = ASCSZ;
66587c478bd9Sstevel@tonic-gate Pad_val = FULLWD;
6659944d83a0Schin Max_offset = (off_t)(ASC_OFFSET_MAX);
66607c478bd9Sstevel@tonic-gate break;
66617c478bd9Sstevel@tonic-gate case TAR:
66627c478bd9Sstevel@tonic-gate /* FALLTHROUGH */
66637c478bd9Sstevel@tonic-gate case USTAR: /* TAR and USTAR */
66647c478bd9Sstevel@tonic-gate Hdrsz = TARSZ;
66657c478bd9Sstevel@tonic-gate Pad_val = FULLBK;
66667c478bd9Sstevel@tonic-gate Max_offset = (off_t)(CHAR_OFFSET_MAX);
66677c478bd9Sstevel@tonic-gate break;
66687c478bd9Sstevel@tonic-gate default:
66697c478bd9Sstevel@tonic-gate msg(EXT, "Impossible header type.");
66707c478bd9Sstevel@tonic-gate }
66717c478bd9Sstevel@tonic-gate } else { /* directory must be specified */
66727c478bd9Sstevel@tonic-gate if (largc != 1)
66737c478bd9Sstevel@tonic-gate Error_cnt++;
6674ed69b652Sjs198686 else if (access(*largv, 2) < 0 && (errno != EACCES))
6675ed69b652Sjs198686 /*
6676ed69b652Sjs198686 * EACCES is ignored here as it may occur
6677ed69b652Sjs198686 * when any directory component of the path
6678ed69b652Sjs198686 * does not have write permission, even though
6679ed69b652Sjs198686 * the destination subdirectory has write
6680ed69b652Sjs198686 * access. Writing to a read only directory
6681ed69b652Sjs198686 * is handled later, as in "copy in" mode.
6682ed69b652Sjs198686 */
66837c478bd9Sstevel@tonic-gate msg(ERRN,
66847c478bd9Sstevel@tonic-gate "Error during access() of \"%s\"", *largv);
66857c478bd9Sstevel@tonic-gate }
66867c478bd9Sstevel@tonic-gate }
66877c478bd9Sstevel@tonic-gate if (Error_cnt)
66887c478bd9Sstevel@tonic-gate usage(); /* exits! */
66897c478bd9Sstevel@tonic-gate if (Args & (OCi | OCo)) {
66907c478bd9Sstevel@tonic-gate if (!Dflag) {
66917c478bd9Sstevel@tonic-gate if (Args & (OCB | OCC)) {
66927c478bd9Sstevel@tonic-gate if (g_init(&Device, &Archive) < 0)
66937c478bd9Sstevel@tonic-gate msg(EXTN,
66947c478bd9Sstevel@tonic-gate "Error during initialization");
66957c478bd9Sstevel@tonic-gate } else {
66967c478bd9Sstevel@tonic-gate if ((Bufsize = g_init(&Device, &Archive)) < 0)
66977c478bd9Sstevel@tonic-gate msg(EXTN,
66987c478bd9Sstevel@tonic-gate "Error during initialization");
66997c478bd9Sstevel@tonic-gate }
67007c478bd9Sstevel@tonic-gate }
67017c478bd9Sstevel@tonic-gate
67027c478bd9Sstevel@tonic-gate blk_cnt_max = _20K / Bufsize;
67037c478bd9Sstevel@tonic-gate if (blk_cnt_max < MX_BUFS) {
67047c478bd9Sstevel@tonic-gate blk_cnt_max = MX_BUFS;
67057c478bd9Sstevel@tonic-gate }
67067c478bd9Sstevel@tonic-gate
67077c478bd9Sstevel@tonic-gate Buffr.b_base_p = NULL;
67087c478bd9Sstevel@tonic-gate
67097c478bd9Sstevel@tonic-gate for (blk_cnt = blk_cnt_max; blk_cnt > 1; blk_cnt--) {
67107c478bd9Sstevel@tonic-gate Buffr.b_size = (size_t)(Bufsize * blk_cnt);
67117c478bd9Sstevel@tonic-gate Buffr.b_base_p = e_valloc(E_NORMAL, Buffr.b_size);
67127c478bd9Sstevel@tonic-gate if (Buffr.b_base_p != NULL) {
67137c478bd9Sstevel@tonic-gate break;
67147c478bd9Sstevel@tonic-gate }
67157c478bd9Sstevel@tonic-gate }
67167c478bd9Sstevel@tonic-gate if (Buffr.b_base_p == NULL || Buffr.b_size < (2 * CPIOBSZ)) {
67177c478bd9Sstevel@tonic-gate msg(EXT, "Out of memory");
67187c478bd9Sstevel@tonic-gate }
67197c478bd9Sstevel@tonic-gate
67207c478bd9Sstevel@tonic-gate Buffr.b_out_p = Buffr.b_in_p = Buffr.b_base_p;
67217c478bd9Sstevel@tonic-gate Buffr.b_cnt = 0L;
67227c478bd9Sstevel@tonic-gate Buffr.b_end_p = Buffr.b_base_p + Buffr.b_size;
67237c478bd9Sstevel@tonic-gate }
67247c478bd9Sstevel@tonic-gate
67257c478bd9Sstevel@tonic-gate /*
67267c478bd9Sstevel@tonic-gate * Now that Bufsize has stabilized, we can allocate our i/o buffer
67277c478bd9Sstevel@tonic-gate */
67287c478bd9Sstevel@tonic-gate Buf_p = e_valloc(E_EXIT, Bufsize);
67297c478bd9Sstevel@tonic-gate
67307c478bd9Sstevel@tonic-gate if (Args & OCp) { /* get destination directory */
67317c478bd9Sstevel@tonic-gate (void) strcpy(Fullnam_p, *largv);
67327c478bd9Sstevel@tonic-gate if (stat(Fullnam_p, &DesSt) < 0)
67337c478bd9Sstevel@tonic-gate msg(EXTN, "Error during stat() of \"%s\"", Fullnam_p);
67347c478bd9Sstevel@tonic-gate if ((DesSt.st_mode & Ftype) != S_IFDIR)
67357c478bd9Sstevel@tonic-gate msg(EXT, "\"%s\" is not a directory", Fullnam_p);
67367c478bd9Sstevel@tonic-gate }
67377c478bd9Sstevel@tonic-gate Full_p = Fullnam_p + strlen(Fullnam_p) - 1;
67387c478bd9Sstevel@tonic-gate if (*Full_p != '/') {
67397c478bd9Sstevel@tonic-gate Full_p++;
67407c478bd9Sstevel@tonic-gate *Full_p = '/';
67417c478bd9Sstevel@tonic-gate }
67427c478bd9Sstevel@tonic-gate Full_p++;
67437c478bd9Sstevel@tonic-gate *Full_p = '\0';
67447c478bd9Sstevel@tonic-gate (void) strcpy(Lnknam_p, Fullnam_p);
67457c478bd9Sstevel@tonic-gate Lnkend_p = Lnknam_p + strlen(Lnknam_p);
67467c478bd9Sstevel@tonic-gate (void) getrlimit(RLIMIT_FSIZE, &rlim);
67477c478bd9Sstevel@tonic-gate Max_filesz = (off_t)rlim.rlim_cur;
67487c478bd9Sstevel@tonic-gate Lnk_hd.L_nxt_p = Lnk_hd.L_bck_p = &Lnk_hd;
6749ced83f9bSceastha Lnk_hd.L_lnk_p = NULL;
67507c478bd9Sstevel@tonic-gate }
67517c478bd9Sstevel@tonic-gate
67527c478bd9Sstevel@tonic-gate /*
67537c478bd9Sstevel@tonic-gate * set_tym: Set the access and/or modification times for a file.
67547c478bd9Sstevel@tonic-gate */
67557c478bd9Sstevel@tonic-gate
67567c478bd9Sstevel@tonic-gate static void
set_tym(int dirfd,char * nam_p,time_t atime,time_t mtime)67577c478bd9Sstevel@tonic-gate set_tym(int dirfd, char *nam_p, time_t atime, time_t mtime)
67587c478bd9Sstevel@tonic-gate {
67597c478bd9Sstevel@tonic-gate struct timeval times[2];
67607c478bd9Sstevel@tonic-gate
67617c478bd9Sstevel@tonic-gate times[0].tv_sec = atime;
67627c478bd9Sstevel@tonic-gate times[0].tv_usec = 0;
67637c478bd9Sstevel@tonic-gate times[1].tv_sec = mtime;
67647c478bd9Sstevel@tonic-gate times[1].tv_usec = 0;
67657c478bd9Sstevel@tonic-gate
67667c478bd9Sstevel@tonic-gate if (futimesat(dirfd, nam_p, times) < 0) {
67677c478bd9Sstevel@tonic-gate if (Args & OCa) {
67687c478bd9Sstevel@tonic-gate msg(ERRN,
67697c478bd9Sstevel@tonic-gate "Unable to reset access time for \"%s%s%s\"",
6770ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? nam_p : Fullnam_p,
6771ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
6772ced83f9bSceastha G_p->g_rw_sysattr ? gettext(" System Attribute ") :
6773ced83f9bSceastha gettext(" Attribute "),
6774ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : nam_p);
67757c478bd9Sstevel@tonic-gate } else {
67767c478bd9Sstevel@tonic-gate msg(ERRN,
67777c478bd9Sstevel@tonic-gate "Unable to reset modification time for \"%s%s%s\"",
6778ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? nam_p : Fullnam_p,
6779ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" :
6780ced83f9bSceastha G_p->g_rw_sysattr ? gettext(" System Attribute ") :
6781ced83f9bSceastha gettext(" Attribute "),
6782ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : nam_p);
67837c478bd9Sstevel@tonic-gate }
67847c478bd9Sstevel@tonic-gate }
67857c478bd9Sstevel@tonic-gate }
67867c478bd9Sstevel@tonic-gate
67877c478bd9Sstevel@tonic-gate /*
67887c478bd9Sstevel@tonic-gate * sigint: Catch interrupts. If an interrupt occurs during the extraction
67897c478bd9Sstevel@tonic-gate * of a file from the archive with the -u option set, and the filename did
67907c478bd9Sstevel@tonic-gate * exist, remove the current file and restore the original file. Then exit.
67917c478bd9Sstevel@tonic-gate */
67927c478bd9Sstevel@tonic-gate
67937c478bd9Sstevel@tonic-gate /*ARGSUSED*/
67947c478bd9Sstevel@tonic-gate static void
sigint(int sig)67957c478bd9Sstevel@tonic-gate sigint(int sig)
67967c478bd9Sstevel@tonic-gate {
67977c478bd9Sstevel@tonic-gate char *nam_p;
67987c478bd9Sstevel@tonic-gate
67997c478bd9Sstevel@tonic-gate (void) signal(SIGINT, SIG_IGN); /* block further signals */
68007c478bd9Sstevel@tonic-gate if (!Finished) {
68017c478bd9Sstevel@tonic-gate if (Args & OCi)
68027c478bd9Sstevel@tonic-gate nam_p = G_p->g_nam_p;
68037c478bd9Sstevel@tonic-gate else /* OCp */
68047c478bd9Sstevel@tonic-gate nam_p = Fullnam_p;
68057c478bd9Sstevel@tonic-gate if (*Over_p != '\0') { /* There is a temp file */
68067c478bd9Sstevel@tonic-gate if (unlink(nam_p) < 0) {
68077c478bd9Sstevel@tonic-gate msg(ERRN,
68087c478bd9Sstevel@tonic-gate "Cannot remove incomplete \"%s\"", nam_p);
68097c478bd9Sstevel@tonic-gate }
68107c478bd9Sstevel@tonic-gate if (rename(Over_p, nam_p) < 0) {
68117c478bd9Sstevel@tonic-gate if (link(Over_p, nam_p) < 0) {
68127c478bd9Sstevel@tonic-gate msg(ERRN,
68137c478bd9Sstevel@tonic-gate "Cannot recover original \"%s\"",
68147c478bd9Sstevel@tonic-gate nam_p);
68157c478bd9Sstevel@tonic-gate }
68167c478bd9Sstevel@tonic-gate if (unlink(Over_p)) {
68177c478bd9Sstevel@tonic-gate msg(ERRN,
68187c478bd9Sstevel@tonic-gate "Cannot remove temp file \"%s\"",
68197c478bd9Sstevel@tonic-gate Over_p);
68207c478bd9Sstevel@tonic-gate }
68217c478bd9Sstevel@tonic-gate }
68227c478bd9Sstevel@tonic-gate } else if (unlink(nam_p))
6823351716f7SToomas Soome msg(ERRN, "Cannot remove incomplete \"%s\"", nam_p);
68247c478bd9Sstevel@tonic-gate *Over_p = '\0';
68257c478bd9Sstevel@tonic-gate }
68267c478bd9Sstevel@tonic-gate exit(EXIT_CODE);
68277c478bd9Sstevel@tonic-gate }
68287c478bd9Sstevel@tonic-gate
68297c478bd9Sstevel@tonic-gate /*
68307c478bd9Sstevel@tonic-gate * swap: Swap bytes (-s), halfwords (-S) or or both halfwords and bytes (-b).
68317c478bd9Sstevel@tonic-gate */
68327c478bd9Sstevel@tonic-gate
68337c478bd9Sstevel@tonic-gate static void
swap(char * buf_p,int cnt)68347c478bd9Sstevel@tonic-gate swap(char *buf_p, int cnt)
68357c478bd9Sstevel@tonic-gate {
68367c478bd9Sstevel@tonic-gate unsigned char tbyte;
68377c478bd9Sstevel@tonic-gate int tcnt;
68387c478bd9Sstevel@tonic-gate int rcnt;
68397c478bd9Sstevel@tonic-gate ushort_t thalf;
68407c478bd9Sstevel@tonic-gate
68417c478bd9Sstevel@tonic-gate rcnt = cnt % 4;
68427c478bd9Sstevel@tonic-gate cnt /= 4;
68437c478bd9Sstevel@tonic-gate if (Args & (OCb | OCs | BSM)) {
68447c478bd9Sstevel@tonic-gate tcnt = cnt;
68457c478bd9Sstevel@tonic-gate Swp_p = (union swpbuf *)buf_p;
68467c478bd9Sstevel@tonic-gate while (tcnt-- > 0) {
68477c478bd9Sstevel@tonic-gate tbyte = Swp_p->s_byte[0];
68487c478bd9Sstevel@tonic-gate Swp_p->s_byte[0] = Swp_p->s_byte[1];
68497c478bd9Sstevel@tonic-gate Swp_p->s_byte[1] = tbyte;
68507c478bd9Sstevel@tonic-gate tbyte = Swp_p->s_byte[2];
68517c478bd9Sstevel@tonic-gate Swp_p->s_byte[2] = Swp_p->s_byte[3];
68527c478bd9Sstevel@tonic-gate Swp_p->s_byte[3] = tbyte;
68537c478bd9Sstevel@tonic-gate Swp_p++;
68547c478bd9Sstevel@tonic-gate }
68557c478bd9Sstevel@tonic-gate if (rcnt >= 2) {
68567c478bd9Sstevel@tonic-gate tbyte = Swp_p->s_byte[0];
68577c478bd9Sstevel@tonic-gate Swp_p->s_byte[0] = Swp_p->s_byte[1];
68587c478bd9Sstevel@tonic-gate Swp_p->s_byte[1] = tbyte;
68597c478bd9Sstevel@tonic-gate tbyte = Swp_p->s_byte[2];
68607c478bd9Sstevel@tonic-gate }
68617c478bd9Sstevel@tonic-gate }
68627c478bd9Sstevel@tonic-gate if (Args & (OCb | OCS)) {
68637c478bd9Sstevel@tonic-gate tcnt = cnt;
68647c478bd9Sstevel@tonic-gate Swp_p = (union swpbuf *)buf_p;
68657c478bd9Sstevel@tonic-gate while (tcnt-- > 0) {
68667c478bd9Sstevel@tonic-gate thalf = Swp_p->s_half[0];
68677c478bd9Sstevel@tonic-gate Swp_p->s_half[0] = Swp_p->s_half[1];
68687c478bd9Sstevel@tonic-gate Swp_p->s_half[1] = thalf;
68697c478bd9Sstevel@tonic-gate Swp_p++;
68707c478bd9Sstevel@tonic-gate }
68717c478bd9Sstevel@tonic-gate }
68727c478bd9Sstevel@tonic-gate }
68737c478bd9Sstevel@tonic-gate
68747c478bd9Sstevel@tonic-gate /*
68757c478bd9Sstevel@tonic-gate * usage: Print the usage message on stderr and exit.
68767c478bd9Sstevel@tonic-gate */
68777c478bd9Sstevel@tonic-gate
68787c478bd9Sstevel@tonic-gate static void
usage(void)68797c478bd9Sstevel@tonic-gate usage(void)
68807c478bd9Sstevel@tonic-gate {
68817c478bd9Sstevel@tonic-gate
68827c478bd9Sstevel@tonic-gate (void) fflush(stdout);
68837c478bd9Sstevel@tonic-gate #if defined(O_XATTR)
68847c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("USAGE:\n"
6885b0ee9efaSGary Mills "\tcpio -i[bcdfkmqrstuv@BSV6] [-C size] "
68867c478bd9Sstevel@tonic-gate "[-E file] [-H hdr] [-I file [-M msg]] "
68877c478bd9Sstevel@tonic-gate "[-R id] [patterns]\n"
68887c478bd9Sstevel@tonic-gate "\tcpio -o[acv@ABLV] [-C size] "
68897c478bd9Sstevel@tonic-gate "[-H hdr] [-O file [-M msg]]\n"
68907c478bd9Sstevel@tonic-gate "\tcpio -p[adlmuv@LV] [-R id] directory\n"));
68917c478bd9Sstevel@tonic-gate #else
68927c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("USAGE:\n"
6893b0ee9efaSGary Mills "\tcpio -i[bcdfkmqrstuvBSV6] [-C size] "
68947c478bd9Sstevel@tonic-gate "[-E file] [-H hdr] [-I file [-M msg]] "
68957c478bd9Sstevel@tonic-gate "[-R id] [patterns]\n"
68967c478bd9Sstevel@tonic-gate "\tcpio -o[acvABLV] [-C size] "
68977c478bd9Sstevel@tonic-gate "[-H hdr] [-O file [-M msg]]\n"
68987c478bd9Sstevel@tonic-gate "\tcpio -p[adlmuvLV] [-R id] directory\n"));
68997c478bd9Sstevel@tonic-gate #endif
69007c478bd9Sstevel@tonic-gate (void) fflush(stderr);
69017c478bd9Sstevel@tonic-gate exit(EXIT_CODE);
69027c478bd9Sstevel@tonic-gate }
69037c478bd9Sstevel@tonic-gate
69047c478bd9Sstevel@tonic-gate /*
69057c478bd9Sstevel@tonic-gate * verbose: For each file, print either the filename (-v) or a dot (-V).
69067c478bd9Sstevel@tonic-gate * If the -t option (table of contents) is set, print either the filename,
69077c478bd9Sstevel@tonic-gate * or if the -v option is also set, print an "ls -l"-like listing.
69087c478bd9Sstevel@tonic-gate */
69097c478bd9Sstevel@tonic-gate
69107c478bd9Sstevel@tonic-gate static void
verbose(char * nam_p)69117c478bd9Sstevel@tonic-gate verbose(char *nam_p)
69127c478bd9Sstevel@tonic-gate {
69137c478bd9Sstevel@tonic-gate int i, j, temp;
69147c478bd9Sstevel@tonic-gate mode_t mode;
69157c478bd9Sstevel@tonic-gate char modestr[12];
69165fbb8099SNobutomo Nakano time_t ttime;
69177c478bd9Sstevel@tonic-gate
69187c478bd9Sstevel@tonic-gate /*
69197c478bd9Sstevel@tonic-gate * The printf format and associated arguments to print the current
69207c478bd9Sstevel@tonic-gate * filename. Normally, just nam_p. If we're processing an extended
69217c478bd9Sstevel@tonic-gate * attribute, these are overridden.
69227c478bd9Sstevel@tonic-gate */
69237c478bd9Sstevel@tonic-gate char *name_fmt = "%s";
69247c478bd9Sstevel@tonic-gate const char *name = nam_p;
69257c478bd9Sstevel@tonic-gate const char *attribute = NULL;
69267c478bd9Sstevel@tonic-gate
6927ced83f9bSceastha if (Gen.g_attrnam_p != NULL) {
69287c478bd9Sstevel@tonic-gate /*
69297c478bd9Sstevel@tonic-gate * Translation note:
69307c478bd9Sstevel@tonic-gate * 'attribute' is a noun.
69317c478bd9Sstevel@tonic-gate */
6932da6c28aaSamw
6933ced83f9bSceastha if (Gen.g_rw_sysattr) {
6934ced83f9bSceastha name_fmt = gettext("%s system attribute %s");
6935ced83f9bSceastha } else if ((Args & OCt) &&
6936ced83f9bSceastha (is_sysattr(basename(Gen.g_attrnam_p)))) {
6937da6c28aaSamw name_fmt = gettext("%s system attribute %s");
6938da6c28aaSamw } else {
69397c478bd9Sstevel@tonic-gate name_fmt = gettext("%s attribute %s");
6940da6c28aaSamw }
69417c478bd9Sstevel@tonic-gate
69427c478bd9Sstevel@tonic-gate name = (Args & OCp) ? nam_p : Gen.g_attrfnam_p;
6943ced83f9bSceastha if (Gen.g_attrparent_p == NULL) {
69447c478bd9Sstevel@tonic-gate attribute = Gen.g_attrnam_p;
6945ced83f9bSceastha } else {
6946ced83f9bSceastha attribute = Gen.g_attrpath_p;
6947ced83f9bSceastha }
69487c478bd9Sstevel@tonic-gate }
69497c478bd9Sstevel@tonic-gate
69507c478bd9Sstevel@tonic-gate if ((Gen.g_mode == SECMODE) || ((Hdr_type == USTAR ||
69517c478bd9Sstevel@tonic-gate Hdr_type == TAR) && Thdr_p->tbuf.t_typeflag == 'A')) {
69527c478bd9Sstevel@tonic-gate /* dont print ancillary file */
69537c478bd9Sstevel@tonic-gate aclchar = '+';
69547c478bd9Sstevel@tonic-gate return;
69557c478bd9Sstevel@tonic-gate }
69567c478bd9Sstevel@tonic-gate for (i = 0; i < 11; i++)
69577c478bd9Sstevel@tonic-gate modestr[i] = '-';
69587c478bd9Sstevel@tonic-gate modestr[i] = '\0';
69597c478bd9Sstevel@tonic-gate modestr[i-1] = aclchar;
69607c478bd9Sstevel@tonic-gate aclchar = ' ';
69617c478bd9Sstevel@tonic-gate
69627c478bd9Sstevel@tonic-gate if ((Args & OCt) && (Args & OCv)) {
69637c478bd9Sstevel@tonic-gate mode = Gen.g_mode;
69647c478bd9Sstevel@tonic-gate for (i = 0; i < 3; i++) {
69657c478bd9Sstevel@tonic-gate temp = (mode >> (6 - (i * 3)));
69667c478bd9Sstevel@tonic-gate j = (i * 3) + 1;
69677c478bd9Sstevel@tonic-gate if (S_IROTH & temp)
69687c478bd9Sstevel@tonic-gate modestr[j] = 'r';
69697c478bd9Sstevel@tonic-gate if (S_IWOTH & temp)
69707c478bd9Sstevel@tonic-gate modestr[j + 1] = 'w';
69717c478bd9Sstevel@tonic-gate if (S_IXOTH & temp)
69727c478bd9Sstevel@tonic-gate modestr[j + 2] = 'x';
69737c478bd9Sstevel@tonic-gate }
69747c478bd9Sstevel@tonic-gate
69757c478bd9Sstevel@tonic-gate if (Hdr_type != BAR) {
69767c478bd9Sstevel@tonic-gate temp = Gen.g_mode & Ftype;
69777c478bd9Sstevel@tonic-gate switch (temp) {
69787c478bd9Sstevel@tonic-gate case (S_IFIFO):
69797c478bd9Sstevel@tonic-gate modestr[0] = 'p';
69807c478bd9Sstevel@tonic-gate break;
6981ced83f9bSceastha case (S_IFSOCK):
6982ced83f9bSceastha modestr[0] = 's';
6983ced83f9bSceastha break;
69847c478bd9Sstevel@tonic-gate case (S_IFCHR):
69857c478bd9Sstevel@tonic-gate modestr[0] = 'c';
69867c478bd9Sstevel@tonic-gate break;
69877c478bd9Sstevel@tonic-gate case (S_IFDIR):
69887c478bd9Sstevel@tonic-gate modestr[0] = 'd';
69897c478bd9Sstevel@tonic-gate break;
69907c478bd9Sstevel@tonic-gate case (S_IFBLK):
69917c478bd9Sstevel@tonic-gate modestr[0] = 'b';
69927c478bd9Sstevel@tonic-gate break;
69937c478bd9Sstevel@tonic-gate case (S_IFREG): /* was initialized to '-' */
69947c478bd9Sstevel@tonic-gate break;
69957c478bd9Sstevel@tonic-gate case (S_IFLNK):
69967c478bd9Sstevel@tonic-gate modestr[0] = 'l';
69977c478bd9Sstevel@tonic-gate break;
69987c478bd9Sstevel@tonic-gate default:
69997c478bd9Sstevel@tonic-gate msg(ERR, "Impossible file type");
70007c478bd9Sstevel@tonic-gate }
70017c478bd9Sstevel@tonic-gate } else { /* bar */
70027c478bd9Sstevel@tonic-gate temp = Gen.g_mode & Ftype;
70037c478bd9Sstevel@tonic-gate switch (temp) {
70047c478bd9Sstevel@tonic-gate case (S_IFIFO):
70057c478bd9Sstevel@tonic-gate modestr[0] = 'p';
70067c478bd9Sstevel@tonic-gate break;
7007ced83f9bSceastha case (S_IFSOCK):
7008ced83f9bSceastha modestr[0] = 's';
7009ced83f9bSceastha break;
70107c478bd9Sstevel@tonic-gate case (S_IFCHR):
70117c478bd9Sstevel@tonic-gate modestr[0] = 'c';
70127c478bd9Sstevel@tonic-gate break;
70137c478bd9Sstevel@tonic-gate case (S_IFDIR):
70147c478bd9Sstevel@tonic-gate modestr[0] = 'd';
70157c478bd9Sstevel@tonic-gate break;
70167c478bd9Sstevel@tonic-gate case (S_IFBLK):
70177c478bd9Sstevel@tonic-gate modestr[0] = 'b';
70187c478bd9Sstevel@tonic-gate break;
70197c478bd9Sstevel@tonic-gate }
70207c478bd9Sstevel@tonic-gate if (bar_linkflag == SYMTYPE)
70217c478bd9Sstevel@tonic-gate modestr[0] = 'l';
70227c478bd9Sstevel@tonic-gate }
70237c478bd9Sstevel@tonic-gate if ((S_ISUID & Gen.g_mode) == S_ISUID)
70247c478bd9Sstevel@tonic-gate modestr[3] = 's';
70257c478bd9Sstevel@tonic-gate if ((S_ISVTX & Gen.g_mode) == S_ISVTX)
70267c478bd9Sstevel@tonic-gate modestr[9] = 't';
70277c478bd9Sstevel@tonic-gate if ((S_ISGID & G_p->g_mode) == S_ISGID && modestr[6] == 'x')
70287c478bd9Sstevel@tonic-gate modestr[6] = 's';
70297c478bd9Sstevel@tonic-gate else if ((S_ENFMT & Gen.g_mode) == S_ENFMT && modestr[6] != 'x')
70307c478bd9Sstevel@tonic-gate modestr[6] = 'l';
70317c478bd9Sstevel@tonic-gate if ((Hdr_type == TAR || Hdr_type == USTAR) && Gen.g_nlink == 0)
70327c478bd9Sstevel@tonic-gate (void) printf("%s%4d ", modestr, (int)Gen.g_nlink+1);
70337c478bd9Sstevel@tonic-gate else
70347c478bd9Sstevel@tonic-gate (void) printf("%s%4d ", modestr, (int)Gen.g_nlink);
70355fbb8099SNobutomo Nakano if (Lastuid == (uid_t)Gen.g_uid) {
70365fbb8099SNobutomo Nakano if (Lastuid == (uid_t)-1)
70377c478bd9Sstevel@tonic-gate (void) printf("-1 ");
70387c478bd9Sstevel@tonic-gate else
70397c478bd9Sstevel@tonic-gate (void) printf("%-9s", Curpw_p->pw_name);
70407c478bd9Sstevel@tonic-gate } else {
7041*6d3b960aSAndy Fiddaman if ((Curpw_p = getpwuid((int)Gen.g_uid)) != NULL) {
70427c478bd9Sstevel@tonic-gate (void) printf("%-9s", Curpw_p->pw_name);
70435fbb8099SNobutomo Nakano Lastuid = (uid_t)Gen.g_uid;
70447c478bd9Sstevel@tonic-gate } else {
70457c478bd9Sstevel@tonic-gate (void) printf("%-9d", (int)Gen.g_uid);
70465fbb8099SNobutomo Nakano Lastuid = (uid_t)-1;
70477c478bd9Sstevel@tonic-gate }
70487c478bd9Sstevel@tonic-gate }
70495fbb8099SNobutomo Nakano if (Lastgid == (gid_t)Gen.g_gid) {
70505fbb8099SNobutomo Nakano if (Lastgid == (gid_t)-1)
70517c478bd9Sstevel@tonic-gate (void) printf("-1 ");
70527c478bd9Sstevel@tonic-gate else
70537c478bd9Sstevel@tonic-gate (void) printf("%-9s", Curgr_p->gr_name);
70547c478bd9Sstevel@tonic-gate } else {
7055*6d3b960aSAndy Fiddaman if ((Curgr_p = getgrgid((int)Gen.g_gid)) != NULL) {
70567c478bd9Sstevel@tonic-gate (void) printf("%-9s", Curgr_p->gr_name);
70575fbb8099SNobutomo Nakano Lastgid = (gid_t)Gen.g_gid;
70587c478bd9Sstevel@tonic-gate } else {
70597c478bd9Sstevel@tonic-gate (void) printf("%-9d", (int)Gen.g_gid);
70605fbb8099SNobutomo Nakano Lastgid = (gid_t)-1;
70617c478bd9Sstevel@tonic-gate }
70627c478bd9Sstevel@tonic-gate }
70637c478bd9Sstevel@tonic-gate
70647c478bd9Sstevel@tonic-gate /* print file size */
70657c478bd9Sstevel@tonic-gate if (!Aspec || ((Gen.g_mode & Ftype) == S_IFIFO) ||
7066ced83f9bSceastha ((Gen.g_mode & Ftype) == S_IFSOCK) ||
70677c478bd9Sstevel@tonic-gate (Hdr_type == BAR && bar_linkflag == SYMTYPE)) {
70685fbb8099SNobutomo Nakano off_t filesz = Gen.g_filesz;
70695fbb8099SNobutomo Nakano
70705fbb8099SNobutomo Nakano if (S_ISSPARSE(Gen.g_mode) && Gen.g_holes != NULL)
70715fbb8099SNobutomo Nakano filesz = Gen.g_holes->orig_size;
70725fbb8099SNobutomo Nakano
7073*6d3b960aSAndy Fiddaman (void) printf("%*" PRId64 " ",
7074*6d3b960aSAndy Fiddaman filesz < (1L << 31) ? 7 : 11, filesz);
7075*6d3b960aSAndy Fiddaman } else {
7076*6d3b960aSAndy Fiddaman (void) printf("%3" PRId32 ",%3" PRId32 " ",
7077*6d3b960aSAndy Fiddaman major(Gen.g_rdev), minor(Gen.g_rdev));
7078*6d3b960aSAndy Fiddaman }
70795fbb8099SNobutomo Nakano ttime = Gen.g_mtime;
70805fbb8099SNobutomo Nakano (void) strftime(Time, sizeof (Time),
70815fbb8099SNobutomo Nakano dcgettext(NULL, FORMAT, LC_TIME), localtime(&ttime));
70827c478bd9Sstevel@tonic-gate (void) printf("%s, ", Time);
70835fbb8099SNobutomo Nakano str_fprintf(stdout, name_fmt, name, attribute);
70847c478bd9Sstevel@tonic-gate if ((Gen.g_mode & Ftype) == S_IFLNK) {
7085*6d3b960aSAndy Fiddaman if (Hdr_type == USTAR || Hdr_type == TAR) {
70867c478bd9Sstevel@tonic-gate (void) strcpy(Symlnk_p,
70877c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_linkname);
7088*6d3b960aSAndy Fiddaman } else {
708932fd2847Snakanon FILL(Gen.g_filesz);
70907c478bd9Sstevel@tonic-gate (void) strncpy(Symlnk_p, Buffr.b_out_p,
70917c478bd9Sstevel@tonic-gate Gen.g_filesz);
70927c478bd9Sstevel@tonic-gate *(Symlnk_p + Gen.g_filesz) = '\0';
70937c478bd9Sstevel@tonic-gate }
70947c478bd9Sstevel@tonic-gate (void) printf(" -> %s", Symlnk_p);
70957c478bd9Sstevel@tonic-gate }
70967c478bd9Sstevel@tonic-gate if (Hdr_type == BAR) {
70977c478bd9Sstevel@tonic-gate if (bar_linkflag == SYMTYPE)
70987c478bd9Sstevel@tonic-gate (void) printf(gettext(" symbolic link to %s"),
70997c478bd9Sstevel@tonic-gate bar_linkname);
71007c478bd9Sstevel@tonic-gate else if (bar_linkflag == '1')
71017c478bd9Sstevel@tonic-gate (void) printf(gettext(" linked to %s"),
71027c478bd9Sstevel@tonic-gate bar_linkname);
71037c478bd9Sstevel@tonic-gate }
71047c478bd9Sstevel@tonic-gate if ((Hdr_type == USTAR || Hdr_type == TAR) &&
71057c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_typeflag == '1') {
71067c478bd9Sstevel@tonic-gate (void) printf(gettext(" linked to %s%s%s"),
7107ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
71087c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_linkname : Gen.g_attrfnam_p,
7109ced83f9bSceastha (Gen.g_attrnam_p == NULL) ? "" :
7110ced83f9bSceastha gettext(" attribute "),
7111ced83f9bSceastha (Gen.g_attrnam_p == NULL) ?
71127c478bd9Sstevel@tonic-gate "" : Gen.g_linktoattrnam_p);
71137c478bd9Sstevel@tonic-gate }
71147c478bd9Sstevel@tonic-gate (void) printf("\n");
71157c478bd9Sstevel@tonic-gate } else if ((Args & OCt) || (Args & OCv)) {
71165fbb8099SNobutomo Nakano str_fprintf(Out_p, name_fmt, name, attribute);
71177c478bd9Sstevel@tonic-gate (void) fputc('\n', Out_p);
71187c478bd9Sstevel@tonic-gate } else { /* OCV */
71197c478bd9Sstevel@tonic-gate (void) fputc('.', Out_p);
71207c478bd9Sstevel@tonic-gate if (Verbcnt++ >= 49) { /* start a new line of dots */
71217c478bd9Sstevel@tonic-gate Verbcnt = 0;
71227c478bd9Sstevel@tonic-gate (void) fputc('\n', Out_p);
71237c478bd9Sstevel@tonic-gate }
71247c478bd9Sstevel@tonic-gate }
71257c478bd9Sstevel@tonic-gate (void) fflush(Out_p);
71267c478bd9Sstevel@tonic-gate }
71277c478bd9Sstevel@tonic-gate
71287c478bd9Sstevel@tonic-gate /*
71297c478bd9Sstevel@tonic-gate * write_hdr: Transfer header information for the generic structure
71307c478bd9Sstevel@tonic-gate * into the format for the selected header and bwrite() the header.
71317c478bd9Sstevel@tonic-gate */
71327c478bd9Sstevel@tonic-gate
71337c478bd9Sstevel@tonic-gate static void
write_hdr(int arcflag,off_t len)71345fbb8099SNobutomo Nakano write_hdr(int arcflag, off_t len)
71357c478bd9Sstevel@tonic-gate {
71360b9a5158SToomas Soome int cnt = 0, pad;
71370b9a5158SToomas Soome mode_t mode = 0;
7138*6d3b960aSAndy Fiddaman major_t maj;
7139*6d3b960aSAndy Fiddaman minor_t min;
71407c478bd9Sstevel@tonic-gate uid_t uid;
71417c478bd9Sstevel@tonic-gate gid_t gid;
71427c478bd9Sstevel@tonic-gate const char warnfmt[] = "%s%s%s : %s";
71437c478bd9Sstevel@tonic-gate
71445fbb8099SNobutomo Nakano switch (arcflag) {
71455fbb8099SNobutomo Nakano case ARCHIVE_ACL:
71467c478bd9Sstevel@tonic-gate mode = SECMODE;
71475fbb8099SNobutomo Nakano break;
71485fbb8099SNobutomo Nakano
71495fbb8099SNobutomo Nakano case ARCHIVE_XATTR:
71505fbb8099SNobutomo Nakano case ARCHIVE_NORMAL:
71517c478bd9Sstevel@tonic-gate /*
71527c478bd9Sstevel@tonic-gate * If attribute is being archived in cpio format then
71537c478bd9Sstevel@tonic-gate * zap off the file type bits since those are truly a
71547c478bd9Sstevel@tonic-gate * mask and reset them with _XATTR_CPIO_MODE
71557c478bd9Sstevel@tonic-gate */
71567c478bd9Sstevel@tonic-gate /*
71577c478bd9Sstevel@tonic-gate * len is the value of g_filesz for normal files
71587c478bd9Sstevel@tonic-gate * and the length of the special header buffer in
71597c478bd9Sstevel@tonic-gate * the case of acl and xattr headers.
71607c478bd9Sstevel@tonic-gate */
7161ced83f9bSceastha if (G_p->g_attrnam_p != NULL && Hdr_type != USTAR &&
71627c478bd9Sstevel@tonic-gate Hdr_type != TAR) {
7163d2443e76Smarks mode = (G_p->g_mode & POSIXMODES) | _XATTR_CPIO_MODE;
71647c478bd9Sstevel@tonic-gate } else {
71657c478bd9Sstevel@tonic-gate mode = G_p->g_mode;
71667c478bd9Sstevel@tonic-gate }
71675fbb8099SNobutomo Nakano if (arcflag != ARCHIVE_XATTR) {
71687c478bd9Sstevel@tonic-gate len = G_p->g_filesz;
71697c478bd9Sstevel@tonic-gate }
71705fbb8099SNobutomo Nakano break;
71715fbb8099SNobutomo Nakano
71725fbb8099SNobutomo Nakano case ARCHIVE_SPARSE:
71735fbb8099SNobutomo Nakano mode = G_p->g_mode | C_ISSPARSE;
71745fbb8099SNobutomo Nakano len = G_p->g_filesz;
71755fbb8099SNobutomo Nakano break;
71767c478bd9Sstevel@tonic-gate }
71777c478bd9Sstevel@tonic-gate
71787c478bd9Sstevel@tonic-gate uid = G_p->g_uid;
71797c478bd9Sstevel@tonic-gate gid = G_p->g_gid;
71807c478bd9Sstevel@tonic-gate /*
71817c478bd9Sstevel@tonic-gate * Handle EFT uids and gids. If they get too big
71827c478bd9Sstevel@tonic-gate * to be represented in a particular format, force 'em to 'nobody'.
71837c478bd9Sstevel@tonic-gate */
71847c478bd9Sstevel@tonic-gate switch (Hdr_type) {
71857c478bd9Sstevel@tonic-gate case BIN: /* 16-bits of u_short */
7186*6d3b960aSAndy Fiddaman if ((uint_t)uid > (uint_t)USHRT_MAX)
71877c478bd9Sstevel@tonic-gate uid = UID_NOBODY;
7188*6d3b960aSAndy Fiddaman if ((uint_t)gid > (uint_t)USHRT_MAX)
71897c478bd9Sstevel@tonic-gate gid = GID_NOBODY;
71907c478bd9Sstevel@tonic-gate break;
7191*6d3b960aSAndy Fiddaman case CHR: /* %.6o => 262143 base 10 */
7192*6d3b960aSAndy Fiddaman if ((uint_t)uid > (uint_t)0777777)
71937c478bd9Sstevel@tonic-gate uid = UID_NOBODY;
7194*6d3b960aSAndy Fiddaman if ((uint_t)gid > (uint_t)0777777)
71957c478bd9Sstevel@tonic-gate gid = GID_NOBODY;
71967c478bd9Sstevel@tonic-gate break;
7197*6d3b960aSAndy Fiddaman case ASC: /* %.8x => full 32 bits */
71987c478bd9Sstevel@tonic-gate case CRC:
71997c478bd9Sstevel@tonic-gate break;
72007c478bd9Sstevel@tonic-gate case USTAR:
7201*6d3b960aSAndy Fiddaman case TAR: /* %.7o => 2097151 base 10 */
7202*6d3b960aSAndy Fiddaman if ((uint_t)uid > (uint_t)07777777)
72037c478bd9Sstevel@tonic-gate uid = UID_NOBODY;
7204*6d3b960aSAndy Fiddaman if ((uint_t)gid > (uint_t)07777777)
72057c478bd9Sstevel@tonic-gate gid = GID_NOBODY;
72067c478bd9Sstevel@tonic-gate break;
72077c478bd9Sstevel@tonic-gate default:
72087c478bd9Sstevel@tonic-gate msg(EXT, "Impossible header type.");
72097c478bd9Sstevel@tonic-gate }
72107c478bd9Sstevel@tonic-gate
72117c478bd9Sstevel@tonic-gate /*
72127c478bd9Sstevel@tonic-gate * Since cpio formats -don't- encode the symbolic names, print
72137c478bd9Sstevel@tonic-gate * a warning message when we map the uid or gid this way.
72147c478bd9Sstevel@tonic-gate * Also, if the ownership just changed, clear set[ug]id bits
72157c478bd9Sstevel@tonic-gate *
72167c478bd9Sstevel@tonic-gate * (Except for USTAR format of course, where we have a string
72177c478bd9Sstevel@tonic-gate * representation of the username embedded in the header)
72187c478bd9Sstevel@tonic-gate */
72197c478bd9Sstevel@tonic-gate if (uid != G_p->g_uid && Hdr_type != USTAR) {
72207c478bd9Sstevel@tonic-gate msg(ERR, warnfmt,
7221ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
72227c478bd9Sstevel@tonic-gate G_p->g_nam_p : G_p->g_attrfnam_p,
7223ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : G_p->g_rw_sysattr ?
7224ced83f9bSceastha gettext(" System Attribute ") : gettext(" Attribute "),
7225ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : G_p->g_attrnam_p,
72267c478bd9Sstevel@tonic-gate gettext("uid too large for archive format"));
72277c478bd9Sstevel@tonic-gate if (S_ISREG(mode))
72287c478bd9Sstevel@tonic-gate mode &= ~S_ISUID;
72297c478bd9Sstevel@tonic-gate }
72307c478bd9Sstevel@tonic-gate if (gid != G_p->g_gid && Hdr_type != USTAR) {
72317c478bd9Sstevel@tonic-gate msg(ERR, warnfmt,
7232ced83f9bSceastha (G_p->g_attrnam_p == NULL) ?
72337c478bd9Sstevel@tonic-gate G_p->g_nam_p : G_p->g_attrfnam_p,
7234ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : G_p->g_rw_sysattr ?
7235ced83f9bSceastha gettext(" System Attribute ") : gettext(" Attribute "),
7236ced83f9bSceastha (G_p->g_attrnam_p == NULL) ? "" : G_p->g_attrnam_p,
72377c478bd9Sstevel@tonic-gate gettext("gid too large for archive format"));
72387c478bd9Sstevel@tonic-gate if (S_ISREG(mode))
72397c478bd9Sstevel@tonic-gate mode &= ~S_ISGID;
72407c478bd9Sstevel@tonic-gate }
72417c478bd9Sstevel@tonic-gate
72427c478bd9Sstevel@tonic-gate switch (Hdr_type) {
72437c478bd9Sstevel@tonic-gate case BIN:
72447c478bd9Sstevel@tonic-gate case CHR:
72457c478bd9Sstevel@tonic-gate case ASC:
72467c478bd9Sstevel@tonic-gate case CRC:
72477c478bd9Sstevel@tonic-gate cnt = Hdrsz + G_p->g_namesz;
72487c478bd9Sstevel@tonic-gate break;
72497c478bd9Sstevel@tonic-gate case TAR:
72507c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/
72517c478bd9Sstevel@tonic-gate case USTAR: /* TAR and USTAR */
72527c478bd9Sstevel@tonic-gate cnt = TARSZ;
72537c478bd9Sstevel@tonic-gate break;
72547c478bd9Sstevel@tonic-gate default:
72557c478bd9Sstevel@tonic-gate msg(EXT, "Impossible header type.");
72567c478bd9Sstevel@tonic-gate }
72577c478bd9Sstevel@tonic-gate FLUSH(cnt);
72587c478bd9Sstevel@tonic-gate
72597c478bd9Sstevel@tonic-gate switch (Hdr_type) {
72607c478bd9Sstevel@tonic-gate case BIN:
72617c478bd9Sstevel@tonic-gate Hdr.h_magic = (short)G_p->g_magic;
72627c478bd9Sstevel@tonic-gate Hdr.h_dev = G_p->g_dev;
72637c478bd9Sstevel@tonic-gate Hdr.h_ino = G_p->g_ino;
72647c478bd9Sstevel@tonic-gate Hdr.h_uid = uid;
72657c478bd9Sstevel@tonic-gate Hdr.h_gid = gid;
72667c478bd9Sstevel@tonic-gate Hdr.h_mode = mode;
72677c478bd9Sstevel@tonic-gate Hdr.h_nlink = G_p->g_nlink;
7268*6d3b960aSAndy Fiddaman maj = major(G_p->g_rdev);
7269*6d3b960aSAndy Fiddaman min = minor(G_p->g_rdev);
7270*6d3b960aSAndy Fiddaman if (maj > (uint_t)OMAXMAJ)
7271*6d3b960aSAndy Fiddaman maj = 0;
7272*6d3b960aSAndy Fiddaman if (min > (uint_t)OMAXMIN)
7273*6d3b960aSAndy Fiddaman min = 0;
7274*6d3b960aSAndy Fiddaman Hdr.h_rdev = TO_SVR3(maj, min);
72757c478bd9Sstevel@tonic-gate mkshort(Hdr.h_mtime, (long)G_p->g_mtime);
72767c478bd9Sstevel@tonic-gate Hdr.h_namesize = (short)G_p->g_namesz;
72777c478bd9Sstevel@tonic-gate mkshort(Hdr.h_filesize, (long)len);
72787c478bd9Sstevel@tonic-gate (void) strcpy(Hdr.h_name, G_p->g_nam_p);
72797c478bd9Sstevel@tonic-gate (void) memcpy(Buffr.b_in_p, &Hdr, cnt);
72807c478bd9Sstevel@tonic-gate break;
72817c478bd9Sstevel@tonic-gate case CHR:
72827c478bd9Sstevel@tonic-gate (void) sprintf(Buffr.b_in_p,
7283*6d3b960aSAndy Fiddaman "%.6o%.6o%.6o%.6o"
7284*6d3b960aSAndy Fiddaman "%.6" _PRIoID "%.6" _PRIoID "%.6o"
7285*6d3b960aSAndy Fiddaman "%.6" PRIo16
7286*6d3b960aSAndy Fiddaman "%.11o%.6o%.11" PRIo64
7287*6d3b960aSAndy Fiddaman "%s",
7288*6d3b960aSAndy Fiddaman G_p->g_magic, G_p->g_dev, G_p->g_ino, mode,
7289*6d3b960aSAndy Fiddaman uid, gid, G_p->g_nlink,
7290*6d3b960aSAndy Fiddaman (unsigned short)(G_p->g_rdev & 0xffff),
7291*6d3b960aSAndy Fiddaman G_p->g_mtime, G_p->g_namesz, len,
72927c478bd9Sstevel@tonic-gate G_p->g_nam_p);
72937c478bd9Sstevel@tonic-gate break;
72947c478bd9Sstevel@tonic-gate case ASC:
72957c478bd9Sstevel@tonic-gate case CRC:
72967c478bd9Sstevel@tonic-gate (void) sprintf(Buffr.b_in_p,
7297*6d3b960aSAndy Fiddaman "%.6x%.8x%.8x"
7298*6d3b960aSAndy Fiddaman "%.8" _PRIxID "%.8" _PRIxID
7299*6d3b960aSAndy Fiddaman "%.8x%.8x%.8x"
7300*6d3b960aSAndy Fiddaman "%.8" PRIx32 "%.8" PRIx32 "%.8" PRIx32 "%.8" PRIx32
7301*6d3b960aSAndy Fiddaman "%.8x%.8x%s",
7302*6d3b960aSAndy Fiddaman G_p->g_magic, G_p->g_ino, mode,
7303*6d3b960aSAndy Fiddaman G_p->g_uid, G_p->g_gid,
7304*6d3b960aSAndy Fiddaman G_p->g_nlink, G_p->g_mtime, (uint_t)len,
73057c478bd9Sstevel@tonic-gate major(G_p->g_dev), minor(G_p->g_dev),
73067c478bd9Sstevel@tonic-gate major(G_p->g_rdev), minor(G_p->g_rdev),
73077c478bd9Sstevel@tonic-gate G_p->g_namesz, G_p->g_cksum, G_p->g_nam_p);
73087c478bd9Sstevel@tonic-gate break;
73097c478bd9Sstevel@tonic-gate case USTAR:
73107c478bd9Sstevel@tonic-gate Thdr_p = (union tblock *)Buffr.b_in_p;
73115fbb8099SNobutomo Nakano (void) memset(Thdr_p, 0, TARSZ);
73127c478bd9Sstevel@tonic-gate (void) strncpy(Thdr_p->tbuf.t_name, G_p->g_tname,
7313*6d3b960aSAndy Fiddaman strlen(G_p->g_tname));
7314*6d3b960aSAndy Fiddaman (void) sprintf(Thdr_p->tbuf.t_mode, "%07o", mode);
7315*6d3b960aSAndy Fiddaman (void) sprintf(Thdr_p->tbuf.t_uid, "%07" _PRIoID, uid);
7316*6d3b960aSAndy Fiddaman (void) sprintf(Thdr_p->tbuf.t_gid, "%07" _PRIoID, gid);
7317*6d3b960aSAndy Fiddaman (void) sprintf(Thdr_p->tbuf.t_size, "%011" PRIo64, len);
7318*6d3b960aSAndy Fiddaman (void) sprintf(Thdr_p->tbuf.t_mtime, "%011o", G_p->g_mtime);
73195fbb8099SNobutomo Nakano if (arcflag == ARCHIVE_ACL) {
73207c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_typeflag = 'A'; /* ACL file type */
73215fbb8099SNobutomo Nakano } else if (arcflag == ARCHIVE_XATTR ||
7322ced83f9bSceastha (G_p->g_attrnam_p != NULL)) {
73237c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_typeflag = _XATTR_HDRTYPE;
73247c478bd9Sstevel@tonic-gate } else {
73257c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_typeflag = G_p->g_typeflag;
73267c478bd9Sstevel@tonic-gate }
73277c478bd9Sstevel@tonic-gate if (T_lname[0] != '\0') {
73287c478bd9Sstevel@tonic-gate /*
73297c478bd9Sstevel@tonic-gate * if not a symbolic link
73307c478bd9Sstevel@tonic-gate */
73317c478bd9Sstevel@tonic-gate if (((G_p->g_mode & Ftype) != S_IFLNK) &&
7332ced83f9bSceastha (G_p->g_attrnam_p == NULL)) {
73337c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_typeflag = LNKTYPE;
73347c478bd9Sstevel@tonic-gate (void) sprintf(Thdr_p->tbuf.t_size,
73357c478bd9Sstevel@tonic-gate "%011lo", 0L);
73367c478bd9Sstevel@tonic-gate }
73377c478bd9Sstevel@tonic-gate (void) strncpy(Thdr_p->tbuf.t_linkname, T_lname,
73387c478bd9Sstevel@tonic-gate strlen(T_lname));
73397c478bd9Sstevel@tonic-gate }
73405fbb8099SNobutomo Nakano (void) strcpy(Thdr_p->tbuf.t_magic, TMAGIC);
7341*6d3b960aSAndy Fiddaman (void) memcpy(Thdr_p->tbuf.t_version, TVERSION, 2);
73425fbb8099SNobutomo Nakano (void) strcpy(Thdr_p->tbuf.t_uname, G_p->g_uname);
73435fbb8099SNobutomo Nakano (void) strcpy(Thdr_p->tbuf.t_gname, G_p->g_gname);
7344*6d3b960aSAndy Fiddaman (void) sprintf(Thdr_p->tbuf.t_devmajor, "%07" PRIo32,
7345*6d3b960aSAndy Fiddaman major(G_p->g_rdev));
7346*6d3b960aSAndy Fiddaman (void) sprintf(Thdr_p->tbuf.t_devminor, "%07" PRIo32,
7347*6d3b960aSAndy Fiddaman minor(G_p->g_rdev));
73487c478bd9Sstevel@tonic-gate if (Gen.g_prefix) {
73495fbb8099SNobutomo Nakano (void) strcpy(Thdr_p->tbuf.t_prefix, Gen.g_prefix);
73507c478bd9Sstevel@tonic-gate free(Gen.g_prefix);
73517c478bd9Sstevel@tonic-gate Gen.g_prefix = NULL;
73527c478bd9Sstevel@tonic-gate } else {
73535fbb8099SNobutomo Nakano Thdr_p->tbuf.t_prefix[0] = '\0';
73547c478bd9Sstevel@tonic-gate }
73557c478bd9Sstevel@tonic-gate (void) sprintf(Thdr_p->tbuf.t_cksum, "%07o",
7356*6d3b960aSAndy Fiddaman cksum(TARTYP, 0, NULL));
73577c478bd9Sstevel@tonic-gate break;
73587c478bd9Sstevel@tonic-gate case TAR:
73597c478bd9Sstevel@tonic-gate Thdr_p = (union tblock *)Buffr.b_in_p;
73605fbb8099SNobutomo Nakano (void) memset(Thdr_p, 0, TARSZ);
73617c478bd9Sstevel@tonic-gate (void) strncpy(Thdr_p->tbuf.t_name, G_p->g_nam_p,
73627c478bd9Sstevel@tonic-gate G_p->g_namesz);
7363*6d3b960aSAndy Fiddaman (void) sprintf(Thdr_p->tbuf.t_mode, "%07o ", mode);
7364*6d3b960aSAndy Fiddaman (void) sprintf(Thdr_p->tbuf.t_uid, "%07" _PRIoID " ", uid);
7365*6d3b960aSAndy Fiddaman (void) sprintf(Thdr_p->tbuf.t_gid, "%07" _PRIoID " ", gid);
7366*6d3b960aSAndy Fiddaman (void) sprintf(Thdr_p->tbuf.t_size, "%011" PRIo64 " ", len);
7367*6d3b960aSAndy Fiddaman (void) sprintf(Thdr_p->tbuf.t_mtime, "%011o ", G_p->g_mtime);
73687c478bd9Sstevel@tonic-gate if (T_lname[0] != '\0') {
73697c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_typeflag = '1';
73707c478bd9Sstevel@tonic-gate } else {
73717c478bd9Sstevel@tonic-gate Thdr_p->tbuf.t_typeflag = '\0';
73727c478bd9Sstevel@tonic-gate }
73737c478bd9Sstevel@tonic-gate (void) strncpy(Thdr_p->tbuf.t_linkname, T_lname,
73747c478bd9Sstevel@tonic-gate strlen(T_lname));
73757c478bd9Sstevel@tonic-gate break;
73767c478bd9Sstevel@tonic-gate default:
73777c478bd9Sstevel@tonic-gate msg(EXT, "Impossible header type.");
73787c478bd9Sstevel@tonic-gate } /* Hdr_type */
73797c478bd9Sstevel@tonic-gate
73807c478bd9Sstevel@tonic-gate Buffr.b_in_p += cnt;
73817c478bd9Sstevel@tonic-gate Buffr.b_cnt += cnt;
73827c478bd9Sstevel@tonic-gate pad = ((cnt + Pad_val) & ~Pad_val) - cnt;
73837c478bd9Sstevel@tonic-gate if (pad != 0) {
73847c478bd9Sstevel@tonic-gate FLUSH(pad);
73855fbb8099SNobutomo Nakano (void) memset(Buffr.b_in_p, 0, pad);
73867c478bd9Sstevel@tonic-gate Buffr.b_in_p += pad;
73877c478bd9Sstevel@tonic-gate Buffr.b_cnt += pad;
73887c478bd9Sstevel@tonic-gate }
73897c478bd9Sstevel@tonic-gate }
73907c478bd9Sstevel@tonic-gate
73917c478bd9Sstevel@tonic-gate /*
73927c478bd9Sstevel@tonic-gate * write_trail: Create the appropriate trailer for the selected header type
73937c478bd9Sstevel@tonic-gate * and bwrite the trailer. Pad the buffer with nulls out to the next Bufsize
73947c478bd9Sstevel@tonic-gate * boundary, and force a write. If the write completes, or if the trailer is
73957c478bd9Sstevel@tonic-gate * completely written (but not all of the padding nulls (as can happen on end
73967c478bd9Sstevel@tonic-gate * of medium)) return. Otherwise, the trailer was not completely written out,
73977c478bd9Sstevel@tonic-gate * so re-pad the buffer with nulls and try again.
73987c478bd9Sstevel@tonic-gate */
73997c478bd9Sstevel@tonic-gate
74007c478bd9Sstevel@tonic-gate static void
write_trail(void)74017c478bd9Sstevel@tonic-gate write_trail(void)
74027c478bd9Sstevel@tonic-gate {
74037c478bd9Sstevel@tonic-gate int cnt, need;
74047c478bd9Sstevel@tonic-gate
74057c478bd9Sstevel@tonic-gate switch (Hdr_type) {
74067c478bd9Sstevel@tonic-gate case BIN:
74077c478bd9Sstevel@tonic-gate Gen.g_magic = CMN_BIN;
74087c478bd9Sstevel@tonic-gate break;
74097c478bd9Sstevel@tonic-gate case CHR:
74107c478bd9Sstevel@tonic-gate Gen.g_magic = CMN_BIN;
74117c478bd9Sstevel@tonic-gate break;
74127c478bd9Sstevel@tonic-gate case ASC:
74137c478bd9Sstevel@tonic-gate Gen.g_magic = CMN_ASC;
74147c478bd9Sstevel@tonic-gate break;
74157c478bd9Sstevel@tonic-gate case CRC:
74167c478bd9Sstevel@tonic-gate Gen.g_magic = CMN_CRC;
74177c478bd9Sstevel@tonic-gate break;
74187c478bd9Sstevel@tonic-gate }
74197c478bd9Sstevel@tonic-gate
74207c478bd9Sstevel@tonic-gate switch (Hdr_type) {
74217c478bd9Sstevel@tonic-gate case BIN:
74227c478bd9Sstevel@tonic-gate case CHR:
74237c478bd9Sstevel@tonic-gate case ASC:
74247c478bd9Sstevel@tonic-gate case CRC:
74257c478bd9Sstevel@tonic-gate Gen.g_mode = Gen.g_uid = Gen.g_gid = 0;
74267c478bd9Sstevel@tonic-gate Gen.g_nlink = 1;
74277c478bd9Sstevel@tonic-gate Gen.g_mtime = Gen.g_ino = Gen.g_dev = 0;
74287c478bd9Sstevel@tonic-gate Gen.g_rdev = Gen.g_cksum = 0;
74297c478bd9Sstevel@tonic-gate Gen.g_filesz = (off_t)0;
74307c478bd9Sstevel@tonic-gate Gen.g_namesz = strlen("TRAILER!!!") + 1;
74317c478bd9Sstevel@tonic-gate (void) strcpy(Gen.g_nam_p, "TRAILER!!!");
74327c478bd9Sstevel@tonic-gate G_p = &Gen;
74337c478bd9Sstevel@tonic-gate write_hdr(ARCHIVE_NORMAL, (off_t)0);
74347c478bd9Sstevel@tonic-gate break;
74357c478bd9Sstevel@tonic-gate case TAR:
74367c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/
74377c478bd9Sstevel@tonic-gate case USTAR: /* TAR and USTAR */
74387c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < 3; cnt++) {
74397c478bd9Sstevel@tonic-gate FLUSH(TARSZ);
74405fbb8099SNobutomo Nakano (void) memset(Buffr.b_in_p, 0, TARSZ);
74417c478bd9Sstevel@tonic-gate Buffr.b_in_p += TARSZ;
74427c478bd9Sstevel@tonic-gate Buffr.b_cnt += TARSZ;
74437c478bd9Sstevel@tonic-gate }
74447c478bd9Sstevel@tonic-gate break;
74457c478bd9Sstevel@tonic-gate default:
74467c478bd9Sstevel@tonic-gate msg(EXT, "Impossible header type.");
74477c478bd9Sstevel@tonic-gate }
74487c478bd9Sstevel@tonic-gate need = Bufsize - (Buffr.b_cnt % Bufsize);
74497c478bd9Sstevel@tonic-gate if (need == Bufsize)
74507c478bd9Sstevel@tonic-gate need = 0;
74517c478bd9Sstevel@tonic-gate
74527c478bd9Sstevel@tonic-gate while (Buffr.b_cnt > 0) {
74537c478bd9Sstevel@tonic-gate while (need > 0) {
74547c478bd9Sstevel@tonic-gate cnt = (need < TARSZ) ? need : TARSZ;
74557c478bd9Sstevel@tonic-gate need -= cnt;
74567c478bd9Sstevel@tonic-gate FLUSH(cnt);
74575fbb8099SNobutomo Nakano (void) memset(Buffr.b_in_p, 0, cnt);
74587c478bd9Sstevel@tonic-gate Buffr.b_in_p += cnt;
74597c478bd9Sstevel@tonic-gate Buffr.b_cnt += cnt;
74607c478bd9Sstevel@tonic-gate }
74617c478bd9Sstevel@tonic-gate bflush();
74627c478bd9Sstevel@tonic-gate }
74637c478bd9Sstevel@tonic-gate }
74647c478bd9Sstevel@tonic-gate
74657c478bd9Sstevel@tonic-gate /*
74667c478bd9Sstevel@tonic-gate * if archives in USTAR format, check if typeflag == '5' for directories
74677c478bd9Sstevel@tonic-gate */
74687c478bd9Sstevel@tonic-gate static int
ustar_dir(void)74697c478bd9Sstevel@tonic-gate ustar_dir(void)
74707c478bd9Sstevel@tonic-gate {
74717c478bd9Sstevel@tonic-gate if (Hdr_type == USTAR || Hdr_type == TAR) {
74727c478bd9Sstevel@tonic-gate if (Thdr_p->tbuf.t_typeflag == '5')
74737c478bd9Sstevel@tonic-gate return (1);
74747c478bd9Sstevel@tonic-gate }
74757c478bd9Sstevel@tonic-gate return (0);
74767c478bd9Sstevel@tonic-gate }
74777c478bd9Sstevel@tonic-gate
74787c478bd9Sstevel@tonic-gate /*
74797c478bd9Sstevel@tonic-gate * if archives in USTAR format, check if typeflag == '3' || '4' || '6'
74807c478bd9Sstevel@tonic-gate * for character, block, fifo special files
74817c478bd9Sstevel@tonic-gate */
74827c478bd9Sstevel@tonic-gate static int
ustar_spec(void)74837c478bd9Sstevel@tonic-gate ustar_spec(void)
74847c478bd9Sstevel@tonic-gate {
74857c478bd9Sstevel@tonic-gate int typeflag;
74867c478bd9Sstevel@tonic-gate
74877c478bd9Sstevel@tonic-gate if (Hdr_type == USTAR || Hdr_type == TAR) {
74887c478bd9Sstevel@tonic-gate typeflag = Thdr_p->tbuf.t_typeflag;
74897c478bd9Sstevel@tonic-gate if (typeflag == '3' || typeflag == '4' || typeflag == '6')
74907c478bd9Sstevel@tonic-gate return (1);
74917c478bd9Sstevel@tonic-gate }
74927c478bd9Sstevel@tonic-gate return (0);
74937c478bd9Sstevel@tonic-gate }
74947c478bd9Sstevel@tonic-gate
74957c478bd9Sstevel@tonic-gate /*
74967c478bd9Sstevel@tonic-gate * The return value is a pointer to a converted copy of the information in
74977c478bd9Sstevel@tonic-gate * FromStat if the file is representable in -Hodc format, and NULL otherwise.
74987c478bd9Sstevel@tonic-gate */
74997c478bd9Sstevel@tonic-gate
75007c478bd9Sstevel@tonic-gate static struct stat *
convert_to_old_stat(struct stat * FromStat,char * namep,char * attrp)75017c478bd9Sstevel@tonic-gate convert_to_old_stat(struct stat *FromStat, char *namep, char *attrp)
75027c478bd9Sstevel@tonic-gate {
75037c478bd9Sstevel@tonic-gate static struct stat ToSt;
75047c478bd9Sstevel@tonic-gate cpioinfo_t TmpSt;
75057c478bd9Sstevel@tonic-gate
75067c478bd9Sstevel@tonic-gate (void) memset(&TmpSt, 0, sizeof (cpioinfo_t));
75077c478bd9Sstevel@tonic-gate stat_to_svr32_stat(&TmpSt, FromStat);
75087c478bd9Sstevel@tonic-gate (void) memset(&ToSt, 0, sizeof (ToSt));
75097c478bd9Sstevel@tonic-gate
75107c478bd9Sstevel@tonic-gate if (TmpSt.st_rdev == (o_dev_t)NODEV &&
75117c478bd9Sstevel@tonic-gate (((TmpSt.st_mode & Ftype) == S_IFCHR) ||
75127c478bd9Sstevel@tonic-gate ((TmpSt.st_mode & Ftype) == S_IFBLK))) {
75137c478bd9Sstevel@tonic-gate /*
75147c478bd9Sstevel@tonic-gate * Encountered a problem representing the rdev information.
75157c478bd9Sstevel@tonic-gate * Don't archive it.
75167c478bd9Sstevel@tonic-gate */
75177c478bd9Sstevel@tonic-gate
75187c478bd9Sstevel@tonic-gate msg(ERR, "Error -Hodc format can't support expanded"
75197c478bd9Sstevel@tonic-gate "types on %s%s%s",
75207c478bd9Sstevel@tonic-gate namep,
75217c478bd9Sstevel@tonic-gate (attrp == NULL) ? "" : gettext(" Attribute"),
75227c478bd9Sstevel@tonic-gate (attrp == NULL) ? "" : attrp);
75237c478bd9Sstevel@tonic-gate return (NULL);
75247c478bd9Sstevel@tonic-gate }
75257c478bd9Sstevel@tonic-gate
75267c478bd9Sstevel@tonic-gate if (TmpSt.st_dev == (o_dev_t)NODEV) {
75277c478bd9Sstevel@tonic-gate /*
75287c478bd9Sstevel@tonic-gate * Having trouble representing the device/inode pair. We can't
75297c478bd9Sstevel@tonic-gate * track links in this case; break them all into separate
75307c478bd9Sstevel@tonic-gate * files.
75317c478bd9Sstevel@tonic-gate */
75327c478bd9Sstevel@tonic-gate
75337c478bd9Sstevel@tonic-gate TmpSt.st_ino = 0;
75347c478bd9Sstevel@tonic-gate
75357c478bd9Sstevel@tonic-gate if (((TmpSt.st_mode & Ftype) != S_IFDIR) &&
75367c478bd9Sstevel@tonic-gate TmpSt.st_nlink > 1)
75377c478bd9Sstevel@tonic-gate msg(POST,
75387c478bd9Sstevel@tonic-gate "Warning: file %s%s%s has large "
75397c478bd9Sstevel@tonic-gate "device number - linked "
75407c478bd9Sstevel@tonic-gate "files will be restored as "
75417c478bd9Sstevel@tonic-gate "separate files",
75427c478bd9Sstevel@tonic-gate namep,
75437c478bd9Sstevel@tonic-gate (attrp == NULL) ? "" : gettext(" Attribute"),
75447c478bd9Sstevel@tonic-gate (attrp == NULL) ? "" : attrp);
75457c478bd9Sstevel@tonic-gate
75467c478bd9Sstevel@tonic-gate /* ensure no links */
75477c478bd9Sstevel@tonic-gate
75487c478bd9Sstevel@tonic-gate TmpSt.st_nlink = 1;
75497c478bd9Sstevel@tonic-gate }
75507c478bd9Sstevel@tonic-gate
75517c478bd9Sstevel@tonic-gate /* Start converting values */
75527c478bd9Sstevel@tonic-gate
75537c478bd9Sstevel@tonic-gate if (TmpSt.st_dev < 0) {
75547c478bd9Sstevel@tonic-gate ToSt.st_dev = 0;
75557c478bd9Sstevel@tonic-gate } else {
75567c478bd9Sstevel@tonic-gate ToSt.st_dev = (dev_t)TmpSt.st_dev;
75577c478bd9Sstevel@tonic-gate }
75587c478bd9Sstevel@tonic-gate
75597c478bd9Sstevel@tonic-gate /* -actual- not truncated uid */
75607c478bd9Sstevel@tonic-gate
75617c478bd9Sstevel@tonic-gate ToSt.st_uid = TmpSt.st_uid;
75627c478bd9Sstevel@tonic-gate
75637c478bd9Sstevel@tonic-gate /* -actual- not truncated gid */
75647c478bd9Sstevel@tonic-gate
75657c478bd9Sstevel@tonic-gate ToSt.st_gid = TmpSt.st_gid;
75667c478bd9Sstevel@tonic-gate ToSt.st_ino = (ino_t)TmpSt.st_ino;
75677c478bd9Sstevel@tonic-gate ToSt.st_mode = (mode_t)TmpSt.st_mode;
7568*6d3b960aSAndy Fiddaman ToSt.st_mtime = (uint_t)TmpSt.st_modtime;
75697c478bd9Sstevel@tonic-gate ToSt.st_nlink = (nlink_t)TmpSt.st_nlink;
75707c478bd9Sstevel@tonic-gate ToSt.st_size = (off_t)TmpSt.st_size;
75717c478bd9Sstevel@tonic-gate ToSt.st_rdev = (dev_t)TmpSt.st_rdev;
75727c478bd9Sstevel@tonic-gate
75737c478bd9Sstevel@tonic-gate return (&ToSt);
75747c478bd9Sstevel@tonic-gate }
75757c478bd9Sstevel@tonic-gate
75767c478bd9Sstevel@tonic-gate /*
75777c478bd9Sstevel@tonic-gate * In the beginning of each bar archive, there is a header which describes the
75787c478bd9Sstevel@tonic-gate * current volume being created, followed by a header which describes the
75797c478bd9Sstevel@tonic-gate * current file being created, followed by the file itself. If there is
75807c478bd9Sstevel@tonic-gate * more than one file to be created, a separate header will be created for
75817c478bd9Sstevel@tonic-gate * each additional file. This structure may be repeated if the bar archive
75827c478bd9Sstevel@tonic-gate * contains multiple volumes. If a file spans across volumes, its header
75837c478bd9Sstevel@tonic-gate * will not be repeated in the next volume.
75847c478bd9Sstevel@tonic-gate * +------------------+
75857c478bd9Sstevel@tonic-gate * | vol header |
75867c478bd9Sstevel@tonic-gate * |------------------|
75877c478bd9Sstevel@tonic-gate * | file header i | i = 0
75887c478bd9Sstevel@tonic-gate * |------------------|
75897c478bd9Sstevel@tonic-gate * | <file i> |
75907c478bd9Sstevel@tonic-gate * |------------------|
75917c478bd9Sstevel@tonic-gate * | file header i+1 |
75927c478bd9Sstevel@tonic-gate * |------------------|
75937c478bd9Sstevel@tonic-gate * | <file i+1> |
75947c478bd9Sstevel@tonic-gate * |------------------|
75957c478bd9Sstevel@tonic-gate * | . |
75967c478bd9Sstevel@tonic-gate * | . |
75977c478bd9Sstevel@tonic-gate * | . |
75987c478bd9Sstevel@tonic-gate * +------------------+
75997c478bd9Sstevel@tonic-gate */
76007c478bd9Sstevel@tonic-gate
76017c478bd9Sstevel@tonic-gate /*
76027c478bd9Sstevel@tonic-gate * read in the header that describes the current volume of the bar archive
76037c478bd9Sstevel@tonic-gate * to be extracted.
76047c478bd9Sstevel@tonic-gate */
76057c478bd9Sstevel@tonic-gate static void
read_bar_vol_hdr(void)76067c478bd9Sstevel@tonic-gate read_bar_vol_hdr(void)
76077c478bd9Sstevel@tonic-gate {
76087c478bd9Sstevel@tonic-gate union b_block *tmp_hdr;
76097c478bd9Sstevel@tonic-gate
76107c478bd9Sstevel@tonic-gate tmp_hdr = (union b_block *)Buffr.b_out_p;
76117c478bd9Sstevel@tonic-gate if (tmp_hdr->dbuf.bar_magic[0] == BAR_VOLUME_MAGIC) {
76127c478bd9Sstevel@tonic-gate
76137c478bd9Sstevel@tonic-gate if (bar_Vhdr == NULL) {
76147c478bd9Sstevel@tonic-gate bar_Vhdr = e_zalloc(E_EXIT, TBLOCK);
76157c478bd9Sstevel@tonic-gate }
76167c478bd9Sstevel@tonic-gate (void) memcpy(&(bar_Vhdr->dbuf), &(tmp_hdr->dbuf), TBLOCK);
76177c478bd9Sstevel@tonic-gate } else {
76187c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
76197c478bd9Sstevel@tonic-gate "bar error: cannot read volume header\n"));
76207c478bd9Sstevel@tonic-gate exit(1);
76217c478bd9Sstevel@tonic-gate }
76227c478bd9Sstevel@tonic-gate
7623*6d3b960aSAndy Fiddaman (void) sscanf(bar_Vhdr->dbuf.mode, "%8l", &Gen_bar_vol.g_mode);
7624*6d3b960aSAndy Fiddaman (void) sscanf(bar_Vhdr->dbuf.uid, "%8" _SCNdID, &Gen_bar_vol.g_uid);
7625*6d3b960aSAndy Fiddaman (void) sscanf(bar_Vhdr->dbuf.gid, "%8" _SCNdID, &Gen_bar_vol.g_gid);
7626*6d3b960aSAndy Fiddaman (void) sscanf(bar_Vhdr->dbuf.size, "%12" SCNo64,
76277c478bd9Sstevel@tonic-gate (u_off_t *)&Gen_bar_vol.g_filesz);
7628*6d3b960aSAndy Fiddaman (void) sscanf(bar_Vhdr->dbuf.mtime, "%12o", &Gen_bar_vol.g_mtime);
7629*6d3b960aSAndy Fiddaman (void) sscanf(bar_Vhdr->dbuf.chksum, "%8o", &Gen_bar_vol.g_cksum);
76307c478bd9Sstevel@tonic-gate
76317c478bd9Sstevel@tonic-gate /* set the compress flag */
76327c478bd9Sstevel@tonic-gate if (bar_Vhdr->dbuf.compressed == '1')
76337c478bd9Sstevel@tonic-gate Compressed = 1;
76347c478bd9Sstevel@tonic-gate else
76357c478bd9Sstevel@tonic-gate Compressed = 0;
76367c478bd9Sstevel@tonic-gate
76377c478bd9Sstevel@tonic-gate Buffr.b_out_p += 512;
76387c478bd9Sstevel@tonic-gate Buffr.b_cnt -= 512;
76397c478bd9Sstevel@tonic-gate
76407c478bd9Sstevel@tonic-gate /*
76417c478bd9Sstevel@tonic-gate * not the first volume; exit
76427c478bd9Sstevel@tonic-gate */
76437c478bd9Sstevel@tonic-gate if (strcmp(bar_Vhdr->dbuf.volume_num, "1") != 0) {
76447c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
76457c478bd9Sstevel@tonic-gate gettext("error: This is not volume 1. "));
76467c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("This is volume %s. "),
76477c478bd9Sstevel@tonic-gate bar_Vhdr->dbuf.volume_num);
76487c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("Please insert volume 1.\n"));
76497c478bd9Sstevel@tonic-gate exit(1);
76507c478bd9Sstevel@tonic-gate }
76517c478bd9Sstevel@tonic-gate
76527c478bd9Sstevel@tonic-gate read_bar_file_hdr();
76537c478bd9Sstevel@tonic-gate }
76547c478bd9Sstevel@tonic-gate
76557c478bd9Sstevel@tonic-gate /*
76567c478bd9Sstevel@tonic-gate * read in the header that describes the current file to be extracted
76577c478bd9Sstevel@tonic-gate */
76587c478bd9Sstevel@tonic-gate static void
read_bar_file_hdr(void)76597c478bd9Sstevel@tonic-gate read_bar_file_hdr(void)
76607c478bd9Sstevel@tonic-gate {
76617c478bd9Sstevel@tonic-gate union b_block *tmp_hdr;
76627c478bd9Sstevel@tonic-gate char *start_of_name, *name_p;
76637c478bd9Sstevel@tonic-gate char *tmp;
7664*6d3b960aSAndy Fiddaman major_t maj;
7665*6d3b960aSAndy Fiddaman minor_t min;
76667c478bd9Sstevel@tonic-gate
76677c478bd9Sstevel@tonic-gate if (*Buffr.b_out_p == '\0') {
76687c478bd9Sstevel@tonic-gate *Gen.g_nam_p = '\0';
76697c478bd9Sstevel@tonic-gate exit(0);
76707c478bd9Sstevel@tonic-gate }
76717c478bd9Sstevel@tonic-gate
76727c478bd9Sstevel@tonic-gate tmp_hdr = (union b_block *)Buffr.b_out_p;
76737c478bd9Sstevel@tonic-gate
76747c478bd9Sstevel@tonic-gate tmp = &tmp_hdr->dbuf.mode[1];
7675*6d3b960aSAndy Fiddaman (void) sscanf(tmp, "%8o", &Gen.g_mode);
7676*6d3b960aSAndy Fiddaman (void) sscanf(tmp_hdr->dbuf.uid, "%8" _SCNoID, &Gen.g_uid);
7677*6d3b960aSAndy Fiddaman (void) sscanf(tmp_hdr->dbuf.gid, "%8" _SCNoID, &Gen.g_gid);
7678*6d3b960aSAndy Fiddaman (void) sscanf(tmp_hdr->dbuf.size, "%12" SCNo64,
76797c478bd9Sstevel@tonic-gate (u_off_t *)&Gen.g_filesz);
7680*6d3b960aSAndy Fiddaman (void) sscanf(tmp_hdr->dbuf.mtime, "%12o", &Gen.g_mtime);
7681*6d3b960aSAndy Fiddaman (void) sscanf(tmp_hdr->dbuf.chksum, "%8o", &Gen.g_cksum);
7682*6d3b960aSAndy Fiddaman (void) sscanf(tmp_hdr->dbuf.rdev, "%8o", &Gen.g_rdev);
76837c478bd9Sstevel@tonic-gate
7684*6d3b960aSAndy Fiddaman maj = SVR3_MAJOR(Gen.g_rdev);
7685*6d3b960aSAndy Fiddaman min = SVR3_MINOR(Gen.g_rdev);
7686*6d3b960aSAndy Fiddaman Gen.g_rdev = makedev(maj, min);
76877c478bd9Sstevel@tonic-gate bar_linkflag = tmp_hdr->dbuf.linkflag;
76887c478bd9Sstevel@tonic-gate start_of_name = &tmp_hdr->dbuf.start_of_name;
76897c478bd9Sstevel@tonic-gate
76907c478bd9Sstevel@tonic-gate
76917c478bd9Sstevel@tonic-gate name_p = Gen.g_nam_p;
7692*6d3b960aSAndy Fiddaman while ((*name_p++ = *start_of_name++) != '\0')
76937c478bd9Sstevel@tonic-gate ;
76947c478bd9Sstevel@tonic-gate *name_p = '\0';
76957c478bd9Sstevel@tonic-gate if (bar_linkflag == LNKTYPE || bar_linkflag == SYMTYPE)
76967c478bd9Sstevel@tonic-gate (void) strcpy(bar_linkname, start_of_name);
76977c478bd9Sstevel@tonic-gate
76987c478bd9Sstevel@tonic-gate Gen.g_namesz = strlen(Gen.g_nam_p) + 1;
76997c478bd9Sstevel@tonic-gate (void) strcpy(nambuf, Gen.g_nam_p);
77007c478bd9Sstevel@tonic-gate }
77017c478bd9Sstevel@tonic-gate
77027c478bd9Sstevel@tonic-gate /*
77037c478bd9Sstevel@tonic-gate * if the bar archive is compressed, set up a pipe and do the de-compression
77047c478bd9Sstevel@tonic-gate * as the compressed file is read in.
77057c478bd9Sstevel@tonic-gate */
77067c478bd9Sstevel@tonic-gate static void
setup_uncompress(FILE ** pipef)77077c478bd9Sstevel@tonic-gate setup_uncompress(FILE **pipef)
77087c478bd9Sstevel@tonic-gate {
77097c478bd9Sstevel@tonic-gate char *cmd_buf;
77107c478bd9Sstevel@tonic-gate size_t cmdlen;
77117c478bd9Sstevel@tonic-gate
77127c478bd9Sstevel@tonic-gate cmd_buf = e_zalloc(E_EXIT, MAXPATHLEN * 2);
77137c478bd9Sstevel@tonic-gate
77147c478bd9Sstevel@tonic-gate if (access(Gen.g_nam_p, W_OK) != 0) {
77157c478bd9Sstevel@tonic-gate cmdlen = snprintf(cmd_buf, MAXPATHLEN * 2,
77167c478bd9Sstevel@tonic-gate "chmod +w '%s'; uncompress -c > '%s'; "
77177c478bd9Sstevel@tonic-gate "chmod 0%o '%s'",
7718*6d3b960aSAndy Fiddaman Gen.g_nam_p, Gen.g_nam_p, G_p->g_mode, Gen.g_nam_p);
77197c478bd9Sstevel@tonic-gate } else {
77207c478bd9Sstevel@tonic-gate cmdlen = snprintf(cmd_buf, MAXPATHLEN * 2,
77217c478bd9Sstevel@tonic-gate "uncompress -c > '%s'", Gen.g_nam_p);
77227c478bd9Sstevel@tonic-gate }
77237c478bd9Sstevel@tonic-gate
77247c478bd9Sstevel@tonic-gate if (cmdlen >= MAXPATHLEN * 2 ||
77257c478bd9Sstevel@tonic-gate (*pipef = popen(cmd_buf, "w")) == NULL) {
77267c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("error\n"));
77277c478bd9Sstevel@tonic-gate exit(1);
77287c478bd9Sstevel@tonic-gate }
77297c478bd9Sstevel@tonic-gate
77307c478bd9Sstevel@tonic-gate if (close(Ofile) != 0)
77317c478bd9Sstevel@tonic-gate msg(EXTN, "close error");
77327c478bd9Sstevel@tonic-gate Ofile = fileno(*pipef);
77337c478bd9Sstevel@tonic-gate
77347c478bd9Sstevel@tonic-gate free(cmd_buf);
77357c478bd9Sstevel@tonic-gate }
77367c478bd9Sstevel@tonic-gate
77377c478bd9Sstevel@tonic-gate /*
77387c478bd9Sstevel@tonic-gate * if the bar archive spans multiple volumes, read in the header that
77397c478bd9Sstevel@tonic-gate * describes the next volume.
77407c478bd9Sstevel@tonic-gate */
77417c478bd9Sstevel@tonic-gate static void
skip_bar_volhdr(void)77427c478bd9Sstevel@tonic-gate skip_bar_volhdr(void)
77437c478bd9Sstevel@tonic-gate {
77447c478bd9Sstevel@tonic-gate char *buff;
77457c478bd9Sstevel@tonic-gate union b_block *tmp_hdr;
77467c478bd9Sstevel@tonic-gate
77477c478bd9Sstevel@tonic-gate buff = e_zalloc(E_EXIT, (uint_t)Bufsize);
77487c478bd9Sstevel@tonic-gate
77497c478bd9Sstevel@tonic-gate if (g_read(Device, Archive, buff, Bufsize) < 0) {
77507c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
77517c478bd9Sstevel@tonic-gate "error in skip_bar_volhdr\n"));
77527c478bd9Sstevel@tonic-gate } else {
77537c478bd9Sstevel@tonic-gate
77547c478bd9Sstevel@tonic-gate tmp_hdr = (union b_block *)buff;
77557c478bd9Sstevel@tonic-gate if (tmp_hdr->dbuf.bar_magic[0] == BAR_VOLUME_MAGIC) {
77567c478bd9Sstevel@tonic-gate
77577c478bd9Sstevel@tonic-gate if (bar_Vhdr == NULL) {
77587c478bd9Sstevel@tonic-gate bar_Vhdr = e_zalloc(E_EXIT, TBLOCK);
77597c478bd9Sstevel@tonic-gate }
77607c478bd9Sstevel@tonic-gate (void) memcpy(&(bar_Vhdr->dbuf),
77617c478bd9Sstevel@tonic-gate &(tmp_hdr->dbuf), TBLOCK);
77627c478bd9Sstevel@tonic-gate } else {
77637c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
77647c478bd9Sstevel@tonic-gate gettext("cpio error: cannot read bar volume "
77657c478bd9Sstevel@tonic-gate "header\n"));
77667c478bd9Sstevel@tonic-gate exit(1);
77677c478bd9Sstevel@tonic-gate }
77687c478bd9Sstevel@tonic-gate
7769*6d3b960aSAndy Fiddaman (void) sscanf(bar_Vhdr->dbuf.mode, "%8o",
77707c478bd9Sstevel@tonic-gate &Gen_bar_vol.g_mode);
7771*6d3b960aSAndy Fiddaman (void) sscanf(bar_Vhdr->dbuf.uid, "%8" _SCNoID,
77727c478bd9Sstevel@tonic-gate &Gen_bar_vol.g_uid);
7773*6d3b960aSAndy Fiddaman (void) sscanf(bar_Vhdr->dbuf.gid, "%8" _SCNoID,
77747c478bd9Sstevel@tonic-gate &Gen_bar_vol.g_gid);
7775*6d3b960aSAndy Fiddaman (void) sscanf(bar_Vhdr->dbuf.size, "%12" SCNo64,
77767c478bd9Sstevel@tonic-gate (u_off_t *)&Gen_bar_vol.g_filesz);
7777*6d3b960aSAndy Fiddaman (void) sscanf(bar_Vhdr->dbuf.mtime, "%12o",
77787c478bd9Sstevel@tonic-gate &Gen_bar_vol.g_mtime);
7779*6d3b960aSAndy Fiddaman (void) sscanf(bar_Vhdr->dbuf.chksum, "%8o",
77807c478bd9Sstevel@tonic-gate &Gen_bar_vol.g_cksum);
77817c478bd9Sstevel@tonic-gate if (bar_Vhdr->dbuf.compressed == '1')
77827c478bd9Sstevel@tonic-gate Compressed = 1;
77837c478bd9Sstevel@tonic-gate else
77847c478bd9Sstevel@tonic-gate Compressed = 0;
77857c478bd9Sstevel@tonic-gate }
77867c478bd9Sstevel@tonic-gate
77877c478bd9Sstevel@tonic-gate /*
77887c478bd9Sstevel@tonic-gate * Now put the rest of the bytes read in into the data buffer.
77897c478bd9Sstevel@tonic-gate */
77907c478bd9Sstevel@tonic-gate (void) memcpy(Buffr.b_in_p, &buff[512], (Bufsize - 512));
77917c478bd9Sstevel@tonic-gate Buffr.b_in_p += (Bufsize - 512);
77927c478bd9Sstevel@tonic-gate Buffr.b_cnt += (long)(Bufsize - 512);
77937c478bd9Sstevel@tonic-gate
77947c478bd9Sstevel@tonic-gate free(buff);
77957c478bd9Sstevel@tonic-gate }
77967c478bd9Sstevel@tonic-gate
77977c478bd9Sstevel@tonic-gate /*
77987c478bd9Sstevel@tonic-gate * check the linkflag which indicates the type of the file to be extracted,
77997c478bd9Sstevel@tonic-gate * invoke the corresponding routine to extract the file.
78007c478bd9Sstevel@tonic-gate */
78017c478bd9Sstevel@tonic-gate static void
bar_file_in(void)78027c478bd9Sstevel@tonic-gate bar_file_in(void)
78037c478bd9Sstevel@tonic-gate {
78047c478bd9Sstevel@tonic-gate /*
78057c478bd9Sstevel@tonic-gate * the file is a directory
78067c478bd9Sstevel@tonic-gate */
78077c478bd9Sstevel@tonic-gate if (Adir) {
78087c478bd9Sstevel@tonic-gate if (ckname(1) != F_SKIP && creat_spec(G_p->g_dirfd) > 0) {
78097c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), G_p->g_nam_p);
78107c478bd9Sstevel@tonic-gate }
78117c478bd9Sstevel@tonic-gate return;
78127c478bd9Sstevel@tonic-gate }
78137c478bd9Sstevel@tonic-gate
78147c478bd9Sstevel@tonic-gate switch (bar_linkflag) {
78157c478bd9Sstevel@tonic-gate case REGTYPE:
78167c478bd9Sstevel@tonic-gate /* regular file */
78177c478bd9Sstevel@tonic-gate if ((ckname(1) == F_SKIP) ||
78187c478bd9Sstevel@tonic-gate (Ofile = openout(G_p->g_dirfd)) < 0) {
78197c478bd9Sstevel@tonic-gate data_in(P_SKIP);
78207c478bd9Sstevel@tonic-gate } else {
78217c478bd9Sstevel@tonic-gate data_in(P_PROC);
78227c478bd9Sstevel@tonic-gate }
78237c478bd9Sstevel@tonic-gate break;
78247c478bd9Sstevel@tonic-gate case LNKTYPE:
78257c478bd9Sstevel@tonic-gate /* hard link */
78267c478bd9Sstevel@tonic-gate if (ckname(1) == F_SKIP) {
78277c478bd9Sstevel@tonic-gate break;
78287c478bd9Sstevel@tonic-gate }
78297c478bd9Sstevel@tonic-gate (void) creat_lnk(G_p->g_dirfd, bar_linkname, G_p->g_nam_p);
78307c478bd9Sstevel@tonic-gate break;
78317c478bd9Sstevel@tonic-gate case SYMTYPE:
78327c478bd9Sstevel@tonic-gate /* symbolic link */
78337c478bd9Sstevel@tonic-gate if ((ckname(1) == F_SKIP) ||
78347c478bd9Sstevel@tonic-gate (Ofile = openout(G_p->g_dirfd)) < 0) {
78357c478bd9Sstevel@tonic-gate data_in(P_SKIP);
78367c478bd9Sstevel@tonic-gate } else {
78377c478bd9Sstevel@tonic-gate data_in(P_PROC);
78387c478bd9Sstevel@tonic-gate }
78397c478bd9Sstevel@tonic-gate break;
78407c478bd9Sstevel@tonic-gate case CHRTYPE:
78417c478bd9Sstevel@tonic-gate /* character device or FIFO */
78427c478bd9Sstevel@tonic-gate if (ckname(1) != F_SKIP && creat_spec(G_p->g_dirfd) > 0) {
78437c478bd9Sstevel@tonic-gate VERBOSE((Args & (OCv | OCV)), G_p->g_nam_p);
78447c478bd9Sstevel@tonic-gate }
78457c478bd9Sstevel@tonic-gate break;
78467c478bd9Sstevel@tonic-gate default:
78477c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("error: unknown file type\n"));
78487c478bd9Sstevel@tonic-gate break;
78497c478bd9Sstevel@tonic-gate }
78507c478bd9Sstevel@tonic-gate }
78517c478bd9Sstevel@tonic-gate
78527c478bd9Sstevel@tonic-gate
78537c478bd9Sstevel@tonic-gate /*
78547c478bd9Sstevel@tonic-gate * This originally came from libgenIO/g_init.c
78557c478bd9Sstevel@tonic-gate * XXX And it is very broken.
78567c478bd9Sstevel@tonic-gate */
78577c478bd9Sstevel@tonic-gate
78587c478bd9Sstevel@tonic-gate /* #include <sys/statvfs.h> */
78597c478bd9Sstevel@tonic-gate #include <ftw.h>
78607c478bd9Sstevel@tonic-gate /* #include <libgenIO.h> */
78617c478bd9Sstevel@tonic-gate #define G_TM_TAPE 1 /* Tapemaster controller */
78627c478bd9Sstevel@tonic-gate #define G_XY_DISK 3 /* xy disks */
78637c478bd9Sstevel@tonic-gate #define G_SD_DISK 7 /* scsi sd disk */
78647c478bd9Sstevel@tonic-gate #define G_XT_TAPE 8 /* xt tapes */
78657c478bd9Sstevel@tonic-gate #define G_SF_FLOPPY 9 /* sf floppy */
78667c478bd9Sstevel@tonic-gate #define G_XD_DISK 10 /* xd disks */
78677c478bd9Sstevel@tonic-gate #define G_ST_TAPE 11 /* scsi tape */
78687c478bd9Sstevel@tonic-gate #define G_NS 12 /* noswap pseudo-dev */
78697c478bd9Sstevel@tonic-gate #define G_RAM 13 /* ram pseudo-dev */
78707c478bd9Sstevel@tonic-gate #define G_FT 14 /* tftp */
78717c478bd9Sstevel@tonic-gate #define G_HD 15 /* 386 network disk */
78727c478bd9Sstevel@tonic-gate #define G_FD 16 /* 386 AT disk */
78737c478bd9Sstevel@tonic-gate #define G_FILE 28 /* file, not a device */
78747c478bd9Sstevel@tonic-gate #define G_NO_DEV 29 /* device does not require special treatment */
78757c478bd9Sstevel@tonic-gate #define G_DEV_MAX 30 /* last valid device type */
78767c478bd9Sstevel@tonic-gate
78777c478bd9Sstevel@tonic-gate /*
78787c478bd9Sstevel@tonic-gate * g_init: Determine the device being accessed, set the buffer size,
78797c478bd9Sstevel@tonic-gate * and perform any device specific initialization. Since at this point
78807c478bd9Sstevel@tonic-gate * Sun has no system call to read the configuration, the major numbers
78817c478bd9Sstevel@tonic-gate * are assumed to be static and types are figured out as such. However,
78827c478bd9Sstevel@tonic-gate * as a rough estimate, the buffer size for all types is set to 512
78837c478bd9Sstevel@tonic-gate * as a default.
78847c478bd9Sstevel@tonic-gate */
78857c478bd9Sstevel@tonic-gate
78867c478bd9Sstevel@tonic-gate static int
g_init(int * devtype,int * fdes)78877c478bd9Sstevel@tonic-gate g_init(int *devtype, int *fdes)
78887c478bd9Sstevel@tonic-gate {
78897c478bd9Sstevel@tonic-gate int bufsize;
78907c478bd9Sstevel@tonic-gate struct stat st_buf;
78917c478bd9Sstevel@tonic-gate struct statvfs stfs_buf;
78927c478bd9Sstevel@tonic-gate
78937c478bd9Sstevel@tonic-gate *devtype = G_NO_DEV;
78947c478bd9Sstevel@tonic-gate bufsize = -1;
78957c478bd9Sstevel@tonic-gate if (fstat(*fdes, &st_buf) == -1)
78967c478bd9Sstevel@tonic-gate return (-1);
78974bc0a2efScasper if (!S_ISCHR(st_buf.st_mode) && !S_ISBLK(st_buf.st_mode)) {
78984bc0a2efScasper if (S_ISFIFO(st_buf.st_mode)) {
78997c478bd9Sstevel@tonic-gate bufsize = 512;
79007c478bd9Sstevel@tonic-gate } else {
79017c478bd9Sstevel@tonic-gate /* find block size for this file system */
79027c478bd9Sstevel@tonic-gate *devtype = G_FILE;
79037c478bd9Sstevel@tonic-gate if (fstatvfs(*fdes, &stfs_buf) < 0) {
79047c478bd9Sstevel@tonic-gate bufsize = -1;
79057c478bd9Sstevel@tonic-gate errno = ENODEV;
79067c478bd9Sstevel@tonic-gate } else
79077c478bd9Sstevel@tonic-gate bufsize = stfs_buf.f_bsize;
79087c478bd9Sstevel@tonic-gate }
79097c478bd9Sstevel@tonic-gate
79107c478bd9Sstevel@tonic-gate return (bufsize);
79117c478bd9Sstevel@tonic-gate
79127c478bd9Sstevel@tonic-gate /*
79137c478bd9Sstevel@tonic-gate * We'll have to add a remote attribute to stat but this
79147c478bd9Sstevel@tonic-gate * should work for now.
79157c478bd9Sstevel@tonic-gate */
79167c478bd9Sstevel@tonic-gate } else if (st_buf.st_dev & 0x8000) /* if remote rdev */
79177c478bd9Sstevel@tonic-gate return (512);
79187c478bd9Sstevel@tonic-gate
79197c478bd9Sstevel@tonic-gate bufsize = 512;
79207c478bd9Sstevel@tonic-gate
79217c478bd9Sstevel@tonic-gate if (Hdr_type == BAR) {
79227c478bd9Sstevel@tonic-gate if (is_tape(*fdes)) {
79237c478bd9Sstevel@tonic-gate bufsize = BAR_TAPE_SIZE;
792461694e45SRich Burridge msg(EPOST, "Archiving to tape blocking factor 126");
79257c478bd9Sstevel@tonic-gate } else if (is_floppy(*fdes)) {
79267c478bd9Sstevel@tonic-gate bufsize = BAR_FLOPPY_SIZE;
792761694e45SRich Burridge msg(EPOST, "Archiving to floppy blocking factor 18");
79287c478bd9Sstevel@tonic-gate }
79297c478bd9Sstevel@tonic-gate }
79307c478bd9Sstevel@tonic-gate
79317c478bd9Sstevel@tonic-gate return (bufsize);
79327c478bd9Sstevel@tonic-gate }
79337c478bd9Sstevel@tonic-gate
79347c478bd9Sstevel@tonic-gate /*
79357c478bd9Sstevel@tonic-gate * This originally came from libgenIO/g_read.c
79367c478bd9Sstevel@tonic-gate */
79377c478bd9Sstevel@tonic-gate
79387c478bd9Sstevel@tonic-gate /*
79397c478bd9Sstevel@tonic-gate * g_read: Read nbytes of data from fdes (of type devtype) and place
79407c478bd9Sstevel@tonic-gate * data in location pointed to by buf. In case of end of medium,
79417c478bd9Sstevel@tonic-gate * translate (where necessary) device specific EOM indications into
79427c478bd9Sstevel@tonic-gate * the generic EOM indication of rv = -1, errno = ENOSPC.
79437c478bd9Sstevel@tonic-gate */
79447c478bd9Sstevel@tonic-gate
79457c478bd9Sstevel@tonic-gate static int
g_read(int devtype,int fdes,char * buf,unsigned nbytes)79467c478bd9Sstevel@tonic-gate g_read(int devtype, int fdes, char *buf, unsigned nbytes)
79477c478bd9Sstevel@tonic-gate {
79487c478bd9Sstevel@tonic-gate int rv;
79497c478bd9Sstevel@tonic-gate
79507c478bd9Sstevel@tonic-gate if (devtype < 0 || devtype >= G_DEV_MAX) {
79517c478bd9Sstevel@tonic-gate errno = ENODEV;
79527c478bd9Sstevel@tonic-gate return (-1);
79537c478bd9Sstevel@tonic-gate }
79547c478bd9Sstevel@tonic-gate
79557c478bd9Sstevel@tonic-gate rv = read(fdes, buf, nbytes);
79567c478bd9Sstevel@tonic-gate
79577c478bd9Sstevel@tonic-gate /* st devices return 0 when no space left */
79587c478bd9Sstevel@tonic-gate if ((rv == 0 && errno == 0 && Hdr_type != BAR) ||
79597c478bd9Sstevel@tonic-gate (rv == -1 && errno == EIO)) {
79607c478bd9Sstevel@tonic-gate errno = 0;
79617c478bd9Sstevel@tonic-gate rv = 0;
79627c478bd9Sstevel@tonic-gate }
79637c478bd9Sstevel@tonic-gate
79647c478bd9Sstevel@tonic-gate return (rv);
79657c478bd9Sstevel@tonic-gate }
79667c478bd9Sstevel@tonic-gate
79677c478bd9Sstevel@tonic-gate /*
79687c478bd9Sstevel@tonic-gate * This originally came from libgenIO/g_write.c
79697c478bd9Sstevel@tonic-gate */
79707c478bd9Sstevel@tonic-gate
79717c478bd9Sstevel@tonic-gate /*
79727c478bd9Sstevel@tonic-gate * g_write: Write nbytes of data to fdes (of type devtype) from
79737c478bd9Sstevel@tonic-gate * the location pointed to by buf. In case of end of medium,
79747c478bd9Sstevel@tonic-gate * translate (where necessary) device specific EOM indications into
79757c478bd9Sstevel@tonic-gate * the generic EOM indication of rv = -1, errno = ENOSPC.
79767c478bd9Sstevel@tonic-gate */
79777c478bd9Sstevel@tonic-gate
79787c478bd9Sstevel@tonic-gate static int
g_write(int devtype,int fdes,char * buf,unsigned nbytes)79797c478bd9Sstevel@tonic-gate g_write(int devtype, int fdes, char *buf, unsigned nbytes)
79807c478bd9Sstevel@tonic-gate {
79817c478bd9Sstevel@tonic-gate int rv;
79827c478bd9Sstevel@tonic-gate
79837c478bd9Sstevel@tonic-gate if (devtype < 0 || devtype >= G_DEV_MAX) {
79847c478bd9Sstevel@tonic-gate errno = ENODEV;
79857c478bd9Sstevel@tonic-gate return (-1);
79867c478bd9Sstevel@tonic-gate }
79877c478bd9Sstevel@tonic-gate
79887c478bd9Sstevel@tonic-gate rv = write(fdes, buf, nbytes);
79897c478bd9Sstevel@tonic-gate
79907c478bd9Sstevel@tonic-gate /* st devices return 0 when no more space left */
79917c478bd9Sstevel@tonic-gate if ((rv == 0 && errno == 0) || (rv == -1 && errno == EIO)) {
79927c478bd9Sstevel@tonic-gate errno = ENOSPC;
79937c478bd9Sstevel@tonic-gate rv = -1;
79947c478bd9Sstevel@tonic-gate }
79957c478bd9Sstevel@tonic-gate
79967c478bd9Sstevel@tonic-gate return (rv);
79977c478bd9Sstevel@tonic-gate }
79987c478bd9Sstevel@tonic-gate
79997c478bd9Sstevel@tonic-gate /*
80007c478bd9Sstevel@tonic-gate * Test for tape
80017c478bd9Sstevel@tonic-gate */
80027c478bd9Sstevel@tonic-gate
80037c478bd9Sstevel@tonic-gate static int
is_tape(int fd)80047c478bd9Sstevel@tonic-gate is_tape(int fd)
80057c478bd9Sstevel@tonic-gate {
80067c478bd9Sstevel@tonic-gate struct mtget stuff;
80077c478bd9Sstevel@tonic-gate
80087c478bd9Sstevel@tonic-gate /*
80097c478bd9Sstevel@tonic-gate * try to do a generic tape ioctl, just to see if
80107c478bd9Sstevel@tonic-gate * the thing is in fact a tape drive(er).
80117c478bd9Sstevel@tonic-gate */
80127c478bd9Sstevel@tonic-gate if (ioctl(fd, MTIOCGET, &stuff) != -1) {
80137c478bd9Sstevel@tonic-gate /* the ioctl succeeded, must have been a tape */
80147c478bd9Sstevel@tonic-gate return (1);
80157c478bd9Sstevel@tonic-gate }
80167c478bd9Sstevel@tonic-gate return (0);
80177c478bd9Sstevel@tonic-gate }
80187c478bd9Sstevel@tonic-gate
80197c478bd9Sstevel@tonic-gate /*
80207c478bd9Sstevel@tonic-gate * Test for floppy
80217c478bd9Sstevel@tonic-gate */
80227c478bd9Sstevel@tonic-gate
80237c478bd9Sstevel@tonic-gate static int
is_floppy(int fd)80247c478bd9Sstevel@tonic-gate is_floppy(int fd)
80257c478bd9Sstevel@tonic-gate {
80267c478bd9Sstevel@tonic-gate struct fd_char stuff;
80277c478bd9Sstevel@tonic-gate
80287c478bd9Sstevel@tonic-gate /*
80297c478bd9Sstevel@tonic-gate * try to get the floppy drive characteristics, just to see if
80307c478bd9Sstevel@tonic-gate * the thing is in fact a floppy drive(er).
80317c478bd9Sstevel@tonic-gate */
80327c478bd9Sstevel@tonic-gate if (ioctl(fd, FDIOGCHAR, &stuff) != -1) {
80337c478bd9Sstevel@tonic-gate /* the ioctl succeeded, must have been a floppy */
80347c478bd9Sstevel@tonic-gate return (1);
80357c478bd9Sstevel@tonic-gate }
80367c478bd9Sstevel@tonic-gate
80377c478bd9Sstevel@tonic-gate return (0);
80387c478bd9Sstevel@tonic-gate }
80397c478bd9Sstevel@tonic-gate
80407c478bd9Sstevel@tonic-gate /*
80417c478bd9Sstevel@tonic-gate * New functions for ACLs and other security attributes
80427c478bd9Sstevel@tonic-gate */
80437c478bd9Sstevel@tonic-gate
80447c478bd9Sstevel@tonic-gate /*
80457c478bd9Sstevel@tonic-gate * The function appends the new security attribute info to the end of
80467c478bd9Sstevel@tonic-gate * existing secinfo.
80477c478bd9Sstevel@tonic-gate */
80487c478bd9Sstevel@tonic-gate static int
append_secattr(char ** secinfo,int * secinfo_len,acl_t * aclp)80494c719f3bSToomas Soome append_secattr(char **secinfo, /* existing security info */
80507c478bd9Sstevel@tonic-gate int *secinfo_len, /* length of existing security info */
8051fa9e4066Sahrens acl_t *aclp) /* new attribute data pointer */
80527c478bd9Sstevel@tonic-gate {
80537c478bd9Sstevel@tonic-gate char *new_secinfo;
80547c478bd9Sstevel@tonic-gate char *attrtext;
80557c478bd9Sstevel@tonic-gate size_t newattrsize;
80567c478bd9Sstevel@tonic-gate int oldsize;
80577c478bd9Sstevel@tonic-gate
80587c478bd9Sstevel@tonic-gate /* no need to add */
8059fa9e4066Sahrens if (aclp == NULL) {
80607c478bd9Sstevel@tonic-gate return (0);
80617c478bd9Sstevel@tonic-gate }
80627c478bd9Sstevel@tonic-gate
8063fa9e4066Sahrens switch (acl_type(aclp)) {
8064fa9e4066Sahrens case ACLENT_T:
8065fa9e4066Sahrens case ACE_T:
8066b249c65cSmarks attrtext = acl_totext(aclp, ACL_APPEND_ID | ACL_COMPACT_FMT |
8067b249c65cSmarks ACL_SID_FMT);
80687c478bd9Sstevel@tonic-gate if (attrtext == NULL) {
806961694e45SRich Burridge msg(EPOST, "acltotext failed");
80707c478bd9Sstevel@tonic-gate return (-1);
80717c478bd9Sstevel@tonic-gate }
80727c478bd9Sstevel@tonic-gate /* header: type + size = 8 */
80737c478bd9Sstevel@tonic-gate newattrsize = 8 + strlen(attrtext) + 1;
80747c478bd9Sstevel@tonic-gate attr = e_zalloc(E_NORMAL, newattrsize);
80757c478bd9Sstevel@tonic-gate if (attr == NULL) {
807661694e45SRich Burridge msg(EPOST, "can't allocate memory");
80777c478bd9Sstevel@tonic-gate return (-1);
80787c478bd9Sstevel@tonic-gate }
8079fa9e4066Sahrens attr->attr_type = (acl_type(aclp) == ACLENT_T) ?
8080fa9e4066Sahrens UFSD_ACL : ACE_ACL;
80817c478bd9Sstevel@tonic-gate /* acl entry count */
8082fa9e4066Sahrens (void) sprintf(attr->attr_len, "%06o", acl_cnt(aclp));
80837c478bd9Sstevel@tonic-gate (void) strcpy((char *)&attr->attr_info[0], attrtext);
80847c478bd9Sstevel@tonic-gate free(attrtext);
80857c478bd9Sstevel@tonic-gate break;
80867c478bd9Sstevel@tonic-gate
80877c478bd9Sstevel@tonic-gate /* SunFed's case goes here */
80887c478bd9Sstevel@tonic-gate
80897c478bd9Sstevel@tonic-gate default:
809061694e45SRich Burridge msg(EPOST, "unrecognized attribute type");
80917c478bd9Sstevel@tonic-gate return (-1);
80927c478bd9Sstevel@tonic-gate }
80937c478bd9Sstevel@tonic-gate
80947c478bd9Sstevel@tonic-gate /* old security info + new attr header(8) + new attr */
80957c478bd9Sstevel@tonic-gate oldsize = *secinfo_len;
80967c478bd9Sstevel@tonic-gate *secinfo_len += newattrsize;
80977c478bd9Sstevel@tonic-gate new_secinfo = e_zalloc(E_NORMAL, (uint_t)*secinfo_len);
80987c478bd9Sstevel@tonic-gate if (new_secinfo == NULL) {
809961694e45SRich Burridge msg(EPOST, "can't allocate memory");
81007c478bd9Sstevel@tonic-gate *secinfo_len -= newattrsize;
81017c478bd9Sstevel@tonic-gate return (-1);
81027c478bd9Sstevel@tonic-gate }
81037c478bd9Sstevel@tonic-gate
81047c478bd9Sstevel@tonic-gate (void) memcpy(new_secinfo, *secinfo, oldsize);
81057c478bd9Sstevel@tonic-gate (void) memcpy(new_secinfo + oldsize, attr, newattrsize);
81067c478bd9Sstevel@tonic-gate
81077c478bd9Sstevel@tonic-gate free(*secinfo);
81087c478bd9Sstevel@tonic-gate *secinfo = new_secinfo;
81097c478bd9Sstevel@tonic-gate return (0);
81107c478bd9Sstevel@tonic-gate }
81117c478bd9Sstevel@tonic-gate
81125fbb8099SNobutomo Nakano /*
81135fbb8099SNobutomo Nakano * Append size amount of data from buf to the archive.
81145fbb8099SNobutomo Nakano */
81157c478bd9Sstevel@tonic-gate static void
write_ancillary(char * buf,size_t len,boolean_t padding)81165fbb8099SNobutomo Nakano write_ancillary(char *buf, size_t len, boolean_t padding)
81177c478bd9Sstevel@tonic-gate {
81185fbb8099SNobutomo Nakano int pad, cnt;
81197c478bd9Sstevel@tonic-gate
81205fbb8099SNobutomo Nakano if (len == 0)
81217c478bd9Sstevel@tonic-gate return;
81227c478bd9Sstevel@tonic-gate
81237c478bd9Sstevel@tonic-gate while (len > 0) {
81247c478bd9Sstevel@tonic-gate cnt = (unsigned)(len > CPIOBSZ) ? CPIOBSZ : len;
81257c478bd9Sstevel@tonic-gate FLUSH(cnt);
81267c478bd9Sstevel@tonic-gate errno = 0;
81275fbb8099SNobutomo Nakano (void) memcpy(Buffr.b_in_p, buf, (unsigned)cnt);
81287c478bd9Sstevel@tonic-gate Buffr.b_in_p += cnt;
81295fbb8099SNobutomo Nakano Buffr.b_cnt += cnt;
81305fbb8099SNobutomo Nakano len -= cnt;
81315fbb8099SNobutomo Nakano buf += cnt;
81327c478bd9Sstevel@tonic-gate }
81335fbb8099SNobutomo Nakano if (padding) {
81347c478bd9Sstevel@tonic-gate pad = (Pad_val + 1 - (cnt & Pad_val)) & Pad_val;
81357c478bd9Sstevel@tonic-gate if (pad != 0) {
81367c478bd9Sstevel@tonic-gate FLUSH(pad);
81375fbb8099SNobutomo Nakano (void) memset(Buffr.b_in_p, 0, pad);
81387c478bd9Sstevel@tonic-gate Buffr.b_in_p += pad;
81397c478bd9Sstevel@tonic-gate Buffr.b_cnt += pad;
81407c478bd9Sstevel@tonic-gate }
81417c478bd9Sstevel@tonic-gate }
81425fbb8099SNobutomo Nakano }
81437c478bd9Sstevel@tonic-gate
81447c478bd9Sstevel@tonic-gate static int
remove_dir(char * path)81457c478bd9Sstevel@tonic-gate remove_dir(char *path)
81467c478bd9Sstevel@tonic-gate {
81477c478bd9Sstevel@tonic-gate DIR *name;
81487c478bd9Sstevel@tonic-gate struct dirent *direct;
81497c478bd9Sstevel@tonic-gate struct stat sbuf;
81507c478bd9Sstevel@tonic-gate char *path_copy;
81517c478bd9Sstevel@tonic-gate
81527c478bd9Sstevel@tonic-gate #define MSG1 "remove_dir() failed to stat(\"%s\") "
81537c478bd9Sstevel@tonic-gate #define MSG2 "remove_dir() failed to remove_dir(\"%s\") "
81547c478bd9Sstevel@tonic-gate #define MSG3 "remove_dir() failed to unlink(\"%s\") "
81557c478bd9Sstevel@tonic-gate
81567c478bd9Sstevel@tonic-gate /*
81577c478bd9Sstevel@tonic-gate * Open the directory for reading.
81587c478bd9Sstevel@tonic-gate */
81597c478bd9Sstevel@tonic-gate if ((name = opendir(path)) == NULL) {
81607c478bd9Sstevel@tonic-gate msg(ERRN, "remove_dir() failed to opendir(\"%s\") ", path);
81617c478bd9Sstevel@tonic-gate return (-1);
81627c478bd9Sstevel@tonic-gate }
81637c478bd9Sstevel@tonic-gate
81647c478bd9Sstevel@tonic-gate if (chdir(path) == -1) {
81657c478bd9Sstevel@tonic-gate msg(ERRN, "remove_dir() failed to chdir(\"%s\") ", path);
81667c478bd9Sstevel@tonic-gate return (-1);
81677c478bd9Sstevel@tonic-gate }
81687c478bd9Sstevel@tonic-gate
81697c478bd9Sstevel@tonic-gate /*
81707c478bd9Sstevel@tonic-gate * Read every directory entry.
81717c478bd9Sstevel@tonic-gate */
81727c478bd9Sstevel@tonic-gate while ((direct = readdir(name)) != NULL) {
81737c478bd9Sstevel@tonic-gate /*
81747c478bd9Sstevel@tonic-gate * Ignore "." and ".." entries.
81757c478bd9Sstevel@tonic-gate */
81767c478bd9Sstevel@tonic-gate if (strcmp(direct->d_name, ".") == 0 ||
81777c478bd9Sstevel@tonic-gate strcmp(direct->d_name, "..") == 0)
81787c478bd9Sstevel@tonic-gate continue;
81797c478bd9Sstevel@tonic-gate
81807c478bd9Sstevel@tonic-gate if (lstat(direct->d_name, &sbuf) == -1) {
81817c478bd9Sstevel@tonic-gate msg(ERRN, MSG1, direct->d_name);
81827c478bd9Sstevel@tonic-gate (void) closedir(name);
81837c478bd9Sstevel@tonic-gate return (-1);
81847c478bd9Sstevel@tonic-gate }
81857c478bd9Sstevel@tonic-gate
81867c478bd9Sstevel@tonic-gate if (S_ISDIR(sbuf.st_mode)) {
81877c478bd9Sstevel@tonic-gate if (remove_dir(direct->d_name) == -1) {
81887c478bd9Sstevel@tonic-gate msg(ERRN, MSG2, direct->d_name);
81897c478bd9Sstevel@tonic-gate (void) closedir(name);
81907c478bd9Sstevel@tonic-gate return (-1);
81917c478bd9Sstevel@tonic-gate }
81927c478bd9Sstevel@tonic-gate } else {
81937c478bd9Sstevel@tonic-gate if (unlink(direct->d_name) == -1) {
81947c478bd9Sstevel@tonic-gate msg(ERRN, MSG3, direct->d_name);
81957c478bd9Sstevel@tonic-gate (void) closedir(name);
81967c478bd9Sstevel@tonic-gate return (-1);
81977c478bd9Sstevel@tonic-gate }
81987c478bd9Sstevel@tonic-gate }
81997c478bd9Sstevel@tonic-gate
82007c478bd9Sstevel@tonic-gate }
82017c478bd9Sstevel@tonic-gate
82027c478bd9Sstevel@tonic-gate /*
82037c478bd9Sstevel@tonic-gate * Close the directory we just finished reading.
82047c478bd9Sstevel@tonic-gate */
82057c478bd9Sstevel@tonic-gate (void) closedir(name);
82067c478bd9Sstevel@tonic-gate
82077c478bd9Sstevel@tonic-gate /*
82087c478bd9Sstevel@tonic-gate * Change directory to the parent directory...
82097c478bd9Sstevel@tonic-gate */
82107c478bd9Sstevel@tonic-gate if (chdir("..") == -1) {
82117c478bd9Sstevel@tonic-gate msg(ERRN, "remove_dir() failed to chdir(\"..\") ");
82127c478bd9Sstevel@tonic-gate return (-1);
82137c478bd9Sstevel@tonic-gate }
82147c478bd9Sstevel@tonic-gate
82157c478bd9Sstevel@tonic-gate /*
82167c478bd9Sstevel@tonic-gate * ...and finally remove the directory; note we have to
82177c478bd9Sstevel@tonic-gate * make a copy since basename is free to modify its input.
82187c478bd9Sstevel@tonic-gate */
82197c478bd9Sstevel@tonic-gate path_copy = e_strdup(E_NORMAL, path);
82207c478bd9Sstevel@tonic-gate if (path_copy == NULL) {
82217c478bd9Sstevel@tonic-gate msg(ERRN, "cannot strdup() the directory pathname ");
82227c478bd9Sstevel@tonic-gate return (-1);
82237c478bd9Sstevel@tonic-gate }
82247c478bd9Sstevel@tonic-gate
82257c478bd9Sstevel@tonic-gate if (rmdir(basename(path_copy)) == -1) {
82267c478bd9Sstevel@tonic-gate free(path_copy);
82277c478bd9Sstevel@tonic-gate msg(ERRN, "remove_dir() failed to rmdir(\"%s\") ", path);
82287c478bd9Sstevel@tonic-gate return (-1);
82297c478bd9Sstevel@tonic-gate }
82307c478bd9Sstevel@tonic-gate
82317c478bd9Sstevel@tonic-gate free(path_copy);
82327c478bd9Sstevel@tonic-gate return (0);
82337c478bd9Sstevel@tonic-gate
82347c478bd9Sstevel@tonic-gate }
82357c478bd9Sstevel@tonic-gate
82367c478bd9Sstevel@tonic-gate static int
save_cwd(void)82377c478bd9Sstevel@tonic-gate save_cwd(void)
82387c478bd9Sstevel@tonic-gate {
82397c478bd9Sstevel@tonic-gate return (open(".", O_RDONLY));
82407c478bd9Sstevel@tonic-gate }
82417c478bd9Sstevel@tonic-gate
82427c478bd9Sstevel@tonic-gate static void
rest_cwd(int cwd)82437c478bd9Sstevel@tonic-gate rest_cwd(int cwd)
82447c478bd9Sstevel@tonic-gate {
82457c478bd9Sstevel@tonic-gate (void) fchdir(cwd);
82467c478bd9Sstevel@tonic-gate (void) close(cwd);
82477c478bd9Sstevel@tonic-gate }
82487c478bd9Sstevel@tonic-gate
82497c478bd9Sstevel@tonic-gate #if defined(O_XATTR)
82507c478bd9Sstevel@tonic-gate static void
xattrs_out(int (* func)())82517c478bd9Sstevel@tonic-gate xattrs_out(int (*func)())
82527c478bd9Sstevel@tonic-gate {
82537c478bd9Sstevel@tonic-gate int dirpfd;
82547c478bd9Sstevel@tonic-gate int filefd;
8255ced83f9bSceastha int arc_rwsysattr = 0;
8256ced83f9bSceastha int rw_sysattr = 0;
8257ced83f9bSceastha int ext_attr = 0;
82587c478bd9Sstevel@tonic-gate DIR *dirp;
82597c478bd9Sstevel@tonic-gate struct dirent *dp;
82607c478bd9Sstevel@tonic-gate int slen;
8261ced83f9bSceastha int plen;
82627c478bd9Sstevel@tonic-gate char *namep, *savenamep;
8263ced83f9bSceastha char *apathp;
8264ced83f9bSceastha char *attrparent = Gen.g_attrparent_p;
8265ced83f9bSceastha char *filename;
82667c478bd9Sstevel@tonic-gate
8267ced83f9bSceastha if (attrparent == NULL) {
8268ced83f9bSceastha filename = Gen.g_nam_p;
8269ced83f9bSceastha } else {
8270ced83f9bSceastha filename = Gen.g_attrnam_p;
8271ced83f9bSceastha }
8272ced83f9bSceastha
8273ced83f9bSceastha /*
8274ced83f9bSceastha * If the underlying file system supports it, then
8275ced83f9bSceastha * archive the extended attributes if -@ was specified,
8276ced83f9bSceastha * and the extended system attributes if -/ was
8277ced83f9bSceastha * specified.
8278ced83f9bSceastha */
8279ced83f9bSceastha if (verify_attr_support(filename, (attrparent == NULL), ARC_CREATE,
8280ced83f9bSceastha &ext_attr) != ATTR_OK) {
82817c478bd9Sstevel@tonic-gate return;
82827c478bd9Sstevel@tonic-gate }
82837c478bd9Sstevel@tonic-gate
8284ced83f9bSceastha #if defined(_PC_SATTR_ENABLED)
8285ced83f9bSceastha if (SysAtflag) {
8286ced83f9bSceastha int filefd;
8287ced83f9bSceastha nvlist_t *slist = NULL;
8288ced83f9bSceastha
8289ced83f9bSceastha /*
8290ced83f9bSceastha * Determine if there are non-transient system
8291ced83f9bSceastha * attributes.
8292ced83f9bSceastha */
8293ced83f9bSceastha errno = 0;
8294ced83f9bSceastha if ((filefd = open(filename, O_RDONLY)) == -1) {
8295ced83f9bSceastha if (attrparent == NULL) {
8296ced83f9bSceastha msg(EXTN,
8297ced83f9bSceastha "unable to open %s%s%sfile %s",
8298ced83f9bSceastha (attrparent == NULL) ? "" :
8299ced83f9bSceastha gettext("attribute "),
8300ced83f9bSceastha (attrparent == NULL) ? "" : attrparent,
8301ced83f9bSceastha (attrparent == NULL) ? "" : gettext(" of "),
8302ced83f9bSceastha (attrparent == NULL) ? G_p->g_nam_p :
8303ced83f9bSceastha G_p->g_attrfnam_p);
8304ced83f9bSceastha }
8305ced83f9bSceastha }
8306ced83f9bSceastha if (((slist = sysattr_list(myname, filefd,
8307ced83f9bSceastha filename)) != NULL) || (errno != 0)) {
8308ced83f9bSceastha arc_rwsysattr = 1;
8309ced83f9bSceastha }
8310ced83f9bSceastha if (slist != NULL) {
8311ced83f9bSceastha (void) nvlist_free(slist);
8312ced83f9bSceastha slist = NULL;
8313ced83f9bSceastha }
8314ced83f9bSceastha (void) close(filefd);
8315ced83f9bSceastha }
8316ced83f9bSceastha
8317ced83f9bSceastha /*
8318ced83f9bSceastha * If we aren't archiving extended system attributes, and we are
8319ced83f9bSceastha * processing an attribute, or if we are archiving extended system
8320ced83f9bSceastha * attributes, and there are are no extended attributes, then there's
8321ced83f9bSceastha * no need to open up the attribute directory of the file unless the
8322ced83f9bSceastha * extended system attributes are not transient (i.e, the system
8323ced83f9bSceastha * attributes are not the default values).
8324ced83f9bSceastha */
8325ced83f9bSceastha if ((arc_rwsysattr == 0) && ((attrparent != NULL) ||
8326ced83f9bSceastha (SysAtflag && !ext_attr))) {
8327ced83f9bSceastha return;
8328ced83f9bSceastha }
8329ced83f9bSceastha
8330ced83f9bSceastha #endif /* _PC_SATTR_ENABLED */
8331ced83f9bSceastha
83327c478bd9Sstevel@tonic-gate /*
83337c478bd9Sstevel@tonic-gate * If aclp still exists then free it since it is was set when base
83347c478bd9Sstevel@tonic-gate * file was extracted.
83357c478bd9Sstevel@tonic-gate */
8336fa9e4066Sahrens if (aclp != NULL) {
8337fa9e4066Sahrens acl_free(aclp);
83387c478bd9Sstevel@tonic-gate aclp = NULL;
8339fa9e4066Sahrens acl_is_set = 0;
83407c478bd9Sstevel@tonic-gate }
83417c478bd9Sstevel@tonic-gate
8342ced83f9bSceastha Gen.g_dirfd = attropen(filename, ".", O_RDONLY);
83437c478bd9Sstevel@tonic-gate if (Gen.g_dirfd == -1) {
8344ced83f9bSceastha msg(ERRN, "Cannot open attribute directory of file \"%s%s%s\"",
8345ced83f9bSceastha (attrparent == NULL) ? "" : gettext("attribute "),
8346ced83f9bSceastha (attrparent == NULL) ? "" : attrparent,
8347ced83f9bSceastha (attrparent == NULL) ? "" : gettext(" of "), filename);
83487c478bd9Sstevel@tonic-gate return;
83497c478bd9Sstevel@tonic-gate
83507c478bd9Sstevel@tonic-gate }
8351ced83f9bSceastha
8352ced83f9bSceastha if (attrparent == NULL) {
83537c478bd9Sstevel@tonic-gate savenamep = G_p->g_nam_p;
8354ced83f9bSceastha } else {
8355ced83f9bSceastha savenamep = G_p->g_attrfnam_p;
8356ced83f9bSceastha }
83577c478bd9Sstevel@tonic-gate
83587c478bd9Sstevel@tonic-gate if ((dirpfd = dup(Gen.g_dirfd)) == -1) {
83597c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot dup(2) attribute directory descriptor");
83607c478bd9Sstevel@tonic-gate return;
83617c478bd9Sstevel@tonic-gate }
83627c478bd9Sstevel@tonic-gate
8363ced83f9bSceastha if ((dirp = fdopendir(dirpfd)) == NULL) {
83647c478bd9Sstevel@tonic-gate msg(ERRN, "Cannot fdopendir(2) directory file descriptor");
83657c478bd9Sstevel@tonic-gate return;
83667c478bd9Sstevel@tonic-gate }
83677c478bd9Sstevel@tonic-gate
8368ced83f9bSceastha if (attrparent == NULL) {
8369ced83f9bSceastha Gen.g_baseparent_fd = save_cwd();
8370ced83f9bSceastha }
8371ced83f9bSceastha
8372ced83f9bSceastha while ((dp = readdir(dirp)) != NULL) {
8373ced83f9bSceastha if (strcmp(dp->d_name, "..") == 0) {
8374ced83f9bSceastha continue;
8375ced83f9bSceastha }
8376ced83f9bSceastha if (verify_attr(dp->d_name, attrparent,
8377ced83f9bSceastha arc_rwsysattr, &rw_sysattr) != ATTR_OK) {
83787c478bd9Sstevel@tonic-gate continue;
83797c478bd9Sstevel@tonic-gate }
83807c478bd9Sstevel@tonic-gate
83817c478bd9Sstevel@tonic-gate if (strcmp(dp->d_name, ".") == 0) {
83827c478bd9Sstevel@tonic-gate Hiddendir = 1;
83837c478bd9Sstevel@tonic-gate } else {
83847c478bd9Sstevel@tonic-gate Hiddendir = 0;
83857c478bd9Sstevel@tonic-gate }
83867c478bd9Sstevel@tonic-gate
8387ced83f9bSceastha Gen.g_rw_sysattr = rw_sysattr;
83887c478bd9Sstevel@tonic-gate Gen.g_attrnam_p = dp->d_name;
83897c478bd9Sstevel@tonic-gate
83907c478bd9Sstevel@tonic-gate if (STAT(Gen.g_dirfd, Gen.g_nam_p, &SrcSt) == -1) {
83917c478bd9Sstevel@tonic-gate msg(ERRN,
83927c478bd9Sstevel@tonic-gate "Could not fstatat(2) attribute \"%s\" of"
8393ced83f9bSceastha " file \"%s\"", dp->d_name, (attrparent == NULL) ?
8394ced83f9bSceastha savenamep : Gen.g_attrfnam_p);
83957c478bd9Sstevel@tonic-gate continue;
83967c478bd9Sstevel@tonic-gate }
83977c478bd9Sstevel@tonic-gate
83987c478bd9Sstevel@tonic-gate if (Use_old_stat) {
8399ced83f9bSceastha Savedev = SrcSt.st_dev;
84007c478bd9Sstevel@tonic-gate OldSt = convert_to_old_stat(&SrcSt,
84017c478bd9Sstevel@tonic-gate Gen.g_nam_p, Gen.g_attrnam_p);
84027c478bd9Sstevel@tonic-gate
84037c478bd9Sstevel@tonic-gate if (OldSt == NULL) {
84047c478bd9Sstevel@tonic-gate msg(ERRN,
84057c478bd9Sstevel@tonic-gate "Could not convert to old stat format");
84067c478bd9Sstevel@tonic-gate continue;
84077c478bd9Sstevel@tonic-gate }
84087c478bd9Sstevel@tonic-gate }
84097c478bd9Sstevel@tonic-gate
84107c478bd9Sstevel@tonic-gate Gen.g_attrfnam_p = savenamep;
84117c478bd9Sstevel@tonic-gate
84127c478bd9Sstevel@tonic-gate /*
84137c478bd9Sstevel@tonic-gate * Set up dummy header name
84147c478bd9Sstevel@tonic-gate *
84157c478bd9Sstevel@tonic-gate * One piece is written with .hdr, which
84167c478bd9Sstevel@tonic-gate * contains the actual xattr hdr or pathing information
84177c478bd9Sstevel@tonic-gate * then the name is updated to drop the .hdr off
84187c478bd9Sstevel@tonic-gate * and the actual file itself is archived.
84197c478bd9Sstevel@tonic-gate */
84207c478bd9Sstevel@tonic-gate slen = strlen(Gen.g_attrnam_p) + strlen(DEVNULL) +
8421ced83f9bSceastha strlen(XATTRHDR) + 2; /* add one for '/' */
8422ced83f9bSceastha if ((namep = e_zalloc(E_NORMAL, slen)) == NULL) {
84237c478bd9Sstevel@tonic-gate msg(ERRN, "Could not calloc memory for attribute name");
84247c478bd9Sstevel@tonic-gate continue;
84257c478bd9Sstevel@tonic-gate }
8426ced83f9bSceastha (void) snprintf(namep, slen, "%s/%s%s",
84277c478bd9Sstevel@tonic-gate DEVNULL, Gen.g_attrnam_p, XATTRHDR);
84287c478bd9Sstevel@tonic-gate Gen.g_nam_p = namep;
84297c478bd9Sstevel@tonic-gate
8430ced83f9bSceastha plen = strlen(Gen.g_attrnam_p) + 1;
8431ced83f9bSceastha if (Gen.g_attrparent_p != NULL) {
8432ced83f9bSceastha plen += strlen(Gen.g_attrparent_p) + 1;
8433ced83f9bSceastha }
8434ced83f9bSceastha if ((apathp = e_zalloc(E_NORMAL, plen)) == NULL) {
8435ced83f9bSceastha msg(ERRN, "Could not calloc memory for attribute name");
8436ced83f9bSceastha continue;
8437ced83f9bSceastha }
8438ced83f9bSceastha (void) snprintf(apathp, plen, "%s%s%s",
8439ced83f9bSceastha (Gen.g_attrparent_p == NULL) ? "" : Gen.g_attrparent_p,
8440ced83f9bSceastha (Gen.g_attrparent_p == NULL) ? "" : "/", Gen.g_attrnam_p);
8441ced83f9bSceastha
8442ced83f9bSceastha if (Gen.g_attrpath_p != NULL) {
8443ced83f9bSceastha free(Gen.g_attrpath_p);
8444ced83f9bSceastha }
8445ced83f9bSceastha Gen.g_attrpath_p = apathp;
8446ced83f9bSceastha
84477c478bd9Sstevel@tonic-gate /*
84487c478bd9Sstevel@tonic-gate * Get attribute's ACL info: don't bother allocating space
84497c478bd9Sstevel@tonic-gate * if there are only standard permissions, i.e. ACL count < 4
84507c478bd9Sstevel@tonic-gate */
84517c478bd9Sstevel@tonic-gate if (Pflag) {
84527c478bd9Sstevel@tonic-gate filefd = openat(Gen.g_dirfd, dp->d_name, O_RDONLY);
84537c478bd9Sstevel@tonic-gate if (filefd == -1) {
84547c478bd9Sstevel@tonic-gate msg(ERRN,
84557c478bd9Sstevel@tonic-gate "Could not open attribute \"%s\" of"
84567c478bd9Sstevel@tonic-gate " file \"%s\"", dp->d_name, savenamep);
84577c478bd9Sstevel@tonic-gate free(namep);
84587c478bd9Sstevel@tonic-gate continue;
84597c478bd9Sstevel@tonic-gate }
8460fa9e4066Sahrens if (facl_get(filefd, ACL_NO_TRIVIAL, &aclp) != 0) {
84617c478bd9Sstevel@tonic-gate msg(ERRN,
84627c478bd9Sstevel@tonic-gate "Error with acl() on %s",
84637c478bd9Sstevel@tonic-gate Gen.g_nam_p);
84647c478bd9Sstevel@tonic-gate }
84657c478bd9Sstevel@tonic-gate (void) close(filefd);
84667c478bd9Sstevel@tonic-gate }
8467ced83f9bSceastha
84687c478bd9Sstevel@tonic-gate (void) creat_hdr();
84697c478bd9Sstevel@tonic-gate (void) (*func)();
8470ced83f9bSceastha
8471ced83f9bSceastha #if defined(_PC_SATTR_ENABLED)
8472ced83f9bSceastha /*
8473ced83f9bSceastha * Recursively call xattrs_out() to process the attribute's
8474ced83f9bSceastha * hidden attribute directory and read-write system attributes.
8475ced83f9bSceastha */
8476ced83f9bSceastha if (SysAtflag && !Hiddendir && !rw_sysattr) {
8477ced83f9bSceastha int savedirfd = Gen.g_dirfd;
8478ced83f9bSceastha
8479ced83f9bSceastha (void) fchdir(Gen.g_dirfd);
8480ced83f9bSceastha Gen.g_attrparent_p = dp->d_name;
8481ced83f9bSceastha xattrs_out(func);
8482ced83f9bSceastha Gen.g_dirfd = savedirfd;
8483ced83f9bSceastha Gen.g_attrparent_p = NULL;
8484ced83f9bSceastha }
8485ced83f9bSceastha #endif /* _PC_SATTR_ENABLED */
8486ced83f9bSceastha
84877c478bd9Sstevel@tonic-gate if (Gen.g_passdirfd != -1) {
84887c478bd9Sstevel@tonic-gate (void) close(Gen.g_passdirfd);
84897c478bd9Sstevel@tonic-gate Gen.g_passdirfd = -1;
84907c478bd9Sstevel@tonic-gate }
8491ced83f9bSceastha Gen.g_attrnam_p = NULL;
8492ced83f9bSceastha Gen.g_attrfnam_p = NULL;
8493ced83f9bSceastha Gen.g_linktoattrfnam_p = NULL;
8494ced83f9bSceastha Gen.g_linktoattrnam_p = NULL;
8495ced83f9bSceastha Gen.g_rw_sysattr = 0;
8496ced83f9bSceastha if (Gen.g_attrpath_p != NULL) {
8497ced83f9bSceastha free(Gen.g_attrpath_p);
8498ced83f9bSceastha Gen.g_attrpath_p = NULL;
8499ced83f9bSceastha }
8500ced83f9bSceastha
8501fa9e4066Sahrens if (aclp != NULL) {
8502fa9e4066Sahrens acl_free(aclp);
85037c478bd9Sstevel@tonic-gate aclp = NULL;
8504fa9e4066Sahrens acl_is_set = 0;
85057c478bd9Sstevel@tonic-gate }
85067c478bd9Sstevel@tonic-gate free(namep);
85077c478bd9Sstevel@tonic-gate }
85087c478bd9Sstevel@tonic-gate
85097c478bd9Sstevel@tonic-gate (void) closedir(dirp);
85107c478bd9Sstevel@tonic-gate (void) close(Gen.g_dirfd);
8511ced83f9bSceastha if (attrparent == NULL) {
8512ced83f9bSceastha rest_cwd(Gen.g_baseparent_fd);
85137c478bd9Sstevel@tonic-gate Gen.g_dirfd = -1;
85147c478bd9Sstevel@tonic-gate }
8515ced83f9bSceastha Hiddendir = 0;
8516ced83f9bSceastha }
85177c478bd9Sstevel@tonic-gate #else
85187c478bd9Sstevel@tonic-gate static void
xattrs_out(int (* func)())85197c478bd9Sstevel@tonic-gate xattrs_out(int (*func)())
85207c478bd9Sstevel@tonic-gate {
85217c478bd9Sstevel@tonic-gate }
85227c478bd9Sstevel@tonic-gate #endif
85237c478bd9Sstevel@tonic-gate
85247c478bd9Sstevel@tonic-gate /*
85257c478bd9Sstevel@tonic-gate * Return the parent directory of a given path.
85267c478bd9Sstevel@tonic-gate *
85277c478bd9Sstevel@tonic-gate * Examples:
85287c478bd9Sstevel@tonic-gate * /usr/tmp return /usr
85297c478bd9Sstevel@tonic-gate * /usr/tmp/file return /usr/tmp
85307c478bd9Sstevel@tonic-gate * / returns .
85317c478bd9Sstevel@tonic-gate * /usr returns /
85327c478bd9Sstevel@tonic-gate * file returns .
85337c478bd9Sstevel@tonic-gate *
85347c478bd9Sstevel@tonic-gate * dir is assumed to be at least as big as path.
85357c478bd9Sstevel@tonic-gate */
85367c478bd9Sstevel@tonic-gate static void
get_parent(char * path,char * dir)85377c478bd9Sstevel@tonic-gate get_parent(char *path, char *dir)
85387c478bd9Sstevel@tonic-gate {
85397c478bd9Sstevel@tonic-gate char *s;
85407c478bd9Sstevel@tonic-gate char tmpdir[PATH_MAX + 1];
85417c478bd9Sstevel@tonic-gate
85427c478bd9Sstevel@tonic-gate if (strlen(path) > PATH_MAX) {
85437c478bd9Sstevel@tonic-gate msg(EXT, "pathname is too long");
85447c478bd9Sstevel@tonic-gate }
85457c478bd9Sstevel@tonic-gate (void) strcpy(tmpdir, path);
85467c478bd9Sstevel@tonic-gate chop_endslashes(tmpdir);
85477c478bd9Sstevel@tonic-gate
85487c478bd9Sstevel@tonic-gate if ((s = strrchr(tmpdir, '/')) == NULL) {
85497c478bd9Sstevel@tonic-gate (void) strcpy(dir, ".");
85507c478bd9Sstevel@tonic-gate } else {
85517c478bd9Sstevel@tonic-gate s = skipslashes(s, tmpdir);
85527c478bd9Sstevel@tonic-gate *s = '\0';
85537c478bd9Sstevel@tonic-gate if (s == tmpdir)
85547c478bd9Sstevel@tonic-gate (void) strcpy(dir, "/");
85557c478bd9Sstevel@tonic-gate else
85567c478bd9Sstevel@tonic-gate (void) strcpy(dir, tmpdir);
85577c478bd9Sstevel@tonic-gate }
85587c478bd9Sstevel@tonic-gate }
85597c478bd9Sstevel@tonic-gate
85607c478bd9Sstevel@tonic-gate #if defined(O_XATTR)
85617c478bd9Sstevel@tonic-gate #define ROUNDTOTBLOCK(a) ((a + (TBLOCK -1)) & ~(TBLOCK -1))
85627c478bd9Sstevel@tonic-gate
85637c478bd9Sstevel@tonic-gate static void
prepare_xattr_hdr(char ** attrbuf,char * filename,char * attrpath,char typeflag,struct Lnk * linkinfo,int * rlen)85647c478bd9Sstevel@tonic-gate prepare_xattr_hdr(
85657c478bd9Sstevel@tonic-gate char **attrbuf,
85667c478bd9Sstevel@tonic-gate char *filename,
8567ced83f9bSceastha char *attrpath,
85687c478bd9Sstevel@tonic-gate char typeflag,
85697c478bd9Sstevel@tonic-gate struct Lnk *linkinfo,
85707c478bd9Sstevel@tonic-gate int *rlen)
85717c478bd9Sstevel@tonic-gate {
85727c478bd9Sstevel@tonic-gate char *bufhead; /* ptr to full buffer */
8573ced83f9bSceastha char *aptr;
85747c478bd9Sstevel@tonic-gate struct xattr_hdr *hptr; /* ptr to header in bufhead */
85757c478bd9Sstevel@tonic-gate struct xattr_buf *tptr; /* ptr to pathing pieces */
85767c478bd9Sstevel@tonic-gate int totalen; /* total buffer length */
85777c478bd9Sstevel@tonic-gate int len; /* length returned to user */
85787c478bd9Sstevel@tonic-gate int stringlen; /* length of filename + attr */
8579ced83f9bSceastha /*
8580ced83f9bSceastha * length of filename + attr
8581ced83f9bSceastha * in link section
8582ced83f9bSceastha */
85830b9a5158SToomas Soome int linkstringlen = 0;
85847c478bd9Sstevel@tonic-gate int complen; /* length of pathing section */
85857c478bd9Sstevel@tonic-gate int linklen; /* length of link section */
8586ced83f9bSceastha int attrnames_index; /* attrnames starting index */
85877c478bd9Sstevel@tonic-gate
85887c478bd9Sstevel@tonic-gate /*
85897c478bd9Sstevel@tonic-gate * Release previous buffer if any.
85907c478bd9Sstevel@tonic-gate */
85917c478bd9Sstevel@tonic-gate
8592ced83f9bSceastha if (*attrbuf != NULL) {
85937c478bd9Sstevel@tonic-gate free(*attrbuf);
85947c478bd9Sstevel@tonic-gate *attrbuf = NULL;
85957c478bd9Sstevel@tonic-gate }
85967c478bd9Sstevel@tonic-gate
85977c478bd9Sstevel@tonic-gate /*
85987c478bd9Sstevel@tonic-gate * First add in fixed size stuff
85997c478bd9Sstevel@tonic-gate */
86007c478bd9Sstevel@tonic-gate len = sizeof (struct xattr_hdr) + sizeof (struct xattr_buf);
86017c478bd9Sstevel@tonic-gate
86027c478bd9Sstevel@tonic-gate /*
86037c478bd9Sstevel@tonic-gate * Add space for two nulls
86047c478bd9Sstevel@tonic-gate */
8605ced83f9bSceastha stringlen = strlen(attrpath) + strlen(filename) + 2;
86067c478bd9Sstevel@tonic-gate complen = stringlen + sizeof (struct xattr_buf);
86077c478bd9Sstevel@tonic-gate
86087c478bd9Sstevel@tonic-gate len += stringlen;
86097c478bd9Sstevel@tonic-gate
86107c478bd9Sstevel@tonic-gate /*
86117c478bd9Sstevel@tonic-gate * Now add on space for link info if any
86127c478bd9Sstevel@tonic-gate */
86137c478bd9Sstevel@tonic-gate
86147c478bd9Sstevel@tonic-gate if (linkinfo != NULL) {
86157c478bd9Sstevel@tonic-gate /*
86167c478bd9Sstevel@tonic-gate * Again add space for two nulls
86177c478bd9Sstevel@tonic-gate */
86187c478bd9Sstevel@tonic-gate linkstringlen = strlen(linkinfo->L_gen.g_attrfnam_p) +
86197c478bd9Sstevel@tonic-gate strlen(linkinfo->L_gen.g_attrnam_p) + 2;
8620ced83f9bSceastha linklen = linkstringlen + sizeof (struct xattr_buf);
8621ced83f9bSceastha len += linklen;
8622ced83f9bSceastha } else {
8623ced83f9bSceastha linklen = 0;
86247c478bd9Sstevel@tonic-gate }
86257c478bd9Sstevel@tonic-gate
86267c478bd9Sstevel@tonic-gate /*
86277c478bd9Sstevel@tonic-gate * Now add padding to end to fill out TBLOCK
86287c478bd9Sstevel@tonic-gate *
86297c478bd9Sstevel@tonic-gate * Function returns size of real data and not size + padding.
86307c478bd9Sstevel@tonic-gate */
86317c478bd9Sstevel@tonic-gate
86327c478bd9Sstevel@tonic-gate totalen = ROUNDTOTBLOCK(len);
86337c478bd9Sstevel@tonic-gate bufhead = e_zalloc(E_EXIT, totalen);
86347c478bd9Sstevel@tonic-gate
86357c478bd9Sstevel@tonic-gate /*
86367c478bd9Sstevel@tonic-gate * Now we can fill in the necessary pieces
86377c478bd9Sstevel@tonic-gate */
86387c478bd9Sstevel@tonic-gate
86397c478bd9Sstevel@tonic-gate /*
86407c478bd9Sstevel@tonic-gate * first fill in the fixed header
86417c478bd9Sstevel@tonic-gate */
86427c478bd9Sstevel@tonic-gate hptr = (struct xattr_hdr *)bufhead;
86435fbb8099SNobutomo Nakano (void) strcpy(hptr->h_version, XATTR_ARCH_VERS);
86447c478bd9Sstevel@tonic-gate (void) sprintf(hptr->h_component_len, "%0*d",
86457c478bd9Sstevel@tonic-gate sizeof (hptr->h_component_len) - 1, complen);
86467c478bd9Sstevel@tonic-gate (void) sprintf(hptr->h_link_component_len, "%0*d",
86477c478bd9Sstevel@tonic-gate sizeof (hptr->h_link_component_len) - 1, linklen);
86487c478bd9Sstevel@tonic-gate (void) sprintf(hptr->h_size, "%0*d", sizeof (hptr->h_size) - 1, len);
86497c478bd9Sstevel@tonic-gate
86507c478bd9Sstevel@tonic-gate /*
86517c478bd9Sstevel@tonic-gate * Now fill in the filename + attrnames section
8652ced83f9bSceastha * The filename and attrnames section can be composed of two or more
8653ced83f9bSceastha * path segments separated by a null character. The first segment
8654ced83f9bSceastha * is the path to the parent file that roots the entire sequence in
8655ced83f9bSceastha * the normal name space. The remaining segments describes a path
8656ced83f9bSceastha * rooted at the hidden extended attribute directory of the leaf file of
8657ced83f9bSceastha * the previous segment, making it possible to name attributes on
8658ced83f9bSceastha * attributes. Thus, if we are just archiving an extended attribute,
8659ced83f9bSceastha * the second segment will contain the attribute name. If we are
8660ced83f9bSceastha * archiving a system attribute of an extended attribute, then the
8661ced83f9bSceastha * second segment will contain the attribute name, and a third segment
8662ced83f9bSceastha * will contain the system attribute name. The attribute pathing
8663ced83f9bSceastha * information is obtained from 'attrpath'.
86647c478bd9Sstevel@tonic-gate */
86657c478bd9Sstevel@tonic-gate
86667c478bd9Sstevel@tonic-gate tptr = (struct xattr_buf *)(bufhead + sizeof (struct xattr_hdr));
86677c478bd9Sstevel@tonic-gate (void) sprintf(tptr->h_namesz, "%0*d", sizeof (tptr->h_namesz) - 1,
86687c478bd9Sstevel@tonic-gate stringlen);
86697c478bd9Sstevel@tonic-gate (void) strcpy(tptr->h_names, filename);
8670ced83f9bSceastha attrnames_index = strlen(filename) + 1;
8671ced83f9bSceastha (void) strcpy(&tptr->h_names[attrnames_index], attrpath);
86727c478bd9Sstevel@tonic-gate tptr->h_typeflag = typeflag;
86737c478bd9Sstevel@tonic-gate
86747c478bd9Sstevel@tonic-gate /*
8675ced83f9bSceastha * Split the attrnames section into two segments if 'attrpath'
8676ced83f9bSceastha * contains pathing information for a system attribute of an
8677ced83f9bSceastha * extended attribute. We split them by replacing the '/' with
8678ced83f9bSceastha * a '\0'.
8679ced83f9bSceastha */
8680ced83f9bSceastha if ((aptr = strpbrk(&tptr->h_names[attrnames_index], "/")) != NULL) {
8681ced83f9bSceastha *aptr = '\0';
8682ced83f9bSceastha }
8683ced83f9bSceastha
8684ced83f9bSceastha /*
86857c478bd9Sstevel@tonic-gate * Now fill in the optional link section if we have one
86867c478bd9Sstevel@tonic-gate */
86877c478bd9Sstevel@tonic-gate
8688ced83f9bSceastha if (linkinfo != NULL) {
86897c478bd9Sstevel@tonic-gate tptr = (struct xattr_buf *)(bufhead +
86907c478bd9Sstevel@tonic-gate sizeof (struct xattr_hdr) + complen);
86917c478bd9Sstevel@tonic-gate
86927c478bd9Sstevel@tonic-gate (void) sprintf(tptr->h_namesz, "%0*d",
86937c478bd9Sstevel@tonic-gate sizeof (tptr->h_namesz) - 1, linkstringlen);
86947c478bd9Sstevel@tonic-gate (void) strcpy(tptr->h_names, linkinfo->L_gen.g_attrfnam_p);
86957c478bd9Sstevel@tonic-gate (void) strcpy(
86967c478bd9Sstevel@tonic-gate &tptr->h_names[strlen(linkinfo->L_gen.g_attrfnam_p) + 1],
86977c478bd9Sstevel@tonic-gate linkinfo->L_gen.g_attrnam_p);
86987c478bd9Sstevel@tonic-gate tptr->h_typeflag = typeflag;
86997c478bd9Sstevel@tonic-gate }
87007c478bd9Sstevel@tonic-gate *attrbuf = (char *)bufhead;
87017c478bd9Sstevel@tonic-gate *rlen = len;
87027c478bd9Sstevel@tonic-gate }
87037c478bd9Sstevel@tonic-gate #endif /* O_XATTR */
87047c478bd9Sstevel@tonic-gate
87057c478bd9Sstevel@tonic-gate static char
tartype(int type)87067c478bd9Sstevel@tonic-gate tartype(int type)
87077c478bd9Sstevel@tonic-gate {
87087c478bd9Sstevel@tonic-gate switch (type) {
87097c478bd9Sstevel@tonic-gate
87107c478bd9Sstevel@tonic-gate case S_IFDIR:
87117c478bd9Sstevel@tonic-gate return (DIRTYPE);
87127c478bd9Sstevel@tonic-gate
87137c478bd9Sstevel@tonic-gate case S_IFLNK:
87147c478bd9Sstevel@tonic-gate return (SYMTYPE);
87157c478bd9Sstevel@tonic-gate
87167c478bd9Sstevel@tonic-gate case S_IFIFO:
87177c478bd9Sstevel@tonic-gate return (FIFOTYPE);
87187c478bd9Sstevel@tonic-gate
87197c478bd9Sstevel@tonic-gate case S_IFCHR:
87207c478bd9Sstevel@tonic-gate return (CHRTYPE);
87217c478bd9Sstevel@tonic-gate
87227c478bd9Sstevel@tonic-gate case S_IFBLK:
87237c478bd9Sstevel@tonic-gate return (BLKTYPE);
87247c478bd9Sstevel@tonic-gate
87257c478bd9Sstevel@tonic-gate case S_IFREG:
87267c478bd9Sstevel@tonic-gate return (REGTYPE);
87277c478bd9Sstevel@tonic-gate
87287c478bd9Sstevel@tonic-gate default:
87297c478bd9Sstevel@tonic-gate return ('\0');
87307c478bd9Sstevel@tonic-gate }
87317c478bd9Sstevel@tonic-gate }
87327c478bd9Sstevel@tonic-gate
87337c478bd9Sstevel@tonic-gate #if defined(O_XATTR)
87347c478bd9Sstevel@tonic-gate static int
openfile(int omode)87357c478bd9Sstevel@tonic-gate openfile(int omode)
87367c478bd9Sstevel@tonic-gate {
8737ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
8738ced83f9bSceastha return (openat(G_p->g_dirfd, G_p->g_attrnam_p, omode));
87397c478bd9Sstevel@tonic-gate } else {
87407c478bd9Sstevel@tonic-gate return (openat(G_p->g_dirfd,
87417c478bd9Sstevel@tonic-gate get_component(G_p->g_nam_p), omode));
87427c478bd9Sstevel@tonic-gate }
87437c478bd9Sstevel@tonic-gate }
87447c478bd9Sstevel@tonic-gate #else
87457c478bd9Sstevel@tonic-gate static int
openfile(int omode)87467c478bd9Sstevel@tonic-gate openfile(int omode)
87477c478bd9Sstevel@tonic-gate {
87487c478bd9Sstevel@tonic-gate return (openat(G_p->g_dirfd, get_component(G_p->g_nam_p), omode));
87497c478bd9Sstevel@tonic-gate }
87507c478bd9Sstevel@tonic-gate #endif
87517c478bd9Sstevel@tonic-gate
87527c478bd9Sstevel@tonic-gate #if defined(O_XATTR)
87537c478bd9Sstevel@tonic-gate static int
read_xattr_hdr()87547c478bd9Sstevel@tonic-gate read_xattr_hdr()
87557c478bd9Sstevel@tonic-gate {
87567c478bd9Sstevel@tonic-gate off_t bytes;
87577c478bd9Sstevel@tonic-gate int comp_len, link_len;
87587c478bd9Sstevel@tonic-gate int namelen;
8759da6c28aaSamw int asz;
87607c478bd9Sstevel@tonic-gate int cnt;
87617c478bd9Sstevel@tonic-gate char *tp;
8762da6c28aaSamw char *xattrapath;
87637c478bd9Sstevel@tonic-gate int pad;
8764da6c28aaSamw int parentfilelen;
87657c478bd9Sstevel@tonic-gate
87667c478bd9Sstevel@tonic-gate /*
87677c478bd9Sstevel@tonic-gate * Include any padding in the read. We need to be positioned
87687c478bd9Sstevel@tonic-gate * at beginning of next header.
87697c478bd9Sstevel@tonic-gate */
87707c478bd9Sstevel@tonic-gate
87717c478bd9Sstevel@tonic-gate bytes = Gen.g_filesz;
87727c478bd9Sstevel@tonic-gate
87737c478bd9Sstevel@tonic-gate if ((xattrhead = e_zalloc(E_NORMAL, (size_t)bytes)) == NULL) {
87747c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext(
87757c478bd9Sstevel@tonic-gate "Insufficient memory for extended attribute\n"));
87767c478bd9Sstevel@tonic-gate return (1);
87777c478bd9Sstevel@tonic-gate }
87787c478bd9Sstevel@tonic-gate
87797c478bd9Sstevel@tonic-gate tp = (char *)xattrhead;
87807c478bd9Sstevel@tonic-gate while (bytes > 0) {
87817c478bd9Sstevel@tonic-gate cnt = (int)(bytes > CPIOBSZ) ? CPIOBSZ : bytes;
87827c478bd9Sstevel@tonic-gate FILL(cnt);
87837c478bd9Sstevel@tonic-gate (void) memcpy(tp, Buffr.b_out_p, cnt);
87847c478bd9Sstevel@tonic-gate tp += cnt;
87857c478bd9Sstevel@tonic-gate Buffr.b_out_p += cnt;
87867c478bd9Sstevel@tonic-gate Buffr.b_cnt -= (off_t)cnt;
87877c478bd9Sstevel@tonic-gate bytes -= (off_t)cnt;
87887c478bd9Sstevel@tonic-gate }
87897c478bd9Sstevel@tonic-gate
87907c478bd9Sstevel@tonic-gate pad = (Pad_val + 1 - (Gen.g_filesz & Pad_val)) &
87917c478bd9Sstevel@tonic-gate Pad_val;
87927c478bd9Sstevel@tonic-gate if (pad != 0) {
87937c478bd9Sstevel@tonic-gate FILL(pad);
87947c478bd9Sstevel@tonic-gate Buffr.b_out_p += pad;
87957c478bd9Sstevel@tonic-gate Buffr.b_cnt -= (off_t)pad;
87967c478bd9Sstevel@tonic-gate }
87977c478bd9Sstevel@tonic-gate
87987c478bd9Sstevel@tonic-gate /*
87997c478bd9Sstevel@tonic-gate * Validate that we can handle header format
88007c478bd9Sstevel@tonic-gate */
88017c478bd9Sstevel@tonic-gate
88027c478bd9Sstevel@tonic-gate if (strcmp(xattrhead->h_version, XATTR_ARCH_VERS) != 0) {
88037c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
88047c478bd9Sstevel@tonic-gate gettext("Unknown extended attribute format encountered\n"));
88057c478bd9Sstevel@tonic-gate (void) fprintf(stderr,
88067c478bd9Sstevel@tonic-gate gettext("Disabling extended attribute header parsing\n"));
88077c478bd9Sstevel@tonic-gate xattrbadhead = 1;
88087c478bd9Sstevel@tonic-gate return (1);
88097c478bd9Sstevel@tonic-gate }
88107c478bd9Sstevel@tonic-gate (void) sscanf(xattrhead->h_component_len, "%10d", &comp_len);
88117c478bd9Sstevel@tonic-gate (void) sscanf(xattrhead->h_link_component_len, "%10d", &link_len);
88127c478bd9Sstevel@tonic-gate xattrp = (struct xattr_buf *)(((char *)xattrhead) +
88137c478bd9Sstevel@tonic-gate sizeof (struct xattr_hdr));
88147c478bd9Sstevel@tonic-gate (void) sscanf(xattrp->h_namesz, "%7d", &namelen);
88157c478bd9Sstevel@tonic-gate if (link_len > 0) {
8816*6d3b960aSAndy Fiddaman xattr_linkp = (struct xattr_buf *)((intptr_t)xattrp +
8817*6d3b960aSAndy Fiddaman (int)comp_len);
88187c478bd9Sstevel@tonic-gate } else {
88197c478bd9Sstevel@tonic-gate xattr_linkp = NULL;
88207c478bd9Sstevel@tonic-gate }
88217c478bd9Sstevel@tonic-gate
8822da6c28aaSamw /*
8823da6c28aaSamw * Gather the attribute path from the filename and attrnames section.
8824da6c28aaSamw * The filename and attrnames section can be composed of two or more
8825da6c28aaSamw * path segments separated by a null character. The first segment
8826da6c28aaSamw * is the path to the parent file that roots the entire sequence in
8827da6c28aaSamw * the normal name space. The remaining segments describes a path
8828da6c28aaSamw * rooted at the hidden extended attribute directory of the leaf file of
8829da6c28aaSamw * the previous segment, making it possible to name attributes on
8830da6c28aaSamw * attributes.
8831da6c28aaSamw */
8832da6c28aaSamw parentfilelen = strlen(xattrp->h_names);
8833da6c28aaSamw xattrapath = xattrp->h_names + parentfilelen + 1;
8834da6c28aaSamw asz = strlen(xattrapath);
8835da6c28aaSamw if ((asz + parentfilelen + 2) < namelen) {
8836da6c28aaSamw /*
8837da6c28aaSamw * The attrnames section contains a system attribute on an
8838da6c28aaSamw * attribute. Save the name of the attribute for use later,
8839da6c28aaSamw * and replace the null separating the attribute name from
8840da6c28aaSamw * the system attribute name with a '/' so that xattrapath can
8841da6c28aaSamw * be used to display messages with the full attribute path name
8842da6c28aaSamw * rooted at the hidden attribute directory of the base file
8843da6c28aaSamw * in normal name space.
8844da6c28aaSamw */
8845da6c28aaSamw xattrapath[asz] = '/';
8846da6c28aaSamw }
8847da6c28aaSamw
88487c478bd9Sstevel@tonic-gate return (0);
88497c478bd9Sstevel@tonic-gate }
88507c478bd9Sstevel@tonic-gate #endif
88517c478bd9Sstevel@tonic-gate
88527c478bd9Sstevel@tonic-gate static mode_t
attrmode(char type)88537c478bd9Sstevel@tonic-gate attrmode(char type)
88547c478bd9Sstevel@tonic-gate {
88557c478bd9Sstevel@tonic-gate mode_t mode;
88567c478bd9Sstevel@tonic-gate
88577c478bd9Sstevel@tonic-gate switch (type) {
88587c478bd9Sstevel@tonic-gate case '\0':
88597c478bd9Sstevel@tonic-gate case REGTYPE:
88607c478bd9Sstevel@tonic-gate case LNKTYPE:
88617c478bd9Sstevel@tonic-gate mode = S_IFREG;
88627c478bd9Sstevel@tonic-gate break;
88637c478bd9Sstevel@tonic-gate
88647c478bd9Sstevel@tonic-gate case SYMTYPE:
88657c478bd9Sstevel@tonic-gate mode = S_IFLNK;
88667c478bd9Sstevel@tonic-gate break;
88677c478bd9Sstevel@tonic-gate
88687c478bd9Sstevel@tonic-gate case CHRTYPE:
88697c478bd9Sstevel@tonic-gate mode = S_IFCHR;
88707c478bd9Sstevel@tonic-gate break;
88717c478bd9Sstevel@tonic-gate case BLKTYPE:
88727c478bd9Sstevel@tonic-gate mode = S_IFBLK;
88737c478bd9Sstevel@tonic-gate break;
88747c478bd9Sstevel@tonic-gate case DIRTYPE:
88757c478bd9Sstevel@tonic-gate mode = S_IFDIR;
88767c478bd9Sstevel@tonic-gate break;
88777c478bd9Sstevel@tonic-gate case FIFOTYPE:
88787c478bd9Sstevel@tonic-gate mode = S_IFIFO;
88797c478bd9Sstevel@tonic-gate break;
88807c478bd9Sstevel@tonic-gate case CONTTYPE:
88817c478bd9Sstevel@tonic-gate default:
88827c478bd9Sstevel@tonic-gate mode = 0;
88837c478bd9Sstevel@tonic-gate }
88847c478bd9Sstevel@tonic-gate
88857c478bd9Sstevel@tonic-gate return (mode);
88867c478bd9Sstevel@tonic-gate }
88877c478bd9Sstevel@tonic-gate
88887c478bd9Sstevel@tonic-gate #if defined(O_XATTR)
88897c478bd9Sstevel@tonic-gate static char *
get_component(char * path)88907c478bd9Sstevel@tonic-gate get_component(char *path)
88917c478bd9Sstevel@tonic-gate {
88927c478bd9Sstevel@tonic-gate char *ptr;
88937c478bd9Sstevel@tonic-gate
88947c478bd9Sstevel@tonic-gate ptr = strrchr(path, '/');
88957c478bd9Sstevel@tonic-gate if (ptr == NULL) {
88967c478bd9Sstevel@tonic-gate return (path);
88977c478bd9Sstevel@tonic-gate } else {
88987c478bd9Sstevel@tonic-gate /*
88997c478bd9Sstevel@tonic-gate * Handle trailing slash
89007c478bd9Sstevel@tonic-gate */
89017c478bd9Sstevel@tonic-gate if (*(ptr + 1) == '\0')
89027c478bd9Sstevel@tonic-gate return (ptr);
89037c478bd9Sstevel@tonic-gate else
89047c478bd9Sstevel@tonic-gate return (ptr + 1);
89057c478bd9Sstevel@tonic-gate }
89067c478bd9Sstevel@tonic-gate }
89077c478bd9Sstevel@tonic-gate #else
89087c478bd9Sstevel@tonic-gate static char *
get_component(char * path)89097c478bd9Sstevel@tonic-gate get_component(char *path)
89107c478bd9Sstevel@tonic-gate {
89117c478bd9Sstevel@tonic-gate return (path);
89127c478bd9Sstevel@tonic-gate }
89137c478bd9Sstevel@tonic-gate #endif
89147c478bd9Sstevel@tonic-gate
89157c478bd9Sstevel@tonic-gate static int
open_dir(char * name)89167c478bd9Sstevel@tonic-gate open_dir(char *name)
89177c478bd9Sstevel@tonic-gate {
89187c478bd9Sstevel@tonic-gate int fd = -1;
89197c478bd9Sstevel@tonic-gate int cnt = 0;
89207c478bd9Sstevel@tonic-gate char *dir;
89217c478bd9Sstevel@tonic-gate
89227c478bd9Sstevel@tonic-gate dir = e_zalloc(E_EXIT, strlen(name) + 1);
89237c478bd9Sstevel@tonic-gate
89247c478bd9Sstevel@tonic-gate /*
89257c478bd9Sstevel@tonic-gate * open directory; creating missing directories along the way.
89267c478bd9Sstevel@tonic-gate */
89277c478bd9Sstevel@tonic-gate get_parent(name, dir);
89287c478bd9Sstevel@tonic-gate do {
89297c478bd9Sstevel@tonic-gate fd = open(dir, O_RDONLY);
89307c478bd9Sstevel@tonic-gate if (fd != -1) {
89317c478bd9Sstevel@tonic-gate free(dir);
89327c478bd9Sstevel@tonic-gate return (fd);
89337c478bd9Sstevel@tonic-gate }
89347c478bd9Sstevel@tonic-gate cnt++;
89357c478bd9Sstevel@tonic-gate } while (cnt <= 1 && missdir(name) == 0);
89367c478bd9Sstevel@tonic-gate
89377c478bd9Sstevel@tonic-gate free(dir);
89387c478bd9Sstevel@tonic-gate return (-1);
89397c478bd9Sstevel@tonic-gate }
89407c478bd9Sstevel@tonic-gate
89417c478bd9Sstevel@tonic-gate static int
open_dirfd()89427c478bd9Sstevel@tonic-gate open_dirfd()
89437c478bd9Sstevel@tonic-gate {
89447c478bd9Sstevel@tonic-gate #ifdef O_XATTR
89457c478bd9Sstevel@tonic-gate if ((Args & OCt) == 0) {
89467c478bd9Sstevel@tonic-gate close_dirfd();
8947ced83f9bSceastha if (G_p->g_attrnam_p != NULL) {
8948ced83f9bSceastha int rw_sysattr;
8949ced83f9bSceastha
8950ced83f9bSceastha /*
8951ced83f9bSceastha * Open the file's attribute directory.
8952ced83f9bSceastha * Change into the base file's starting directory then
8953ced83f9bSceastha * call open_attr_dir() to open the attribute directory
8954ced83f9bSceastha * of either the base file (if G_p->g_attrparent_p is
8955ced83f9bSceastha * NULL) or the attribute (if G_p->g_attrparent_p is
8956ced83f9bSceastha * set) of the base file.
8957ced83f9bSceastha */
8958ced83f9bSceastha (void) fchdir(G_p->g_baseparent_fd);
8959ced83f9bSceastha (void) open_attr_dir(G_p->g_attrnam_p,
8960ced83f9bSceastha G_p->g_attrfnam_p, G_p->g_baseparent_fd,
8961ced83f9bSceastha (G_p->g_attrparent_p == NULL) ? NULL :
8962ced83f9bSceastha G_p->g_attrparent_p, &G_p->g_dirfd, &rw_sysattr);
8963ced83f9bSceastha if (Args & OCi) {
8964ced83f9bSceastha int saveerrno = errno;
8965ced83f9bSceastha
8966ced83f9bSceastha (void) fchdir(G_p->g_baseparent_fd);
8967ced83f9bSceastha errno = saveerrno;
89687c478bd9Sstevel@tonic-gate }
8969ced83f9bSceastha if ((G_p->g_dirfd == -1) && (Args & (OCi | OCp))) {
8970ced83f9bSceastha msg(ERRN,
8971ced83f9bSceastha "Cannot open attribute directory "
8972ced83f9bSceastha "of %s%s%sfile \"%s\"",
8973ced83f9bSceastha (G_p->g_attrparent_p == NULL) ? "" :
8974ced83f9bSceastha gettext("attribute \""),
8975ced83f9bSceastha (G_p->g_attrparent_p == NULL) ? "" :
8976ced83f9bSceastha G_p->g_attrparent_p,
8977ced83f9bSceastha (G_p->g_attrparent_p == NULL) ? "" :
8978ced83f9bSceastha gettext("\" of "),
8979ced83f9bSceastha G_p->g_attrfnam_p);
8980ced83f9bSceastha return (FILE_PASS_ERR);
89817c478bd9Sstevel@tonic-gate }
89827c478bd9Sstevel@tonic-gate } else {
89837c478bd9Sstevel@tonic-gate G_p->g_dirfd = open_dir(G_p->g_nam_p);
89847c478bd9Sstevel@tonic-gate if (G_p->g_dirfd == -1) {
89857c478bd9Sstevel@tonic-gate msg(ERRN,
89867c478bd9Sstevel@tonic-gate "Cannot open/create %s", G_p->g_nam_p);
89877c478bd9Sstevel@tonic-gate return (1);
89887c478bd9Sstevel@tonic-gate }
89897c478bd9Sstevel@tonic-gate }
89907c478bd9Sstevel@tonic-gate } else {
89917c478bd9Sstevel@tonic-gate G_p->g_dirfd = -1;
89927c478bd9Sstevel@tonic-gate }
89937c478bd9Sstevel@tonic-gate #else
89947c478bd9Sstevel@tonic-gate G_p->g_dirfd = -1;
89957c478bd9Sstevel@tonic-gate #endif
89967c478bd9Sstevel@tonic-gate return (0);
89977c478bd9Sstevel@tonic-gate }
89987c478bd9Sstevel@tonic-gate
89997c478bd9Sstevel@tonic-gate static void
close_dirfd()90007c478bd9Sstevel@tonic-gate close_dirfd()
90017c478bd9Sstevel@tonic-gate {
90027c478bd9Sstevel@tonic-gate if (G_p->g_dirfd != -1) {
90037c478bd9Sstevel@tonic-gate (void) close(G_p->g_dirfd);
90047c478bd9Sstevel@tonic-gate G_p->g_dirfd = -1;
90057c478bd9Sstevel@tonic-gate }
90067c478bd9Sstevel@tonic-gate }
90077c478bd9Sstevel@tonic-gate
90087c478bd9Sstevel@tonic-gate static void
write_xattr_hdr()90097c478bd9Sstevel@tonic-gate write_xattr_hdr()
90107c478bd9Sstevel@tonic-gate {
90117c478bd9Sstevel@tonic-gate char *attrbuf = NULL;
90127c478bd9Sstevel@tonic-gate int attrlen = 0;
90137c478bd9Sstevel@tonic-gate char *namep;
90147c478bd9Sstevel@tonic-gate struct Lnk *tl_p, *linkinfo;
90157c478bd9Sstevel@tonic-gate
90167c478bd9Sstevel@tonic-gate /*
90177c478bd9Sstevel@tonic-gate * namep was allocated in xattrs_out. It is big enough to hold
90187c478bd9Sstevel@tonic-gate * either the name + .hdr on the end or just the attr name
90197c478bd9Sstevel@tonic-gate */
90207c478bd9Sstevel@tonic-gate
90217c478bd9Sstevel@tonic-gate #if defined(O_XATTR)
90227c478bd9Sstevel@tonic-gate namep = Gen.g_nam_p;
90237c478bd9Sstevel@tonic-gate (void) creat_hdr();
90247c478bd9Sstevel@tonic-gate
90257c478bd9Sstevel@tonic-gate if (Args & OCo) {
90267c478bd9Sstevel@tonic-gate linkinfo = NULL;
90277c478bd9Sstevel@tonic-gate tl_p = Lnk_hd.L_nxt_p;
90287c478bd9Sstevel@tonic-gate while (tl_p != &Lnk_hd) {
90297c478bd9Sstevel@tonic-gate if (tl_p->L_gen.g_ino == G_p->g_ino &&
90307c478bd9Sstevel@tonic-gate tl_p->L_gen.g_dev == G_p->g_dev) {
90317c478bd9Sstevel@tonic-gate linkinfo = tl_p;
90327c478bd9Sstevel@tonic-gate break; /* found */
90337c478bd9Sstevel@tonic-gate }
90347c478bd9Sstevel@tonic-gate tl_p = tl_p->L_nxt_p;
90357c478bd9Sstevel@tonic-gate }
90367c478bd9Sstevel@tonic-gate prepare_xattr_hdr(&attrbuf, Gen.g_attrfnam_p,
9037ced83f9bSceastha Gen.g_attrpath_p,
9038ced83f9bSceastha (linkinfo == NULL) ?
90397c478bd9Sstevel@tonic-gate tartype(Gen.g_mode & Ftype) : LNKTYPE,
90407c478bd9Sstevel@tonic-gate linkinfo, &attrlen);
90417c478bd9Sstevel@tonic-gate Gen.g_filesz = attrlen;
90427c478bd9Sstevel@tonic-gate write_hdr(ARCHIVE_XATTR, (off_t)attrlen);
90437c478bd9Sstevel@tonic-gate (void) sprintf(namep, "%s/%s", DEVNULL, Gen.g_attrnam_p);
90445fbb8099SNobutomo Nakano write_ancillary(attrbuf, attrlen, B_TRUE);
90457c478bd9Sstevel@tonic-gate }
90467c478bd9Sstevel@tonic-gate
90477c478bd9Sstevel@tonic-gate (void) creat_hdr();
90487c478bd9Sstevel@tonic-gate #endif
90497c478bd9Sstevel@tonic-gate }
90507c478bd9Sstevel@tonic-gate
90517c478bd9Sstevel@tonic-gate /*
90527c478bd9Sstevel@tonic-gate * skip over extra slashes in string.
90537c478bd9Sstevel@tonic-gate *
90547c478bd9Sstevel@tonic-gate * For example:
90557c478bd9Sstevel@tonic-gate * /usr/tmp/////
90567c478bd9Sstevel@tonic-gate *
90577c478bd9Sstevel@tonic-gate * would return pointer at
90587c478bd9Sstevel@tonic-gate * /usr/tmp/////
90597c478bd9Sstevel@tonic-gate * ^
90607c478bd9Sstevel@tonic-gate */
90617c478bd9Sstevel@tonic-gate static char *
skipslashes(char * string,char * start)90627c478bd9Sstevel@tonic-gate skipslashes(char *string, char *start)
90637c478bd9Sstevel@tonic-gate {
90647c478bd9Sstevel@tonic-gate while ((string > start) && *(string - 1) == '/') {
90657c478bd9Sstevel@tonic-gate string--;
90667c478bd9Sstevel@tonic-gate }
90677c478bd9Sstevel@tonic-gate
90687c478bd9Sstevel@tonic-gate return (string);
90697c478bd9Sstevel@tonic-gate }
90707c478bd9Sstevel@tonic-gate
90717c478bd9Sstevel@tonic-gate static sl_info_t *
sl_info_alloc(void)90727c478bd9Sstevel@tonic-gate sl_info_alloc(void)
90737c478bd9Sstevel@tonic-gate {
90747c478bd9Sstevel@tonic-gate static int num_left;
90757c478bd9Sstevel@tonic-gate static sl_info_t *slipool;
90767c478bd9Sstevel@tonic-gate
90777c478bd9Sstevel@tonic-gate if (num_left > 0) {
90787c478bd9Sstevel@tonic-gate return (&slipool[--num_left]);
90797c478bd9Sstevel@tonic-gate }
90807c478bd9Sstevel@tonic-gate num_left = SL_INFO_ALLOC_CHUNK;
90817c478bd9Sstevel@tonic-gate slipool = e_zalloc(E_EXIT, sizeof (sl_info_t) * num_left);
90827c478bd9Sstevel@tonic-gate return (&slipool[--num_left]);
90837c478bd9Sstevel@tonic-gate }
90847c478bd9Sstevel@tonic-gate
90857c478bd9Sstevel@tonic-gate /*
90867c478bd9Sstevel@tonic-gate * If a match for the key values was found in the tree, return a pointer to it.
90877c478bd9Sstevel@tonic-gate * If a match was not found, insert it and return a pointer to it. This is
90887c478bd9Sstevel@tonic-gate * based on Knuth's Algorithm A in Vol 3, section 6.2.3.
90897c478bd9Sstevel@tonic-gate */
90907c478bd9Sstevel@tonic-gate
90917c478bd9Sstevel@tonic-gate sl_info_t *
sl_insert(dev_t device,ino_t inode,int ftype)9092ced83f9bSceastha sl_insert(dev_t device, ino_t inode, int ftype)
90937c478bd9Sstevel@tonic-gate {
90947c478bd9Sstevel@tonic-gate sl_info_t *p; /* moves down the tree */
90950b9a5158SToomas Soome sl_info_t *q = NULL; /* scratch */
90967c478bd9Sstevel@tonic-gate sl_info_t *r; /* scratch */
90977c478bd9Sstevel@tonic-gate sl_info_t *s; /* pt where rebalancing may be needed */
90987c478bd9Sstevel@tonic-gate sl_info_t *t; /* father of s */
90997c478bd9Sstevel@tonic-gate sl_info_t *head;
91007c478bd9Sstevel@tonic-gate
91017c478bd9Sstevel@tonic-gate int a; /* used to hold balance factors */
91027c478bd9Sstevel@tonic-gate int done; /* loop control */
91037c478bd9Sstevel@tonic-gate int cmpflg; /* used to hold the result of a comparison */
91047c478bd9Sstevel@tonic-gate
91057c478bd9Sstevel@tonic-gate /* initialize */
91067c478bd9Sstevel@tonic-gate
91077c478bd9Sstevel@tonic-gate head = sl_devhash_lookup(device);
91087c478bd9Sstevel@tonic-gate
91097c478bd9Sstevel@tonic-gate if (head == NULL) {
91107c478bd9Sstevel@tonic-gate head = sl_info_alloc();
91117c478bd9Sstevel@tonic-gate head->llink = NULL;
91127c478bd9Sstevel@tonic-gate head->bal = 0;
91137c478bd9Sstevel@tonic-gate
91147c478bd9Sstevel@tonic-gate p = head->rlink = sl_info_alloc();
91157c478bd9Sstevel@tonic-gate p->sl_ino = inode;
9116ced83f9bSceastha p->sl_ftype = ftype;
91177c478bd9Sstevel@tonic-gate p->sl_count = 0;
91187c478bd9Sstevel@tonic-gate p->bal = 0;
91197c478bd9Sstevel@tonic-gate p->llink = NULL;
91207c478bd9Sstevel@tonic-gate p->rlink = NULL;
91217c478bd9Sstevel@tonic-gate sl_devhash_insert(device, head);
91227c478bd9Sstevel@tonic-gate return (p);
91237c478bd9Sstevel@tonic-gate }
91247c478bd9Sstevel@tonic-gate
91257c478bd9Sstevel@tonic-gate t = head;
91267c478bd9Sstevel@tonic-gate s = p = head->rlink;
91277c478bd9Sstevel@tonic-gate
91287c478bd9Sstevel@tonic-gate /* compare */
91297c478bd9Sstevel@tonic-gate
91307c478bd9Sstevel@tonic-gate for (done = 0; ! done; ) {
9131ced83f9bSceastha switch (sl_compare(inode, ftype, p->sl_ino, p->sl_ftype)) {
91327c478bd9Sstevel@tonic-gate case -1:
91337c478bd9Sstevel@tonic-gate /* move left */
91347c478bd9Sstevel@tonic-gate
91357c478bd9Sstevel@tonic-gate q = p->llink;
91367c478bd9Sstevel@tonic-gate
91377c478bd9Sstevel@tonic-gate if (q == NULL) {
91387c478bd9Sstevel@tonic-gate q = sl_info_alloc();
91397c478bd9Sstevel@tonic-gate p->llink = q;
91407c478bd9Sstevel@tonic-gate done = 1;
91417c478bd9Sstevel@tonic-gate continue;
91427c478bd9Sstevel@tonic-gate }
91437c478bd9Sstevel@tonic-gate
91447c478bd9Sstevel@tonic-gate break;
91457c478bd9Sstevel@tonic-gate
91467c478bd9Sstevel@tonic-gate case 0:
91477c478bd9Sstevel@tonic-gate /* found it */
91487c478bd9Sstevel@tonic-gate return (p);
91497c478bd9Sstevel@tonic-gate
91507c478bd9Sstevel@tonic-gate case 1:
91517c478bd9Sstevel@tonic-gate /* move right */
91527c478bd9Sstevel@tonic-gate
91537c478bd9Sstevel@tonic-gate q = p->rlink;
91547c478bd9Sstevel@tonic-gate
91557c478bd9Sstevel@tonic-gate if (q == NULL) {
91567c478bd9Sstevel@tonic-gate q = sl_info_alloc();
91577c478bd9Sstevel@tonic-gate p->rlink = q;
91587c478bd9Sstevel@tonic-gate done = 1;
91597c478bd9Sstevel@tonic-gate continue;
91607c478bd9Sstevel@tonic-gate }
91617c478bd9Sstevel@tonic-gate
91627c478bd9Sstevel@tonic-gate break;
91637c478bd9Sstevel@tonic-gate }
91647c478bd9Sstevel@tonic-gate
91657c478bd9Sstevel@tonic-gate if (q->bal != 0) {
91667c478bd9Sstevel@tonic-gate t = p;
91677c478bd9Sstevel@tonic-gate s = q;
91687c478bd9Sstevel@tonic-gate }
91697c478bd9Sstevel@tonic-gate
91707c478bd9Sstevel@tonic-gate p = q;
91717c478bd9Sstevel@tonic-gate }
91727c478bd9Sstevel@tonic-gate
91737c478bd9Sstevel@tonic-gate /* insert */
91747c478bd9Sstevel@tonic-gate
91757c478bd9Sstevel@tonic-gate q->sl_ino = inode;
9176ced83f9bSceastha q->sl_ftype = ftype;
91777c478bd9Sstevel@tonic-gate q->sl_count = 0;
91787c478bd9Sstevel@tonic-gate q->llink = q->rlink = NULL;
91797c478bd9Sstevel@tonic-gate q->bal = 0;
91807c478bd9Sstevel@tonic-gate
91817c478bd9Sstevel@tonic-gate /* adjust balance factors */
91827c478bd9Sstevel@tonic-gate
9183ced83f9bSceastha if ((cmpflg = sl_compare(inode, ftype, s->sl_ino, s->sl_ftype)) < 0) {
91847c478bd9Sstevel@tonic-gate r = p = s->llink;
91857c478bd9Sstevel@tonic-gate } else {
91867c478bd9Sstevel@tonic-gate r = p = s->rlink;
91877c478bd9Sstevel@tonic-gate }
91887c478bd9Sstevel@tonic-gate
91897c478bd9Sstevel@tonic-gate while (p != q) {
9190ced83f9bSceastha switch (sl_compare(inode, ftype, p->sl_ino, p->sl_ftype)) {
91917c478bd9Sstevel@tonic-gate case -1:
91927c478bd9Sstevel@tonic-gate p->bal = -1;
91937c478bd9Sstevel@tonic-gate p = p->llink;
91947c478bd9Sstevel@tonic-gate break;
91957c478bd9Sstevel@tonic-gate
91967c478bd9Sstevel@tonic-gate case 0:
91977c478bd9Sstevel@tonic-gate break;
91987c478bd9Sstevel@tonic-gate
91997c478bd9Sstevel@tonic-gate case 1:
92007c478bd9Sstevel@tonic-gate p->bal = 1;
92017c478bd9Sstevel@tonic-gate p = p->rlink;
92027c478bd9Sstevel@tonic-gate break;
92037c478bd9Sstevel@tonic-gate }
92047c478bd9Sstevel@tonic-gate }
92057c478bd9Sstevel@tonic-gate
92067c478bd9Sstevel@tonic-gate /* balancing act */
92077c478bd9Sstevel@tonic-gate
92087c478bd9Sstevel@tonic-gate if (cmpflg < 0) {
92097c478bd9Sstevel@tonic-gate a = -1;
92107c478bd9Sstevel@tonic-gate } else {
92117c478bd9Sstevel@tonic-gate a = 1;
92127c478bd9Sstevel@tonic-gate }
92137c478bd9Sstevel@tonic-gate
92147c478bd9Sstevel@tonic-gate if (s->bal == 0) {
92157c478bd9Sstevel@tonic-gate s->bal = a;
9216*6d3b960aSAndy Fiddaman head->llink = (sl_info_t *)((intptr_t)head->llink + 1);
92177c478bd9Sstevel@tonic-gate return (q);
92187c478bd9Sstevel@tonic-gate } else if (s->bal == -a) {
92197c478bd9Sstevel@tonic-gate s->bal = 0;
92207c478bd9Sstevel@tonic-gate return (q);
92217c478bd9Sstevel@tonic-gate }
92227c478bd9Sstevel@tonic-gate
92237c478bd9Sstevel@tonic-gate /*
92247c478bd9Sstevel@tonic-gate * (s->bal == a)
92257c478bd9Sstevel@tonic-gate */
92267c478bd9Sstevel@tonic-gate
92277c478bd9Sstevel@tonic-gate if (r->bal == a) {
92287c478bd9Sstevel@tonic-gate /* single rotation */
92297c478bd9Sstevel@tonic-gate
92307c478bd9Sstevel@tonic-gate p = r;
92317c478bd9Sstevel@tonic-gate
92327c478bd9Sstevel@tonic-gate if (a == -1) {
92337c478bd9Sstevel@tonic-gate s->llink = r->rlink;
92347c478bd9Sstevel@tonic-gate r->rlink = s;
92357c478bd9Sstevel@tonic-gate } else if (a == 1) {
92367c478bd9Sstevel@tonic-gate s->rlink = r->llink;
92377c478bd9Sstevel@tonic-gate r->llink = s;
92387c478bd9Sstevel@tonic-gate }
92397c478bd9Sstevel@tonic-gate
92407c478bd9Sstevel@tonic-gate s->bal = r->bal = 0;
92417c478bd9Sstevel@tonic-gate
92427c478bd9Sstevel@tonic-gate } else if (r->bal == -a) {
92437c478bd9Sstevel@tonic-gate /* double rotation */
92447c478bd9Sstevel@tonic-gate
92457c478bd9Sstevel@tonic-gate if (a == -1) {
92467c478bd9Sstevel@tonic-gate p = r->rlink;
92477c478bd9Sstevel@tonic-gate r->rlink = p->llink;
92487c478bd9Sstevel@tonic-gate p->llink = r;
92497c478bd9Sstevel@tonic-gate s->llink = p->rlink;
92507c478bd9Sstevel@tonic-gate p->rlink = s;
92517c478bd9Sstevel@tonic-gate } else if (a == 1) {
92527c478bd9Sstevel@tonic-gate p = r->llink;
92537c478bd9Sstevel@tonic-gate r->llink = p->rlink;
92547c478bd9Sstevel@tonic-gate p->rlink = r;
92557c478bd9Sstevel@tonic-gate s->rlink = p->llink;
92567c478bd9Sstevel@tonic-gate p->llink = s;
92577c478bd9Sstevel@tonic-gate }
92587c478bd9Sstevel@tonic-gate
92597c478bd9Sstevel@tonic-gate if (p->bal == 0) {
92607c478bd9Sstevel@tonic-gate s->bal = 0;
92617c478bd9Sstevel@tonic-gate r->bal = 0;
92627c478bd9Sstevel@tonic-gate } else if (p->bal == -a) {
92637c478bd9Sstevel@tonic-gate s->bal = 0;
92647c478bd9Sstevel@tonic-gate r->bal = a;
92657c478bd9Sstevel@tonic-gate } else if (p->bal == a) {
92667c478bd9Sstevel@tonic-gate s->bal = -a;
92677c478bd9Sstevel@tonic-gate r->bal = 0;
92687c478bd9Sstevel@tonic-gate }
92697c478bd9Sstevel@tonic-gate
92707c478bd9Sstevel@tonic-gate p->bal = 0;
92717c478bd9Sstevel@tonic-gate }
92727c478bd9Sstevel@tonic-gate
92737c478bd9Sstevel@tonic-gate /* finishing touch */
92747c478bd9Sstevel@tonic-gate
92757c478bd9Sstevel@tonic-gate if (s == t->rlink) {
92767c478bd9Sstevel@tonic-gate t->rlink = p;
92777c478bd9Sstevel@tonic-gate } else {
92787c478bd9Sstevel@tonic-gate t->llink = p;
92797c478bd9Sstevel@tonic-gate }
92807c478bd9Sstevel@tonic-gate
92817c478bd9Sstevel@tonic-gate return (q);
92827c478bd9Sstevel@tonic-gate }
92837c478bd9Sstevel@tonic-gate
92847c478bd9Sstevel@tonic-gate /*
92857c478bd9Sstevel@tonic-gate * sl_numlinks: return the number of links that we saw during our preview.
92867c478bd9Sstevel@tonic-gate */
92877c478bd9Sstevel@tonic-gate
9288*6d3b960aSAndy Fiddaman static uint_t
sl_numlinks(dev_t device,ino_t inode,int ftype)9289ced83f9bSceastha sl_numlinks(dev_t device, ino_t inode, int ftype)
92907c478bd9Sstevel@tonic-gate {
9291ced83f9bSceastha sl_info_t *p = sl_search(device, inode, ftype);
92927c478bd9Sstevel@tonic-gate
92937c478bd9Sstevel@tonic-gate if (p) {
92947c478bd9Sstevel@tonic-gate return (p->sl_count);
92957c478bd9Sstevel@tonic-gate } else {
92967c478bd9Sstevel@tonic-gate return (1);
92977c478bd9Sstevel@tonic-gate }
92987c478bd9Sstevel@tonic-gate }
92997c478bd9Sstevel@tonic-gate
93007c478bd9Sstevel@tonic-gate /*
9301ced83f9bSceastha * Preview extended and extended system attributes.
9302ced83f9bSceastha *
9303ced83f9bSceastha * Return 0 if successful, otherwise return 1.
9304ced83f9bSceastha */
9305ced83f9bSceastha #if defined(O_XATTR)
9306ced83f9bSceastha static int
preview_attrs(char * s,char * attrparent)9307ced83f9bSceastha preview_attrs(char *s, char *attrparent)
9308ced83f9bSceastha {
9309ced83f9bSceastha char *filename = (attrparent == NULL) ? s : attrparent;
9310ced83f9bSceastha int dirfd;
9311ced83f9bSceastha int tmpfd;
9312ced83f9bSceastha int islnk;
9313ced83f9bSceastha int rc = 0;
9314ced83f9bSceastha int arc_rwsysattr = 0;
9315ced83f9bSceastha int rw_sysattr = 0;
9316ced83f9bSceastha int ext_attr = 0;
9317ced83f9bSceastha DIR *dirp;
9318ced83f9bSceastha struct dirent *dp;
9319ced83f9bSceastha struct stat sb;
9320ced83f9bSceastha
9321ced83f9bSceastha /*
9322ced83f9bSceastha * If the underlying file system supports it, then
9323ced83f9bSceastha * archive the extended attributes if -@ was specified,
9324ced83f9bSceastha * and the extended system attributes if -/ was
9325ced83f9bSceastha * specified.
9326ced83f9bSceastha */
9327ced83f9bSceastha if (verify_attr_support(filename, (attrparent == NULL), ARC_CREATE,
9328ced83f9bSceastha &ext_attr) != ATTR_OK) {
9329ced83f9bSceastha return (1);
9330ced83f9bSceastha }
9331ced83f9bSceastha
9332ced83f9bSceastha #if defined(_PC_SATTR_ENABLED)
9333ced83f9bSceastha if (SysAtflag) {
9334ced83f9bSceastha int filefd;
9335ced83f9bSceastha nvlist_t *slist = NULL;
9336ced83f9bSceastha
9337ced83f9bSceastha /* Determine if there are non-transient system attributes. */
9338ced83f9bSceastha errno = 0;
9339ced83f9bSceastha if ((filefd = open(filename, O_RDONLY)) < 0) {
9340ced83f9bSceastha return (1);
9341ced83f9bSceastha }
9342ced83f9bSceastha if (((slist = sysattr_list(myname, filefd,
9343ced83f9bSceastha filename)) != NULL) || (errno != 0)) {
9344ced83f9bSceastha arc_rwsysattr = 1;
9345ced83f9bSceastha }
9346ced83f9bSceastha if (slist != NULL) {
9347ced83f9bSceastha (void) nvlist_free(slist);
9348ced83f9bSceastha slist = NULL;
9349ced83f9bSceastha }
9350ced83f9bSceastha (void) close(filefd);
9351ced83f9bSceastha }
9352ced83f9bSceastha
9353ced83f9bSceastha if ((arc_rwsysattr == 0) && ((attrparent != NULL) ||
9354ced83f9bSceastha (SysAtflag && !ext_attr))) {
9355ced83f9bSceastha return (1);
9356ced83f9bSceastha }
9357ced83f9bSceastha #endif /* _PC_SATTR_ENABLED */
9358ced83f9bSceastha /*
9359ced83f9bSceastha * We need to open the attribute directory of the
9360ced83f9bSceastha * file, and preview all of the file's attributes as
9361ced83f9bSceastha * attributes of the file can be hard links to other
9362ced83f9bSceastha * attributes of the file.
9363ced83f9bSceastha */
9364ced83f9bSceastha dirfd = attropen(filename, ".", O_RDONLY);
9365ced83f9bSceastha if (dirfd == -1)
9366ced83f9bSceastha return (1);
9367ced83f9bSceastha
9368ced83f9bSceastha tmpfd = dup(dirfd);
9369ced83f9bSceastha if (tmpfd == -1) {
9370ced83f9bSceastha (void) close(dirfd);
9371ced83f9bSceastha return (1);
9372ced83f9bSceastha }
9373ced83f9bSceastha dirp = fdopendir(tmpfd);
9374ced83f9bSceastha if (dirp == NULL) {
9375ced83f9bSceastha (void) close(dirfd);
9376ced83f9bSceastha (void) close(tmpfd);
9377ced83f9bSceastha return (1);
9378ced83f9bSceastha }
9379ced83f9bSceastha
9380*6d3b960aSAndy Fiddaman while ((dp = readdir(dirp)) != NULL) {
9381ced83f9bSceastha if (dp->d_name[0] == '.') {
9382ced83f9bSceastha if (dp->d_name[1] == '\0') {
9383ced83f9bSceastha Hiddendir = 1;
9384ced83f9bSceastha } else if ((dp->d_name[1] == '.') &&
9385ced83f9bSceastha (dp->d_name[2] == '\0')) {
9386ced83f9bSceastha continue;
9387ced83f9bSceastha } else {
9388ced83f9bSceastha Hiddendir = 0;
9389ced83f9bSceastha }
9390ced83f9bSceastha } else {
9391ced83f9bSceastha Hiddendir = 0;
9392ced83f9bSceastha }
9393ced83f9bSceastha
9394ced83f9bSceastha if (fstatat(dirfd, dp->d_name, &sb,
9395ced83f9bSceastha AT_SYMLINK_NOFOLLOW) < 0) {
9396ced83f9bSceastha continue;
9397ced83f9bSceastha }
9398ced83f9bSceastha
9399ced83f9bSceastha if (verify_attr(dp->d_name, attrparent,
9400ced83f9bSceastha arc_rwsysattr, &rw_sysattr) != ATTR_OK) {
9401ced83f9bSceastha continue;
9402ced83f9bSceastha }
9403ced83f9bSceastha
9404ced83f9bSceastha islnk = 0;
9405ced83f9bSceastha if (S_ISLNK(sb.st_mode)) {
9406ced83f9bSceastha islnk = 1;
9407ced83f9bSceastha if (Args & OCL) {
9408ced83f9bSceastha if (fstatat(dirfd, dp->d_name,
9409ced83f9bSceastha &sb, 0) < 0) {
9410ced83f9bSceastha continue;
9411ced83f9bSceastha }
9412ced83f9bSceastha }
9413ced83f9bSceastha }
9414ced83f9bSceastha sl_remember_tgt(&sb, islnk, rw_sysattr);
9415ced83f9bSceastha
9416ced83f9bSceastha /*
9417ced83f9bSceastha * Recursively call preview_attrs() to preview extended
9418ced83f9bSceastha * system attributes of attributes.
9419ced83f9bSceastha */
9420ced83f9bSceastha if (SysAtflag && !Hiddendir && !rw_sysattr) {
9421ced83f9bSceastha int my_cwd = save_cwd();
9422ced83f9bSceastha
9423ced83f9bSceastha (void) fchdir(dirfd);
9424ced83f9bSceastha rc = preview_attrs(s, dp->d_name);
9425ced83f9bSceastha rest_cwd(my_cwd);
9426ced83f9bSceastha }
9427ced83f9bSceastha }
9428ced83f9bSceastha (void) closedir(dirp);
9429ced83f9bSceastha (void) close(dirfd);
9430ced83f9bSceastha return (rc);
9431ced83f9bSceastha }
9432ced83f9bSceastha #endif /* O_XATTR */
9433ced83f9bSceastha
9434ced83f9bSceastha /*
94357c478bd9Sstevel@tonic-gate * sl_preview_synonyms: Read the file list from the input stream, remembering
94367c478bd9Sstevel@tonic-gate * each reference to each file.
94377c478bd9Sstevel@tonic-gate */
94387c478bd9Sstevel@tonic-gate
94397c478bd9Sstevel@tonic-gate static void
sl_preview_synonyms(void)94407c478bd9Sstevel@tonic-gate sl_preview_synonyms(void)
94417c478bd9Sstevel@tonic-gate {
94427c478bd9Sstevel@tonic-gate char buf [APATH+1];
94437c478bd9Sstevel@tonic-gate char *s;
94447c478bd9Sstevel@tonic-gate
94457c478bd9Sstevel@tonic-gate char *suffix = "/cpioXXXXXX";
94467c478bd9Sstevel@tonic-gate char *tmpdir = getenv("TMPDIR");
94477c478bd9Sstevel@tonic-gate int tmpfd, islnk;
94487c478bd9Sstevel@tonic-gate FILE *tmpfile;
94497c478bd9Sstevel@tonic-gate char *tmpfname;
94507c478bd9Sstevel@tonic-gate
94517c478bd9Sstevel@tonic-gate if (tmpdir == NULL || *tmpdir == '\0' ||
94527c478bd9Sstevel@tonic-gate (strlen(tmpdir) + strlen(suffix)) > APATH) {
94537c478bd9Sstevel@tonic-gate struct statvfs tdsb;
94547c478bd9Sstevel@tonic-gate
94557c478bd9Sstevel@tonic-gate tmpdir = "/var/tmp";
94567c478bd9Sstevel@tonic-gate
94577c478bd9Sstevel@tonic-gate /* /var/tmp is read-only in the mini-root environment */
94587c478bd9Sstevel@tonic-gate
94597c478bd9Sstevel@tonic-gate if (statvfs(tmpdir, &tdsb) == -1 || tdsb.f_flag & ST_RDONLY) {
94607c478bd9Sstevel@tonic-gate tmpdir = "/tmp";
94617c478bd9Sstevel@tonic-gate }
94627c478bd9Sstevel@tonic-gate }
94637c478bd9Sstevel@tonic-gate
94647c478bd9Sstevel@tonic-gate tmpfname = e_zalloc(E_EXIT, strlen(tmpdir) + strlen(suffix) + 1);
94657c478bd9Sstevel@tonic-gate
94667c478bd9Sstevel@tonic-gate (void) strcpy(tmpfname, tmpdir);
94677c478bd9Sstevel@tonic-gate (void) strcat(tmpfname, suffix);
94687c478bd9Sstevel@tonic-gate
94697c478bd9Sstevel@tonic-gate if ((tmpfd = mkstemp(tmpfname)) == -1) {
9470ced83f9bSceastha msg(EXTN, "cannot open tmpfile %s%s", tmpdir, suffix);
94717c478bd9Sstevel@tonic-gate }
94727c478bd9Sstevel@tonic-gate
94737c478bd9Sstevel@tonic-gate if (unlink(tmpfname) == -1) {
94747c478bd9Sstevel@tonic-gate msg(EXTN, "cannot unlink tmpfile %s", tmpfname);
94757c478bd9Sstevel@tonic-gate }
94767c478bd9Sstevel@tonic-gate
94777c478bd9Sstevel@tonic-gate if ((tmpfile = fdopen(tmpfd, "w+")) == NULL) {
94787c478bd9Sstevel@tonic-gate msg(EXTN, "cannot fdopen tmpfile %s", tmpfname);
94797c478bd9Sstevel@tonic-gate }
94807c478bd9Sstevel@tonic-gate
94817c478bd9Sstevel@tonic-gate while ((s = fgets(buf, APATH+1, In_p)) != NULL) {
94827c478bd9Sstevel@tonic-gate size_t lastchar;
94837c478bd9Sstevel@tonic-gate struct stat sb;
94847c478bd9Sstevel@tonic-gate
94857c478bd9Sstevel@tonic-gate if (fputs(buf, tmpfile) == EOF) {
94867c478bd9Sstevel@tonic-gate msg(EXTN, "problem writing to tmpfile %s", tmpfname);
94877c478bd9Sstevel@tonic-gate }
94887c478bd9Sstevel@tonic-gate
94897c478bd9Sstevel@tonic-gate /* pre-process the name */
94907c478bd9Sstevel@tonic-gate
94917c478bd9Sstevel@tonic-gate lastchar = strlen(s) - 1;
94927c478bd9Sstevel@tonic-gate
94937c478bd9Sstevel@tonic-gate if (s[lastchar] != '\n' && lastchar == APATH - 1) {
94947c478bd9Sstevel@tonic-gate continue;
94957c478bd9Sstevel@tonic-gate } else {
94967c478bd9Sstevel@tonic-gate s[lastchar] = '\0';
94977c478bd9Sstevel@tonic-gate }
94987c478bd9Sstevel@tonic-gate
94997c478bd9Sstevel@tonic-gate while (s[0] == '.' && s[1] == '/') {
95007c478bd9Sstevel@tonic-gate s += 2;
95017c478bd9Sstevel@tonic-gate while (s[0] == '/') {
95027c478bd9Sstevel@tonic-gate s++;
95037c478bd9Sstevel@tonic-gate }
95047c478bd9Sstevel@tonic-gate }
95057c478bd9Sstevel@tonic-gate
95067c478bd9Sstevel@tonic-gate if (lstat(s, &sb) < 0) {
95077c478bd9Sstevel@tonic-gate continue;
95087c478bd9Sstevel@tonic-gate }
95097c478bd9Sstevel@tonic-gate islnk = 0;
95107c478bd9Sstevel@tonic-gate if (S_ISLNK(sb.st_mode)) {
95117c478bd9Sstevel@tonic-gate islnk = 1;
95127c478bd9Sstevel@tonic-gate if (Args & OCL) {
95137c478bd9Sstevel@tonic-gate if (stat(s, &sb) < 0) {
95147c478bd9Sstevel@tonic-gate continue;
95157c478bd9Sstevel@tonic-gate }
95167c478bd9Sstevel@tonic-gate }
95177c478bd9Sstevel@tonic-gate }
9518ced83f9bSceastha sl_remember_tgt(&sb, islnk, 0);
95197c478bd9Sstevel@tonic-gate
95207c478bd9Sstevel@tonic-gate #if defined(O_XATTR)
9521ced83f9bSceastha if (Atflag || SysAtflag) {
9522ced83f9bSceastha (void) preview_attrs(s, NULL);
95237c478bd9Sstevel@tonic-gate }
9524ced83f9bSceastha #endif /* O_XATTR */
95257c478bd9Sstevel@tonic-gate }
95267c478bd9Sstevel@tonic-gate
95277c478bd9Sstevel@tonic-gate if (ferror(In_p)) {
95287c478bd9Sstevel@tonic-gate msg(EXTN, "error reading stdin");
95297c478bd9Sstevel@tonic-gate }
95307c478bd9Sstevel@tonic-gate
95317c478bd9Sstevel@tonic-gate if (fseek(tmpfile, 0L, SEEK_SET) == -1) {
95327c478bd9Sstevel@tonic-gate msg(EXTN, "cannot fseek on tmpfile %s", tmpfname);
95337c478bd9Sstevel@tonic-gate }
95347c478bd9Sstevel@tonic-gate
95357c478bd9Sstevel@tonic-gate In_p = tmpfile;
95367c478bd9Sstevel@tonic-gate free(tmpfname);
95377c478bd9Sstevel@tonic-gate }
95387c478bd9Sstevel@tonic-gate
95397c478bd9Sstevel@tonic-gate /*
95407c478bd9Sstevel@tonic-gate * sl_remember_tgt: Add the device/inode for lstat or stat info to the list of
95417c478bd9Sstevel@tonic-gate * those we've seen before.
95427c478bd9Sstevel@tonic-gate *
95437c478bd9Sstevel@tonic-gate * This tree (rooted under head) is keyed by the device/inode of the file
95447c478bd9Sstevel@tonic-gate * being pointed to. A count is kept of the number of references encountered
95457c478bd9Sstevel@tonic-gate * so far.
95467c478bd9Sstevel@tonic-gate */
95477c478bd9Sstevel@tonic-gate
95487c478bd9Sstevel@tonic-gate static void
sl_remember_tgt(const struct stat * sbp,int isSymlink,int is_sysattr)9549ced83f9bSceastha sl_remember_tgt(const struct stat *sbp, int isSymlink, int is_sysattr)
95507c478bd9Sstevel@tonic-gate {
95517c478bd9Sstevel@tonic-gate sl_info_t *p;
95527c478bd9Sstevel@tonic-gate dev_t device;
95537c478bd9Sstevel@tonic-gate ino_t inode;
9554ced83f9bSceastha int ftype;
95557c478bd9Sstevel@tonic-gate
95567c478bd9Sstevel@tonic-gate device = sbp->st_dev;
95577c478bd9Sstevel@tonic-gate inode = sbp->st_ino;
9558ced83f9bSceastha ftype = sbp->st_mode & Ftype;
95597c478bd9Sstevel@tonic-gate
95607c478bd9Sstevel@tonic-gate /* Determine whether we've seen this one before */
95617c478bd9Sstevel@tonic-gate
9562ced83f9bSceastha p = sl_insert(device, inode, ftype);
95637c478bd9Sstevel@tonic-gate
95647c478bd9Sstevel@tonic-gate if (p->sl_count > 0) {
95657c478bd9Sstevel@tonic-gate /*
9566ced83f9bSceastha * It appears as if have seen this file before as we found a
9567ced83f9bSceastha * matching device, inode, and file type as a file already
9568ced83f9bSceastha * processed. Since there can possibly be files with the
9569ced83f9bSceastha * same device, inode, and file type, but aren't hard links
9570ced83f9bSceastha * (e.g., read-write system attribute files will always have
9571ced83f9bSceastha * the same inode), we need to only attempt to add one to the
9572ced83f9bSceastha * link count if the file we are processing is a hard link
9573ced83f9bSceastha * (i.e., st_nlink > 1).
9574ced83f9bSceastha *
95757c478bd9Sstevel@tonic-gate * Note that if we are not chasing symlinks, and this one is a
95767c478bd9Sstevel@tonic-gate * symlink, it is identically the one we saw before (you cannot
95777c478bd9Sstevel@tonic-gate * have hard links to symlinks); in this case, we leave the
95787c478bd9Sstevel@tonic-gate * count alone, so that we don't wind up archiving a symlink to
95797c478bd9Sstevel@tonic-gate * itself.
95807c478bd9Sstevel@tonic-gate */
95817c478bd9Sstevel@tonic-gate
9582ced83f9bSceastha if (((Args & OCL) || (! isSymlink)) && !is_sysattr) {
95837c478bd9Sstevel@tonic-gate p->sl_count++;
95847c478bd9Sstevel@tonic-gate }
95857c478bd9Sstevel@tonic-gate } else {
95867c478bd9Sstevel@tonic-gate /* We have not seen this file before */
95877c478bd9Sstevel@tonic-gate
95887c478bd9Sstevel@tonic-gate p->sl_count = 1;
95897c478bd9Sstevel@tonic-gate
95907c478bd9Sstevel@tonic-gate if (Use_old_stat) {
95917c478bd9Sstevel@tonic-gate /* -Hodc: remap inode (-1 on overflow) */
95927c478bd9Sstevel@tonic-gate
95937c478bd9Sstevel@tonic-gate sl_remap_t *q;
95947c478bd9Sstevel@tonic-gate
95957c478bd9Sstevel@tonic-gate for (q = sl_remap_head; q && (q->dev != device);
95967c478bd9Sstevel@tonic-gate q = q->next) {
95977c478bd9Sstevel@tonic-gate /* do nothing */
95987c478bd9Sstevel@tonic-gate }
95997c478bd9Sstevel@tonic-gate
96007c478bd9Sstevel@tonic-gate if (q == NULL) {
96017c478bd9Sstevel@tonic-gate q = e_zalloc(E_EXIT, sizeof (sl_remap_t));
96027c478bd9Sstevel@tonic-gate q->dev = device;
96037c478bd9Sstevel@tonic-gate p->sl_ino2 = q->inode_count = 1;
96047c478bd9Sstevel@tonic-gate
96057c478bd9Sstevel@tonic-gate q->next = (sl_remap_head) ?
96067c478bd9Sstevel@tonic-gate sl_remap_head->next : NULL;
96077c478bd9Sstevel@tonic-gate sl_remap_head = q;
96087c478bd9Sstevel@tonic-gate } else {
96097c478bd9Sstevel@tonic-gate if ((size_t)q->inode_count <=
96107c478bd9Sstevel@tonic-gate ((1 << (sizeof (o_ino_t) * 8)) - 1)) {
96117c478bd9Sstevel@tonic-gate /* fits in o_ino_t */
96127c478bd9Sstevel@tonic-gate p->sl_ino2 = ++(q->inode_count);
96137c478bd9Sstevel@tonic-gate } else {
96147c478bd9Sstevel@tonic-gate p->sl_ino2 = (ino_t)-1;
96157c478bd9Sstevel@tonic-gate }
96167c478bd9Sstevel@tonic-gate }
96177c478bd9Sstevel@tonic-gate }
96187c478bd9Sstevel@tonic-gate }
96197c478bd9Sstevel@tonic-gate }
96207c478bd9Sstevel@tonic-gate
96217c478bd9Sstevel@tonic-gate /*
96227c478bd9Sstevel@tonic-gate * A faster search, which does not insert the key values into the tree.
96237c478bd9Sstevel@tonic-gate * If the a match was found in the tree, return a pointer to it. If it was not
96247c478bd9Sstevel@tonic-gate * found, return NULL.
96257c478bd9Sstevel@tonic-gate */
96267c478bd9Sstevel@tonic-gate
96277c478bd9Sstevel@tonic-gate sl_info_t *
sl_search(dev_t device,ino_t inode,int ftype)9628ced83f9bSceastha sl_search(dev_t device, ino_t inode, int ftype)
96297c478bd9Sstevel@tonic-gate {
96307c478bd9Sstevel@tonic-gate sl_info_t *p; /* moves down the tree */
96317c478bd9Sstevel@tonic-gate int c; /* comparison value */
96327c478bd9Sstevel@tonic-gate sl_info_t *retval = NULL; /* return value */
96337c478bd9Sstevel@tonic-gate sl_info_t *head;
96347c478bd9Sstevel@tonic-gate
96357c478bd9Sstevel@tonic-gate head = sl_devhash_lookup(device);
96367c478bd9Sstevel@tonic-gate if (head != NULL) {
96377c478bd9Sstevel@tonic-gate for (p = head->rlink; p; ) {
9638ced83f9bSceastha if ((c = sl_compare(inode, ftype, p->sl_ino,
9639ced83f9bSceastha p->sl_ftype)) == 0) {
96407c478bd9Sstevel@tonic-gate retval = p;
96417c478bd9Sstevel@tonic-gate break;
96427c478bd9Sstevel@tonic-gate } else if (c < 0) {
96437c478bd9Sstevel@tonic-gate p = p->llink;
96447c478bd9Sstevel@tonic-gate } else {
96457c478bd9Sstevel@tonic-gate p = p->rlink;
96467c478bd9Sstevel@tonic-gate }
96477c478bd9Sstevel@tonic-gate }
96487c478bd9Sstevel@tonic-gate }
96497c478bd9Sstevel@tonic-gate
96507c478bd9Sstevel@tonic-gate return (retval);
96517c478bd9Sstevel@tonic-gate }
96527c478bd9Sstevel@tonic-gate
96537c478bd9Sstevel@tonic-gate static sl_info_t *
sl_devhash_lookup(dev_t device)96547c478bd9Sstevel@tonic-gate sl_devhash_lookup(dev_t device)
96557c478bd9Sstevel@tonic-gate {
96567c478bd9Sstevel@tonic-gate int key;
96577c478bd9Sstevel@tonic-gate sl_info_link_t *lp;
96587c478bd9Sstevel@tonic-gate static sl_info_link_t *devcache;
96597c478bd9Sstevel@tonic-gate
96607c478bd9Sstevel@tonic-gate if (devcache != NULL && devcache->dev == device) {
96617c478bd9Sstevel@tonic-gate return (devcache->head);
96627c478bd9Sstevel@tonic-gate }
96637c478bd9Sstevel@tonic-gate
96647c478bd9Sstevel@tonic-gate key = DEV_HASHKEY(device);
96657c478bd9Sstevel@tonic-gate for (lp = sl_devhash[key]; lp; lp = lp->next) {
96667c478bd9Sstevel@tonic-gate if (lp->dev == device) {
96677c478bd9Sstevel@tonic-gate devcache = lp;
96687c478bd9Sstevel@tonic-gate return (lp->head);
96697c478bd9Sstevel@tonic-gate }
96707c478bd9Sstevel@tonic-gate }
96717c478bd9Sstevel@tonic-gate return (NULL);
96727c478bd9Sstevel@tonic-gate }
96737c478bd9Sstevel@tonic-gate
96747c478bd9Sstevel@tonic-gate static void
sl_devhash_insert(dev_t device,sl_info_t * head)96757c478bd9Sstevel@tonic-gate sl_devhash_insert(dev_t device, sl_info_t *head)
96767c478bd9Sstevel@tonic-gate {
96777c478bd9Sstevel@tonic-gate int key = DEV_HASHKEY(device);
96787c478bd9Sstevel@tonic-gate sl_info_link_t *lp;
96797c478bd9Sstevel@tonic-gate
96807c478bd9Sstevel@tonic-gate lp = e_zalloc(E_EXIT, sizeof (sl_info_link_t));
96817c478bd9Sstevel@tonic-gate lp->dev = device;
96827c478bd9Sstevel@tonic-gate lp->head = head;
96837c478bd9Sstevel@tonic-gate lp->next = sl_devhash[key];
96847c478bd9Sstevel@tonic-gate sl_devhash[key] = lp;
96857c478bd9Sstevel@tonic-gate }
96867c478bd9Sstevel@tonic-gate
96877c478bd9Sstevel@tonic-gate static void
chop_endslashes(char * path)96887c478bd9Sstevel@tonic-gate chop_endslashes(char *path)
96897c478bd9Sstevel@tonic-gate {
96907c478bd9Sstevel@tonic-gate char *end, *ptr;
96917c478bd9Sstevel@tonic-gate
96927c478bd9Sstevel@tonic-gate end = &path[strlen(path) -1];
96937c478bd9Sstevel@tonic-gate if (*end == '/' && end != path) {
96947c478bd9Sstevel@tonic-gate ptr = skipslashes(end, path);
96957c478bd9Sstevel@tonic-gate if (ptr != NULL && ptr != path) {
96967c478bd9Sstevel@tonic-gate *ptr = '\0';
96977c478bd9Sstevel@tonic-gate }
96987c478bd9Sstevel@tonic-gate }
96997c478bd9Sstevel@tonic-gate }
97007c478bd9Sstevel@tonic-gate
97017c478bd9Sstevel@tonic-gate #if !defined(O_XATTR)
97027c478bd9Sstevel@tonic-gate int
openat64(int fd,char * name,int oflag,mode_t cmode)97037c478bd9Sstevel@tonic-gate openat64(int fd, char *name, int oflag, mode_t cmode)
97047c478bd9Sstevel@tonic-gate {
97057c478bd9Sstevel@tonic-gate return (open64(name, oflag, cmode));
97067c478bd9Sstevel@tonic-gate }
97077c478bd9Sstevel@tonic-gate
97087c478bd9Sstevel@tonic-gate int
openat(int fd,char * name,int oflag,mode_t cmode)97097c478bd9Sstevel@tonic-gate openat(int fd, char *name, int oflag, mode_t cmode)
97107c478bd9Sstevel@tonic-gate {
97117c478bd9Sstevel@tonic-gate return (open(name, oflag, cmode));
97127c478bd9Sstevel@tonic-gate }
97137c478bd9Sstevel@tonic-gate
97147c478bd9Sstevel@tonic-gate int
fchownat(int fd,char * name,uid_t owner,gid_t group,int flag)97157c478bd9Sstevel@tonic-gate fchownat(int fd, char *name, uid_t owner, gid_t group, int flag)
97167c478bd9Sstevel@tonic-gate {
97177c478bd9Sstevel@tonic-gate if (flag == AT_SYMLINK_NOFOLLOW)
97187c478bd9Sstevel@tonic-gate return (lchown(name, owner, group));
97197c478bd9Sstevel@tonic-gate else
97207c478bd9Sstevel@tonic-gate return (chown(name, owner, group));
97217c478bd9Sstevel@tonic-gate }
97227c478bd9Sstevel@tonic-gate
97237c478bd9Sstevel@tonic-gate int
renameat(int fromfd,char * old,int tofd,char * new)97247c478bd9Sstevel@tonic-gate renameat(int fromfd, char *old, int tofd, char *new)
97257c478bd9Sstevel@tonic-gate {
97267c478bd9Sstevel@tonic-gate return (rename(old, new));
97277c478bd9Sstevel@tonic-gate }
97287c478bd9Sstevel@tonic-gate
97297c478bd9Sstevel@tonic-gate int
futimesat(int fd,char * path,struct timeval times[2])97307c478bd9Sstevel@tonic-gate futimesat(int fd, char *path, struct timeval times[2])
97317c478bd9Sstevel@tonic-gate {
97327c478bd9Sstevel@tonic-gate return (utimes(path, times));
97337c478bd9Sstevel@tonic-gate }
97347c478bd9Sstevel@tonic-gate
97357c478bd9Sstevel@tonic-gate int
unlinkat(int dirfd,char * path,int flag)97367c478bd9Sstevel@tonic-gate unlinkat(int dirfd, char *path, int flag)
97377c478bd9Sstevel@tonic-gate {
97387c478bd9Sstevel@tonic-gate if (flag == AT_REMOVEDIR) {
97397c478bd9Sstevel@tonic-gate return (rmdir(path));
97407c478bd9Sstevel@tonic-gate } else {
97417c478bd9Sstevel@tonic-gate return (unlink(path));
97427c478bd9Sstevel@tonic-gate }
97437c478bd9Sstevel@tonic-gate }
97447c478bd9Sstevel@tonic-gate
97457c478bd9Sstevel@tonic-gate int
fstatat(int fd,char * path,struct stat * buf,int flag)97467c478bd9Sstevel@tonic-gate fstatat(int fd, char *path, struct stat *buf, int flag)
97477c478bd9Sstevel@tonic-gate {
97487c478bd9Sstevel@tonic-gate if (flag == AT_SYMLINK_NOFOLLOW)
97497c478bd9Sstevel@tonic-gate return (lstat(path, buf));
97507c478bd9Sstevel@tonic-gate else
97517c478bd9Sstevel@tonic-gate return (stat(path, buf));
97527c478bd9Sstevel@tonic-gate }
97537c478bd9Sstevel@tonic-gate
97547c478bd9Sstevel@tonic-gate int
attropen(char * file,char * attr,int omode,mode_t cmode)97557c478bd9Sstevel@tonic-gate attropen(char *file, char *attr, int omode, mode_t cmode)
97567c478bd9Sstevel@tonic-gate {
97577c478bd9Sstevel@tonic-gate errno = ENOTSUP;
97587c478bd9Sstevel@tonic-gate return (-1);
97597c478bd9Sstevel@tonic-gate }
97607c478bd9Sstevel@tonic-gate #endif
9761