#pragma ident "%Z%%M% %I% %E% SMI"

#include <unistd.h>

#include <sys/types.h>

#include <sys/param.h>

#include <sys/stat.h>

#include <sys/mkdev.h>

#include <sys/wait.h>

#include <dirent.h>

#include <errno.h>

#include <stdio.h>

#include <signal.h>

#include <ctype.h>

#include <locale.h>

#include <nl_types.h>

#include <langinfo.h>

#include <pwd.h>

#include <grp.h>

#include <fcntl.h>

#include <string.h>

#include <malloc.h>

#include <time.h>

#include <utime.h>

#include <stdlib.h>

#include <stdarg.h>

#include <widec.h>

#include <sys/mtio.h>

#include <sys/acl.h>

#include <strings.h>

#include <deflt.h>

#include <limits.h>

#include <iconv.h>

#include <assert.h>

#include <libgen.h>

#include <libintl.h>

#include <aclutils.h>

#include <libnvpair.h>

#include <archives.h>

#if defined(__SunOS_5_6) || defined(__SunOS_5_7)

extern int defcntl();

#endif

#if defined(_PC_SATTR_ENABLED)

#include <attr.h>

#include <libcmdutils.h>

#endif

#include <zone.h>

#include <tsol/label.h>

#include <sys/tsol/label_macro.h>

#include "getresponse.h"

#if !defined(O_XATTR)

#define AT_SYMLINK_NOFOLLOW 0x1000

#define AT_REMOVEDIR 0x1

#define AT_FDCWD 0xffd19553

#define _XATTR_HDRTYPE 'E'

static int attropen();

static int fstatat();

static int renameat();

static int unlinkat();

static int openat();

static int fchownat();

static int futimesat();

#endif

int utimes(const char *path, const struct timeval timeval_ptr[]);

#ifndef MINSIZE

#define MINSIZE 250

#endif

#define DEF_FILE "/etc/default/tar"

#define min(a, b) ((a) < (b) ? (a) : (b))

#define max(a, b) ((a) > (b) ? (a) : (b))

#ifdef DEBUG

#undef DEBUG

#define DEBUG(a, b, c)\

(void) fprintf(stderr, "DEBUG - "), (void) fprintf(stderr, a, b, c)

#endif

#define TBLOCK 512 /* tape block size--should be universal */

#ifdef BSIZE

#define SYS_BLOCK BSIZE /* from sys/param.h: secondary block size */

#else /* BSIZE */

#define SYS_BLOCK 512 /* default if no BSIZE in param.h */

#endif /* BSIZE */

#define NBLOCK 20

#define NAMSIZ 100

#define PRESIZ 155

#define MAXNAM 256

#define MODEMASK 0777777 /* file creation mode mask */

#define POSIXMODES 07777 /* mask for POSIX mode bits */

#define MAXEXT 9 /* reasonable max # extents for a file */

#define EXTMIN 50 /* min blks left on floppy to split a file */

#define TAR_EFSIZE_MAX 0777777777

#ifdef XHDR_DEBUG

#define TAR_OFFSET_MAX 9

#define OCTAL7CHAR 2

#else

#define TAR_OFFSET_MAX 077777777777ULL

#define OCTAL7CHAR 07777777

#endif

#define TBLOCKS(bytes) (((bytes) + TBLOCK - 1) / TBLOCK)

#define K(tblocks) ((tblocks+1)/2) /* tblocks to Kbytes for printing */

#define MAXLEV (PATH_MAX / 2)

#define LEV0 1

#define SYMLINK_LEV0 0

#define TRUE 1

#define FALSE 0

#define XATTR_FILE 1

#define NORMAL_FILE 0

#define PUT_AS_LINK 1

#define PUT_NOTAS_LINK 0

#ifndef VIEW_READONLY

#define VIEW_READONLY "SUNWattr_ro"

#endif

#ifndef VIEW_READWRITE

#define VIEW_READWRITE "SUNWattr_rw"

#endif

#if _FILE_OFFSET_BITS == 64

#define FMT_off_t "lld"

#define FMT_off_t_o "llo"

#define FMT_blkcnt_t "lld"

#else

#define FMT_off_t "ld"

#define FMT_off_t_o "lo"

#define FMT_blkcnt_t "ld"

#endif

struct sec_attr {

char attr_type;

char attr_len[7];

char attr_info[1];

} *attr;

#if defined(O_XATTR)

typedef enum {

ATTR_OK,

ATTR_SKIP,

ATTR_CHDIR_ERR,

ATTR_OPEN_ERR,

ATTR_XATTR_ERR,

ATTR_SATTR_ERR

} attr_status_t;

#endif

#if defined(O_XATTR)

typedef enum {

ARC_CREATE,

ARC_RESTORE

} arc_action_t;

#endif

typedef struct attr_data {

char *attr_parent;

char *attr_path;

int attr_parentfd;

int attr_rw_sysattr;

} attr_data_t;

static struct xattr_hdr *xattrhead;

static struct xattr_buf *xattrp;

static struct xattr_buf *xattr_linkp; /* pointer to link info, if any */

static char *xattrapath; /* attribute name */

static char *xattr_linkaname; /* attribute attribute is linked to */

static char Hiddendir; /* are we processing hidden xattr dir */

static char xattrbadhead;

union hblock {

char dummy[TBLOCK];

struct header {

char name[NAMSIZ]; /* If non-null prefix, path is */

/* <prefix>/<name>; otherwise */

/* <name> */

char mode[8];

char uid[8];

char gid[8];

char size[12]; /* size of this extent if file split */

char mtime[12];

char chksum[8];

char typeflag;

char linkname[NAMSIZ];

char magic[6];

char version[2];

char uname[32];

char gname[32];

char devmajor[8];

char devminor[8];

char prefix[PRESIZ]; /* Together with "name", the path of */

/* the file: <prefix>/<name> */

char extno; /* extent #, null if not split */

char extotal; /* total extents */

char efsize[10]; /* size of entire file */

} dbuf;

} dblock, *tbuf, xhdr_buf;

struct xtar_hdr {

uid_t x_uid, /* Uid of file */

x_gid; /* Gid of file */

major_t x_devmajor; /* Device major node */

minor_t x_devminor; /* Device minor node */

off_t x_filesz; /* Length of file */

char *x_uname, /* Pointer to name of user */

*x_gname, /* Pointer to gid of user */

*x_linkpath, /* Path for a hard/symbolic link */

*x_path; /* Path of file */

timestruc_t x_mtime; /* Seconds and nanoseconds */

} Xtarhdr;

struct gen_hdr {

ulong_t g_mode; /* Mode of file */

uid_t g_uid, /* Uid of file */

g_gid; /* Gid of file */

off_t g_filesz; /* Length of file */

time_t g_mtime; /* Modification time */

uint_t g_cksum; /* Checksum of file */

ulong_t g_devmajor, /* File system of file */

g_devminor; /* Major/minor of special files */

} Gen;

struct linkbuf {

ino_t inum;

dev_t devnum;

int count;

char pathname[MAXNAM+1]; /* added 1 for last NULL */

char attrname[MAXNAM+1];

struct linkbuf *nextp;

} *ihead;

#define TABLE_SIZE 512

typedef struct file_list {

char *name; /* Name of file to {in,ex}clude */

struct file_list *next; /* Linked list */

} file_list_t;

static file_list_t *exclude_tbl[TABLE_SIZE],

*include_tbl[TABLE_SIZE];

static int append_secattr(char **, int *, int, char *, char);

static void write_ancillary(union hblock *, char *, int, char);

static void add_file_to_table(file_list_t *table[], char *str);

static void assert_string(char *s, char *msg);

static int istape(int fd, int type);

static void backtape(void);

static void build_table(file_list_t *table[], char *file);

static int check_prefix(char **namep, char **dirp, char **compp);

static void closevol(void);

static void copy(void *dst, void *src);

static int convtoreg(off_t);

static void delete_target(int fd, char *comp, char *namep);

static void doDirTimes(char *name, timestruc_t modTime);

static void done(int n);

static void dorep(char *argv[]);

#ifdef _iBCS2

static void dotable(char *argv[], int cnt);

static void doxtract(char *argv[], int cnt);

#else

static void dotable(char *argv[]);

static void doxtract(char *argv[]);

#endif

static void fatal(char *format, ...);

static void vperror(int exit_status, char *fmt, ...);

static void flushtape(void);

static void getdir(void);

static void *getmem(size_t);

static void longt(struct stat *st, char aclchar);

static void load_info_from_xtarhdr(u_longlong_t flag, struct xtar_hdr *xhdrp);

static int makeDir(char *name);

static void mterr(char *operation, int i, int exitcode);

static void newvol(void);

static void passtape(void);

static void putempty(blkcnt_t n);

static int putfile(char *longname, char *shortname, char *parent,

attr_data_t *attrinfo, int filetype, int lev, int symlink_lev);

static void readtape(char *buffer);

static void seekdisk(blkcnt_t blocks);

static void setPathTimes(int dirfd, char *path, timestruc_t modTime);

static void setbytes_to_skip(struct stat *st, int err);

static void splitfile(char *longname, int ifd, char *name,

char *prefix, int filetype);

static void tomodes(struct stat *sp);

static void usage(void);

static int xblocks(int issysattr, off_t bytes, int ofile);

static int xsfile(int issysattr, int ofd);

static void resugname(int dirfd, char *name, int symflag);

static int bcheck(char *bstr);

static int checkdir(char *name);

static int checksum(union hblock *dblockp);

#ifdef EUC

static int checksum_signed(union hblock *dblockp);

#endif /* EUC */

static int checkupdate(char *arg);

static int checkw(char c, char *name);

static int cmp(char *b, char *s, int n);

static int defset(char *arch);

static int endtape(void);

static int is_in_table(file_list_t *table[], char *str);

static int notsame(void);

static int is_prefix(char *s1, char *s2);

static int response(void);

static int build_dblock(const char *, const char *, const char,

const int filetype, const struct stat *, const dev_t, const char *);

static unsigned int hash(char *str);

#ifdef _iBCS2

static void initarg(char *argv[], char *file);

static char *nextarg();

#endif

static blkcnt_t kcheck(char *kstr);

static off_t bsrch(char *s, int n, off_t l, off_t h);

static void onintr(int sig);

static void onquit(int sig);

static void onhup(int sig);

static uid_t getuidbyname(char *);

static gid_t getgidbyname(char *);

static char *getname(gid_t);

static char *getgroup(gid_t);

static int checkf(char *name, int mode, int howmuch);

static int writetbuf(char *buffer, int n);

static int wantit(char *argv[], char **namep, char **dirp, char **comp,

attr_data_t **attrinfo);

static void append_ext_attr(char *shortname, char **secinfo, int *len);

static int get_xdata(void);

static void gen_num(const char *keyword, const u_longlong_t number);

static void gen_date(const char *keyword, const timestruc_t time_value);

static void gen_string(const char *keyword, const char *value);

static void get_xtime(char *value, timestruc_t *xtime);

static int chk_path_build(char *name, char *longname, char *linkname,

char *prefix, char type, int filetype);

static int gen_utf8_names(const char *filename);

static int utf8_local(char *option, char **Xhdr_ptrptr, char *target,

const char *src, int max_val);

static int local_utf8(char **Xhdr_ptrptr, char *target, const char *src,

iconv_t iconv_cd, int xhdrflg, int max_val);

static int c_utf8(char *target, const char *source);

static int getstat(int dirfd, char *longname, char *shortname,

char *attrparent);

static void xattrs_put(char *, char *, char *, char *);

static void prepare_xattr(char **, char *, char *,

char, struct linkbuf *, int *);

static int put_link(char *name, char *longname, char *component,

char *longattrname, char *prefix, int filetype, char typeflag);

static int put_extra_attributes(char *longname, char *shortname,

char *longattrname, char *prefix, int filetype, char typeflag);

static int put_xattr_hdr(char *longname, char *shortname, char *longattrname,

char *prefix, int typeflag, int filetype, struct linkbuf *lp);

static int read_xattr_hdr(attr_data_t **attrinfo);

#define AUTO_ZONE "/zone"

static void extract_attr(char **file_ptr, struct sec_attr *);

static int check_ext_attr(char *filename);

static void rebuild_comp_path(char *str, char **namep);

static int rebuild_lk_comp_path(char *str, char **namep);

static void get_parent(char *path, char *dir);

static char *get_component(char *path);

static int retry_open_attr(int pdirfd, int cwd, char *dirp, char *pattr,

char *name, int oflag, mode_t mode);

static char *skipslashes(char *string, char *start);

static void chop_endslashes(char *path);

static struct stat stbuf;

static char *myname;

static int checkflag = 0;

#ifdef _iBCS2

static int Fileflag;

char *sysv3_env;

#endif

static int Xflag, Fflag, iflag, hflag, Bflag, Iflag;

static int rflag, xflag, vflag, tflag, mt, cflag, mflag, pflag;

static int uflag;

static int eflag, errflag, qflag;

static int oflag;

static int bflag, kflag, Aflag;

static int Pflag; /* POSIX conformant archive */

static int Eflag; /* Allow files greater than 8GB */

static int atflag; /* traverse extended attributes */

static int saflag; /* traverse extended sys attributes */

static int Dflag; /* Data change flag */

static int Tflag; /* Trusted Extensions attr flags */

static int dir_flag; /* for attribute extract */

static int mld_flag; /* for attribute extract */

static char *orig_namep; /* original namep - unadorned */

static int rpath_flag; /* MLD real path is rebuilt */

static char real_path[MAXPATHLEN]; /* MLD real path */

static int lk_rpath_flag; /* linked to real path is rebuilt */

static char lk_real_path[MAXPATHLEN]; /* linked real path */

static bslabel_t bs_label; /* for attribute extract */

static bslabel_t admin_low;

static bslabel_t admin_high;

static int ignored_aprivs = 0;

static int ignored_fprivs = 0;

static int ignored_fattrs = 0;

static int term, chksum, wflag,

first = TRUE, defaults_used = FALSE, linkerrok;

static blkcnt_t recno;

static int freemem = 1;

static int nblock = NBLOCK;

static int Errflg = 0;

static int exitflag = 0;

static dev_t mt_dev; /* device containing output file */

static ino_t mt_ino; /* inode number of output file */

static int mt_devtype; /* dev type of archive, from stat structure */

static int update = 1; /* for `open' call */

static off_t low;

static off_t high;

static FILE *tfile;

static FILE *vfile = stdout;

static char tname[] = "/tmp/tarXXXXXX";

static char archive[] = "archive0=";

static char *Xfile;

static char *usefile;

static char *Filefile;

static int mulvol; /* multi-volume option selected */

static blkcnt_t blocklim; /* number of blocks to accept per volume */

static blkcnt_t tapepos; /* current block number to be written */

static int NotTape; /* true if tape is a disk */

static int dumping; /* true if writing a tape or other archive */

static int extno; /* number of extent: starts at 1 */

static int extotal; /* total extents in this file */

static off_t extsize; /* size of current extent during extraction */

static ushort_t Oumask = 0; /* old umask value */

static int is_posix; /* true if archive we're reading is POSIX-conformant */

static const char *magic_type = "ustar";

static size_t xrec_size = 8 * PATH_MAX; /* extended rec initial size */

static char *xrec_ptr;

static off_t xrec_offset = 0;

static int Xhdrflag;

static int charset_type = 0;

static u_longlong_t xhdr_flgs; /* Bits set determine which items */

/* need to be in extended header. */

#define _X_DEVMAJOR 0x1

#define _X_DEVMINOR 0x2

#define _X_GID 0x4

#define _X_GNAME 0x8

#define _X_LINKPATH 0x10

#define _X_PATH 0x20

#define _X_SIZE 0x40

#define _X_UID 0x80

#define _X_UNAME 0x100

#define _X_ATIME 0x200

#define _X_CTIME 0x400

#define _X_MTIME 0x800

#define _X_XHDR 0x1000 /* Bit flag that determines whether 'X' */

/* typeflag was followed by 'A' or non 'A' */

/* typeflag. */

#define _X_LAST 0x40000000

#define PID_MAX_DIGITS (10 * sizeof (pid_t) / 4)

#define TIME_MAX_DIGITS (10 * sizeof (time_t) / 4)

#define LONG_MAX_DIGITS (10 * sizeof (long) / 4)

#define ULONGLONG_MAX_DIGITS (10 * sizeof (u_longlong_t) / 4)

#define UTF_8_FACTOR 6

static u_longlong_t xhdr_count = 0;

static char xhdr_dirname[PRESIZ + 1];

static char pidchars[PID_MAX_DIGITS + 1];

static char *tchar = ""; /* null linkpath */

static char local_path[UTF_8_FACTOR * PATH_MAX + 1];

static char local_linkpath[UTF_8_FACTOR * PATH_MAX + 1];

static char local_gname[UTF_8_FACTOR * _POSIX_NAME_MAX + 1];

static char local_uname[UTF_8_FACTOR * _POSIX_NAME_MAX + 1];

#ifdef WAITAROUND

int waitaround = 0; /* wait for rendezvous with the debugger */

#endif

main(int argc, char *argv[])

{

char *cp;

char *tmpdirp;

pid_t thispid;

#ifdef _iBCS2

int tbl_cnt = 0;

sysv3_env = getenv("SYSV3");

#endif

(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */

#define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */

#endif

(void) textdomain(TEXT_DOMAIN);

if (argc < 2)

usage();

tfile = NULL;

if ((myname = strdup(argv[0])) == NULL) {

(void) fprintf(stderr, gettext(

"tar: cannot allocate program name\n"));

exit(1);

}

if (init_yes() < 0) {

(void) fprintf(stderr, gettext(ERR_MSG_INIT_YES),

strerror(errno));

exit(2);

}

/*

if (strcmp(argv[1], "--") == 0) {

argv++;

argc--;

if (argc < 3)

usage();

}

argv[argc] = NULL;

argv++;

/*

if ((usefile = getenv("TAPE")) == (char *)NULL) {

for (cp = *argv; *cp; ++cp)

if (isdigit(*cp) || *cp == 'f')

break;

if (*cp != 'f') {

archive[7] = (*cp)? *cp: '0';

if (!(defaults_used = defset(archive))) {

usefile = NULL;

nblock = 1;

blocklim = 0;

NotTape = 0;

}

}

}

for (cp = *argv++; *cp; cp++)

switch (*cp) {

#ifdef WAITAROUND

case 'z':

/* rendezvous with the debugger */

waitaround = 1;

break;

#endif

case 'f':

assert_string(*argv, gettext(

"tar: tarfile must be specified with 'f' "

"function modifier\n"));

usefile = *argv++;

break;

case 'F':

#ifdef _iBCS2

if (sysv3_env) {

assert_string(*argv, gettext(

"tar: 'F' requires a file name\n"));

Filefile = *argv++;

Fileflag++;

} else

#endif /* _iBCS2 */

Fflag++;

break;

case 'c':

cflag++;

rflag++;

update = 1;

break;

#if defined(O_XATTR)

case '@':

atflag++;

break;

#endif /* O_XATTR */

#if defined(_PC_SATTR_ENABLED)

case '/':

saflag++;

break;

#endif /* _PC_SATTR_ENABLED */

case 'u':

uflag++; /* moved code after signals caught */

rflag++;

update = 2;

break;

case 'r':

rflag++;

update = 2;

break;

case 'v':

vflag++;

break;

case 'w':

wflag++;

break;

case 'x':

xflag++;

break;

case 'X':

assert_string(*argv, gettext(

"tar: exclude file must be specified with 'X' "

"function modifier\n"));

Xflag = 1;

Xfile = *argv++;

build_table(exclude_tbl, Xfile);

break;

case 't':

tflag++;

break;

case 'm':

mflag++;

break;

case 'p':

pflag++;

break;

case 'D':

Dflag++;

break;

case '-':

/* ignore this silently */

break;

case '0': /* numeric entries used only for defaults */

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

break;

case 'b':

assert_string(*argv, gettext(

"tar: blocking factor must be specified "

"with 'b' function modifier\n"));

bflag++;

nblock = bcheck(*argv++);

break;

case 'q':

qflag++;

break;

case 'k':

assert_string(*argv, gettext(

"tar: size value must be specified with 'k' "

"function modifier\n"));

kflag++;

blocklim = kcheck(*argv++);

break;

case 'n': /* not a magtape (instead of 'k') */

NotTape++; /* assume non-magtape */

break;

case 'l':

linkerrok++;

break;

case 'e':

#ifdef _iBCS2

/* If sysv3 IS set, don't be as verbose */

if (!sysv3_env)

#endif /* _iBCS2 */

errflag++;

eflag++;

break;

case 'o':

oflag++;

break;

case 'h':

hflag++;

break;

case 'i':

iflag++;

break;

case 'B':

Bflag++;

break;

case 'P':

Pflag++;

break;

case 'E':

Eflag++;

Pflag++; /* Only POSIX archive made */

break;

case 'T':

Tflag++; /* Handle Trusted Extensions attrs */

pflag++; /* also set flag for ACL */

break;

default:

(void) fprintf(stderr, gettext(

"tar: %c: unknown function modifier\n"), *cp);

usage();

}

#ifdef _iBCS2

if (Xflag && Fileflag) {

(void) fprintf(stderr, gettext(

"tar: specify only one of X or F.\n"));

usage();

}

#endif /* _iBCS2 */

if (!rflag && !xflag && !tflag)

usage();

if ((rflag && xflag) || (xflag && tflag) || (rflag && tflag)) {

(void) fprintf(stderr, gettext(

"tar: specify only one of [ctxru].\n"));

usage();

}

/* Trusted Extensions attribute handling */

if (Tflag && ((getzoneid() != GLOBAL_ZONEID) ||

!is_system_labeled())) {

(void) fprintf(stderr, gettext(

"tar: the 'T' option is only available with "

"Trusted Extensions\nand must be run from "

"the global zone.\n"));

usage();

}

if (cflag && *argv == NULL && Filefile == NULL)

fatal(gettext("Missing filenames"));

if (usefile == NULL)

fatal(gettext("device argument required"));

/* alloc a buffer of the right size */

if ((tbuf = (union hblock *)

calloc(sizeof (union hblock) * nblock, sizeof (char))) ==

(union hblock *)NULL) {

(void) fprintf(stderr, gettext(

"tar: cannot allocate physio buffer\n"));

exit(1);

}

if ((xrec_ptr = malloc(xrec_size)) == NULL) {

(void) fprintf(stderr, gettext(

"tar: cannot allocate extended header buffer\n"));

exit(1);

}

#ifdef WAITAROUND

if (waitaround) {

(void) fprintf(stderr, gettext("Rendezvous with tar on pid"

" %d\n"), getpid());

while (waitaround) {

(void) sleep(10);

}

}

#endif

thispid = getpid();

(void) sprintf(pidchars, "%ld", thispid);

thispid = strlen(pidchars);

if ((tmpdirp = getenv("TMPDIR")) == (char *)NULL)

(void) strcpy(xhdr_dirname, "/tmp");

else {

/*

if (strlen(tmpdirp) > (size_t)(PRESIZ - thispid - 12)) {

(void) strcpy(xhdr_dirname, "/tmp");

if ((vflag > 0) && (Eflag > 0))

(void) fprintf(stderr, gettext(

"Ignoring TMPDIR\n"));

} else

(void) strcpy(xhdr_dirname, tmpdirp);

}

(void) strcat(xhdr_dirname, "/PaxHeaders.");

(void) strcat(xhdr_dirname, pidchars);

if (rflag) {

if (cflag && tfile != NULL)

usage();

if (signal(SIGINT, SIG_IGN) != SIG_IGN)

(void) signal(SIGINT, onintr);

if (signal(SIGHUP, SIG_IGN) != SIG_IGN)

(void) signal(SIGHUP, onhup);

if (signal(SIGQUIT, SIG_IGN) != SIG_IGN)

(void) signal(SIGQUIT, onquit);

if (uflag) {

int tnum;

if ((tnum = mkstemp(tname)) == -1)

vperror(1, "%s", tname);

if ((tfile = fdopen(tnum, "w")) == NULL)

vperror(1, "%s", tname);

}

if (strcmp(usefile, "-") == 0) {

if (cflag == 0)

fatal(gettext(

"can only create standard output archives."));

vfile = stderr;

mt = dup(1);

++bflag;

} else {

if (cflag)

mt = open(usefile,

O_RDWR|O_CREAT|O_TRUNC, 0666);

else

mt = open(usefile, O_RDWR);

if (mt < 0) {

if (cflag == 0 || (mt = creat(usefile, 0666))

< 0)

vperror(1, "%s", usefile);

}

}

/* Get inode and device number of output file */

(void) fstat(mt, &stbuf);

mt_ino = stbuf.st_ino;

mt_dev = stbuf.st_dev;

mt_devtype = stbuf.st_mode & S_IFMT;

NotTape = !istape(mt, mt_devtype);

if (rflag && !cflag && (mt_devtype == S_IFIFO))

fatal(gettext("cannot append to pipe or FIFO."));

if (Aflag && vflag)

(void) printf(

gettext("Suppressing absolute pathnames\n"));

dorep(argv);

} else if (xflag || tflag) {

/*

for (argc = 0; argv[argc]; argc++) {

if (strcmp(argv[argc], "-I") == 0) {

if (!argv[argc+1]) {

(void) fprintf(stderr, gettext(

"tar: missing argument for -I flag\n"));

done(2);

} else {

Iflag = 1;

argv[argc] = argv[argc+2];

build_table(include_tbl, argv[++argc]);

#ifdef _iBCS2

if (Fileflag) {

(void) fprintf(stderr, gettext(

"tar: only one of I or F.\n"));

usage();

}

#endif /* _iBCS2 */

}

}

}

if (strcmp(usefile, "-") == 0) {

mt = dup(0);

++bflag;

/* try to recover from short reads when reading stdin */

++Bflag;

} else if ((mt = open(usefile, 0)) < 0)

vperror(1, "%s", usefile);

if (xflag) {

if (Aflag && vflag)

(void) printf(gettext(

"Suppressing absolute pathnames.\n"));

#ifdef _iBCS2

doxtract(argv, tbl_cnt);

#else

doxtract(argv);

#endif

} else if (tflag)

#ifdef _iBCS2

dotable(argv, tbl_cnt);

#else

dotable(argv);

#endif

}

else

usage();

done(Errflg);

/* Not reached: keep compiler quiet */

return (1);

}

static void

usage(void)

{

#ifdef _iBCS2

if (sysv3_env) {

(void) fprintf(stderr, gettext(

#if defined(O_XATTR)

#if defined(_PC_SATTR_ENABLED)

"Usage: tar {c|r|t|u|x}[BDeEhilmnopPqTvw@/[0-7]][bfFk][X...] "

#else

"Usage: tar {c|r|t|u|x}[BDeEhilmnopPqTvw@[0-7]][bfFk][X...] "

#endif /* _PC_SATTR_ENABLED */

#else

"Usage: tar {c|r|t|u|x}[BDeEhilmnopPqTvw[0-7]][bfFk][X...] "

#endif /* O_XATTR */

"[blocksize] [tarfile] [filename] [size] [exclude-file...] "

"{file | -I include-file | -C directory file}...\n"));

} else

#endif /* _iBCS2 */

{

(void) fprintf(stderr, gettext(

#if defined(O_XATTR)

#if defined(_PC_SATTR_ENABLED)

"Usage: tar {c|r|t|u|x}[BDeEFhilmnopPqTvw@/[0-7]][bfk][X...] "

#else

"Usage: tar {c|r|t|u|x}[BDeEFhilmnopPqTvw@[0-7]][bfk][X...] "

#endif /* _PC_SATTR_ENABLED */

#else

"Usage: tar {c|r|t|u|x}[BDeEFhilmnopPqTvw[0-7]][bfk][X...] "

#endif /* O_XATTR */

"[blocksize] [tarfile] [size] [exclude-file...] "

"{file | -I include-file | -C directory file}...\n"));

}

done(1);

}

static void

dorep(char *argv[])

{

char *cp, *cp2, *p;

char wdir[PATH_MAX+2], tempdir[PATH_MAX+2], *parent;

char file[PATH_MAX*2], origdir[PATH_MAX+1];

FILE *fp = (FILE *)NULL;

FILE *ff = (FILE *)NULL;

int archtype;

int ret;

if (!cflag) {

xhdr_flgs = 0;

getdir(); /* read header for next file */

if (Xhdrflag > 0) {

if (!Eflag)

fatal(gettext("Archive contains extended"

" header. -E flag required.\n"));

ret = get_xdata(); /* Get extended header items */

/* and regular header */

} else {

if (Eflag)

fatal(gettext("Archive contains no extended"

" header. -E flag not allowed.\n"));

}

while (!endtape()) { /* changed from a do while */

setbytes_to_skip(&stbuf, ret);

passtape(); /* skip the file data */

if (term)

done(Errflg); /* received signal to stop */

xhdr_flgs = 0;

getdir();

if (Xhdrflag > 0)

ret = get_xdata();

}

if (ret == 0) {

if ((dblock.dbuf.typeflag != 'A') &&

(xhdr_flgs != 0)) {

load_info_from_xtarhdr(xhdr_flgs,

&Xtarhdr);

xhdr_flgs |= _X_XHDR;

}

}

backtape(); /* was called by endtape */

if (tfile != NULL) {

char buf[200];

(void) sprintf(buf, "sort +0 -1 +1nr %s -o %s; awk '$1 "

"!= prev {print; prev=$1}' %s >%sX;mv %sX %s",

tname, tname, tname, tname, tname, tname);

(void) fflush(tfile);

(void) system(buf);

(void) freopen(tname, "r", tfile);

(void) fstat(fileno(tfile), &stbuf);

high = stbuf.st_size;

}

}

dumping = 1;

if (mulvol) { /* SP-1 */

if (nblock && (blocklim%nblock) != 0)

fatal(gettext(

"Volume size not a multiple of block size."));

blocklim -= 2; /* for trailer records */

if (vflag)

(void) fprintf(vfile, gettext("Volume ends at %"

FMT_blkcnt_t "K, blocking factor = %dK\n"),

K((blocklim - 1)), K(nblock));

}

#ifdef _iBCS2

if (Fileflag) {

if (Filefile != NULL) {

if ((ff = fopen(Filefile, "r")) == NULL)

vperror(0, "%s", Filefile);

} else {

(void) fprintf(stderr, gettext(

"tar: F requires a file name.\n"));

usage();

}

}

#endif /* _iBCS2 */

/*

if (getcwd(origdir, (PATH_MAX+1)) == NULL) {

vperror(0, gettext("A parent directory cannot be read"));

exit(1);

}

(void) strcpy(wdir, origdir);

while ((*argv || fp || ff) && !term) {

if (fp || (strcmp(*argv, "-I") == 0)) {

#ifdef _iBCS2

if (Fileflag) {

(void) fprintf(stderr, gettext(

"tar: only one of I or F.\n"));

usage();

}

#endif /* _iBCS2 */

if (fp == NULL) {

if (*++argv == NULL)

fatal(gettext(

"missing file name for -I flag."));

else if ((fp = fopen(*argv++, "r")) == NULL)

vperror(0, "%s", argv[-1]);

continue;

} else if ((fgets(file, PATH_MAX-1, fp)) == NULL) {

(void) fclose(fp);

fp = NULL;

continue;

} else {

cp = cp2 = file;

if ((p = strchr(cp2, '\n')))

*p = 0;

}

} else if ((strcmp(*argv, "-C") == 0) && argv[1]) {

#ifdef _iBCS2

if (Fileflag) {

(void) fprintf(stderr, gettext(

"tar: only one of F or C\n"));

usage();

}

#endif /* _iBCS2 */

if (chdir(*++argv) < 0)

vperror(0, gettext(

"can't change directories to %s"), *argv);

else

(void) getcwd(wdir, (sizeof (wdir)));

argv++;

continue;

#ifdef _iBCS2

} else if (Fileflag && (ff != NULL)) {

if ((fgets(file, PATH_MAX-1, ff)) == NULL) {

(void) fclose(ff);

ff = NULL;

continue;

} else {

cp = cp2 = file;

if (p = strchr(cp2, '\n'))

*p = 0;

}

#endif /* _iBCS2 */

} else

cp = cp2 = strcpy(file, *argv++);

/*

for (; *cp; cp++) {

if (*cp == '/') {

while (*(cp+1) == '/') {

++cp;

}

if (*(cp+1) != '\0') {

/* not trailing slash */

cp2 = cp;

}

}

}

if (cp2 != file) {

*cp2 = '\0';

if (chdir(file) < 0) {

vperror(0, gettext(

"can't change directories to %s"), file);

continue;

}

*cp2 = '/';

cp2++;

}

parent = getcwd(tempdir, (sizeof (tempdir)));

archtype = putfile(file, cp2, parent, NULL, NORMAL_FILE,

LEV0, SYMLINK_LEV0);

#if defined(O_XATTR)

if (!exitflag) {

if ((atflag || saflag) &&

(archtype == PUT_NOTAS_LINK)) {

xattrs_put(file, cp2, parent, NULL);

}

}

#endif

if (chdir(origdir) < 0)

vperror(0, gettext("cannot change back?: %s"), origdir);

if (exitflag) {

/*

break;

}

}

putempty((blkcnt_t)2);

flushtape();

closevol(); /* SP-1 */

if (linkerrok == 1)

for (; ihead != NULL; ihead = ihead->nextp) {

if (ihead->count == 0)

continue;

(void) fprintf(stderr, gettext(

"tar: missing links to %s\n"), ihead->pathname);

if (errflag)

done(1);

else

Errflg = 1;

}

}

static int

endtape(void)

{

if (dblock.dbuf.name[0] == '\0') { /* null header = EOT */

return (1);

} else

return (0);

}

static void

getdir(void)

{

struct stat *sp;

#ifdef EUC

static int warn_chksum_sign = 0;

#endif /* EUC */

top:

readtape((char *)&dblock);

if (dblock.dbuf.name[0] == '\0')

return;

sp = &stbuf;

(void) sscanf(dblock.dbuf.mode, "%8lo", &Gen.g_mode);

(void) sscanf(dblock.dbuf.uid, "%8lo", (ulong_t *)&Gen.g_uid);

(void) sscanf(dblock.dbuf.gid, "%8lo", (ulong_t *)&Gen.g_gid);

(void) sscanf(dblock.dbuf.size, "%12" FMT_off_t_o, &Gen.g_filesz);

(void) sscanf(dblock.dbuf.mtime, "%12lo", (ulong_t *)&Gen.g_mtime);

(void) sscanf(dblock.dbuf.chksum, "%8o", &Gen.g_cksum);

(void) sscanf(dblock.dbuf.devmajor, "%8lo", &Gen.g_devmajor);

(void) sscanf(dblock.dbuf.devminor, "%8lo", &Gen.g_devminor);

is_posix = (strcmp(dblock.dbuf.magic, magic_type) == 0);

sp->st_mode = Gen.g_mode;

if (is_posix && (sp->st_mode & S_IFMT) == 0)

switch (dblock.dbuf.typeflag) {

case '0': case 0: case _XATTR_HDRTYPE:

sp->st_mode |= S_IFREG;

break;

case '1': /* hard link */

break;

case '2':

sp->st_mode |= S_IFLNK;

break;

case '3':

sp->st_mode |= S_IFCHR;

break;

case '4':

sp->st_mode |= S_IFBLK;

break;

case '5':

sp->st_mode |= S_IFDIR;

break;

case '6':

sp->st_mode |= S_IFIFO;

break;

default:

if (convtoreg(Gen.g_filesz))

sp->st_mode |= S_IFREG;

break;

}

if (dblock.dbuf.typeflag == 'X')

Xhdrflag = 1; /* Currently processing extended header */

else

Xhdrflag = 0;

sp->st_uid = Gen.g_uid;

sp->st_gid = Gen.g_gid;

sp->st_size = Gen.g_filesz;

sp->st_mtime = Gen.g_mtime;

chksum = Gen.g_cksum;

if (dblock.dbuf.extno != '\0') { /* split file? */

extno = dblock.dbuf.extno;

extsize = Gen.g_filesz;

extotal = dblock.dbuf.extotal;

} else {

extno = 0; /* tell others file not split */

extsize = 0;

extotal = 0;

}

#ifdef EUC

if (chksum != checksum(&dblock)) {

if (chksum != checksum_signed(&dblock)) {

(void) fprintf(stderr, gettext(

"tar: directory checksum error\n"));

if (iflag)

goto top;

done(2);

} else {

if (! warn_chksum_sign) {

warn_chksum_sign = 1;

(void) fprintf(stderr, gettext(

"tar: warning: tar file made with signed checksum\n"));

}

}

}

#else

if (chksum != checksum(&dblock)) {

(void) fprintf(stderr, gettext(

"tar: directory checksum error\n"));

if (iflag)

goto top;

done(2);

}

#endif /* EUC */

if (tfile != NULL && Xhdrflag == 0) {

/*

if ((xhdr_flgs & _X_MTIME))

sp->st_mtim.tv_nsec = Xtarhdr.x_mtime.tv_nsec;

else

sp->st_mtim.tv_nsec = -1;

if (xhdr_flgs & _X_PATH)

(void) fprintf(tfile, "%s %10ld.%9.9ld\n",

Xtarhdr.x_path, sp->st_mtim.tv_sec,

sp->st_mtim.tv_nsec);

else

(void) fprintf(tfile, "%.*s %10ld.%9.9ld\n",

NAMSIZ, dblock.dbuf.name, sp->st_mtim.tv_sec,

sp->st_mtim.tv_nsec);

}

#if defined(O_XATTR)

Hiddendir = 0;

if (xattrp && dblock.dbuf.typeflag == _XATTR_HDRTYPE) {

if (xattrbadhead) {

free(xattrhead);

xattrp = NULL;

xattr_linkp = NULL;

xattrhead = NULL;

} else {

char *aname = basename(xattrapath);

size_t xindex = aname - xattrapath;

if (xattrapath[xindex] == '.' &&

xattrapath[xindex + 1] == '\0' &&

xattrp->h_typeflag == '5') {

Hiddendir = 1;

sp->st_mode =

(S_IFDIR | (sp->st_mode & POSIXMODES));

}

dblock.dbuf.typeflag = xattrp->h_typeflag;

}

}

#endif

}

static void

passtape(void)

{

blkcnt_t blocks;

char buf[TBLOCK];

/*

if (dblock.dbuf.typeflag == '1' || dblock.dbuf.typeflag == '2' ||

dblock.dbuf.typeflag == '3' || dblock.dbuf.typeflag == '4' ||

dblock.dbuf.typeflag == '5' || dblock.dbuf.typeflag == '6')

return;

blocks = TBLOCKS(stbuf.st_size);

/* if operating on disk, seek instead of reading */

if (NotTape)

seekdisk(blocks);

else

while (blocks-- > 0)

readtape(buf);

}

#if defined(O_XATTR)

static int

is_sysattr(char *name)

{

return ((strcmp(name, VIEW_READONLY) == 0) ||

(strcmp(name, VIEW_READWRITE) == 0));

}

#endif

#if defined(O_XATTR)

static attr_status_t

verify_attr(char *attrname, char *attrparent, int arc_rwsysattr,

int *rw_sysattr)

{

#if defined(_PC_SATTR_ENABLED)

int attr_supported;

/* Never restore read-only system attribute files */

if ((attr_supported = sysattr_type(attrname)) == _RO_SATTR) {

*rw_sysattr = 0;

return (ATTR_SKIP);

} else {

*rw_sysattr = (attr_supported == _RW_SATTR);

}

#else

/*

if (*rw_sysattr = is_sysattr(attrname)) {

return (ATTR_SKIP);

} else {

return (ATTR_OK);

}

#endif /* _PC_SATTR_ENABLED */

/*

if (*rw_sysattr && !arc_rwsysattr) {

return (ATTR_SKIP);

}

/*

if (atflag) {

if (!saflag) {

/*

if (*rw_sysattr || (Hiddendir &&

(attrparent != NULL))) {

return (ATTR_SKIP);

}

}

} else if (saflag) {

/*

if (!*rw_sysattr || (attrparent != NULL)) {

return (ATTR_SKIP);

}

} else {

return (ATTR_SKIP);

}

return (ATTR_OK);

}

#endif

static void

free_children(file_list_t *children)

{

file_list_t *child = children;

file_list_t *cptr;

while (child != NULL) {

cptr = child->next;

if (child->name != NULL) {

free(child->name);

}

child = cptr;

}

}

static int

putfile(char *longname, char *shortname, char *parent, attr_data_t *attrinfo,

int filetype, int lev, int symlink_lev)

{

int infile = -1; /* deliberately invalid */

blkcnt_t blocks;

char buf[PATH_MAX + 2]; /* Add trailing slash and null */

char *bigbuf;

int maxread;

int hint; /* amount to write to get "in sync" */

char filetmp[PATH_MAX + 1];

char *cp;

char *name;

char *attrparent = NULL;

char *longattrname = NULL;

file_list_t *child = NULL;

file_list_t *child_end = NULL;

file_list_t *cptr;

struct dirent *dp;

DIR *dirp;

int i;

int split;

int dirfd = -1;

int rc = PUT_NOTAS_LINK;

int archtype = 0;

int rw_sysattr = 0;

char newparent[PATH_MAX + MAXNAMLEN + 1];

char *prefix = "";

char *tmpbuf;

char goodbuf[PRESIZ + 2];

char junkbuf[MAXNAM+1];

char *lastslash;

int j;

struct stat sbuf;

int readlink_max;

(void) memset(goodbuf, '\0', sizeof (goodbuf));

(void) memset(junkbuf, '\0', sizeof (junkbuf));

xhdr_flgs = 0;

if (filetype == XATTR_FILE) {

attrparent = attrinfo->attr_parent;

longattrname = attrinfo->attr_path;

dirfd = attrinfo->attr_parentfd;

rw_sysattr = attrinfo->attr_rw_sysattr;

} else {

dirfd = open(".", O_RDONLY);

}

if (dirfd == -1) {

(void) fprintf(stderr, gettext(

"tar: unable to open%sdirectory %s%s%s%s\n"),

(filetype == XATTR_FILE) ? gettext(" attribute ") : " ",

(attrparent == NULL) ? "" : gettext("of attribute "),

(attrparent == NULL) ? "" : attrparent,

(attrparent == NULL) ? "" : gettext(" of "),

(filetype == XATTR_FILE) ? longname : parent);

goto out;

}

if (lev > MAXLEV) {

(void) fprintf(stderr,

gettext("tar: directory nesting too deep, %s not dumped\n"),

longname);

goto out;

}

if (getstat(dirfd, longname, shortname, attrparent))

goto out;

if (hflag) {

/*

j = fstatat(dirfd, shortname, &sbuf, AT_SYMLINK_NOFOLLOW);

if (S_ISLNK(sbuf.st_mode)) {

if (symlink_lev++ >= MAXSYMLINKS) {

(void) fprintf(stderr, gettext(

"tar: %s: Number of symbolic links "

"encountered during path name traversal "

"exceeds MAXSYMLINKS\n"), longname);

Errflg = 1;

goto out;

}

}

}

/*

if ((mt_ino == stbuf.st_ino) && (mt_dev == stbuf.st_dev)) {

(void) fprintf(stderr, gettext(

"tar: %s%s%s%s%s same as archive file\n"),

rw_sysattr ? gettext("system ") : "",

(longattrname == NULL) ? "" : gettext("attribute "),

(longattrname == NULL) ? "" : longattrname,

(longattrname == NULL) ? "" : gettext(" of "),

longname);

Errflg = 1;

goto out;

}

/*

if ((stbuf.st_size > (off_t)TAR_OFFSET_MAX) &&

!S_ISDIR(stbuf.st_mode) &&

!S_ISCHR(stbuf.st_mode) &&

!S_ISBLK(stbuf.st_mode) &&

(Eflag == 0)) {

(void) fprintf(stderr, gettext(

"tar: %s%s%s%s%s too large to archive. "

"Use E function modifier.\n"),

rw_sysattr ? gettext("system ") : "",

(longattrname == NULL) ? "" : gettext("attribute "),

(longattrname == NULL) ? "" : longattrname,

(longattrname == NULL) ? "" : gettext(" of "),

longname);

if (errflag)

exitflag = 1;

Errflg = 1;

goto out;

}

if (tfile != NULL && checkupdate(longname) == 0) {

goto out;

}

if (checkw('r', longname) == 0) {

goto out;

}

if (Fflag && checkf(shortname, stbuf.st_mode, Fflag) == 0)

goto out;

if (Xflag) {

if (is_in_table(exclude_tbl, longname)) {

if (vflag) {

(void) fprintf(vfile, gettext(

"a %s excluded\n"), longname);

}

goto out;

}

}

/*

if ((((split = (int)strlen(longname)) > MAXNAM) && (Eflag == 0)) ||

(split > PATH_MAX)) {

(void) fprintf(stderr, gettext(

"tar: %s: file name too long\n"), longname);

if (errflag)

exitflag = 1;

Errflg = 1;

goto out;

}

/*

if ((split > NAMSIZ) ||

(split == NAMSIZ && strlen(shortname) < NAMSIZ) ||

(split == NAMSIZ && S_ISDIR(stbuf.st_mode) && !Pflag)) {

/*

(void) strncpy(&goodbuf[0], longname, min(split, PRESIZ + 1));

tmpbuf = goodbuf;

lastslash = strrchr(tmpbuf, '/');

if (lastslash == NULL) {

i = split; /* Length of name */

j = 0; /* Length of prefix */

goodbuf[0] = '\0';

} else {

*lastslash = '\0'; /* Terminate the prefix */

j = strlen(tmpbuf);

i = split - j - 1;

}

/*

if ((i > NAMSIZ) || (i == NAMSIZ && S_ISDIR(stbuf.st_mode) &&

!Pflag)) {

/* Determine which (filename or path) is too long. */

lastslash = strrchr(longname, '/');

if (lastslash != NULL)

i = strlen(lastslash + 1);

if (Eflag > 0) {

xhdr_flgs |= _X_PATH;

Xtarhdr.x_path = longname;

if (i <= NAMSIZ)

(void) strcpy(junkbuf, lastslash + 1);

else

(void) sprintf(junkbuf, "%llu",

xhdr_count + 1);

if (split - i - 1 > PRESIZ)

(void) strcpy(goodbuf, xhdr_dirname);

} else {

if ((i > NAMSIZ) || (i == NAMSIZ &&

S_ISDIR(stbuf.st_mode) && !Pflag))

(void) fprintf(stderr, gettext(

"tar: %s: filename is greater than "

"%d\n"), lastslash == NULL ?

longname : lastslash + 1, NAMSIZ);

else

(void) fprintf(stderr, gettext(

"tar: %s: prefix is greater than %d"

"\n"), longname, PRESIZ);

if (errflag)

exitflag = 1;

Errflg = 1;

goto out;

}

} else

(void) strncpy(&junkbuf[0], longname + j + 1,

strlen(longname + j + 1));

name = junkbuf;

prefix = goodbuf;

} else {

name = longname;

}

if (Aflag) {

if ((prefix != NULL) && (*prefix != '\0'))

while (*prefix == '/')

++prefix;

else

while (*name == '/')

++name;

}

switch (stbuf.st_mode & S_IFMT) {

case S_IFDIR:

stbuf.st_size = (off_t)0;

blocks = TBLOCKS(stbuf.st_size);

if (filetype != XATTR_FILE && Hiddendir == 0) {

i = 0;

cp = buf;

while ((*cp++ = longname[i++]))

;

*--cp = '/';

*++cp = 0;

}

if (!oflag) {

tomodes(&stbuf);

if (build_dblock(name, tchar, '5', filetype,

&stbuf, stbuf.st_dev, prefix) != 0) {

goto out;

}

if (!Pflag) {

/*

if (strlen(name) > (unsigned)NAMSIZ-1) {

(void) fprintf(stderr, gettext(

"tar: %s: filename is greater "

"than %d\n"), name, NAMSIZ);

if (errflag)

exitflag = 1;

Errflg = 1;

goto out;

} else {

if (strlen(name) == (NAMSIZ - 1)) {

(void) memcpy(dblock.dbuf.name,

name, NAMSIZ);

dblock.dbuf.name[NAMSIZ-1]

= '/';

} else

(void) sprintf(dblock.dbuf.name,

"%s/", name);

/*

(void) sprintf(dblock.dbuf.chksum,

"%07o", checksum(&dblock));

}

}

if (put_extra_attributes(longname, shortname,

longattrname, prefix, filetype, '5') != 0)

goto out;

#if defined(O_XATTR)

/*

if (filetype == XATTR_FILE) {

dblock.dbuf.typeflag = _XATTR_HDRTYPE;

} else {

dblock.dbuf.typeflag = '5';

}

#else

dblock.dbuf.typeflag = '5';

#endif

(void) sprintf(dblock.dbuf.chksum, "%07o",

checksum(&dblock));

(void) writetbuf((char *)&dblock, 1);

}

if (vflag) {

#ifdef DEBUG

if (NotTape)

DEBUG("seek = %" FMT_blkcnt_t "K\t", K(tapepos),

0);

#endif

if (filetype == XATTR_FILE && Hiddendir) {

(void) fprintf(vfile, "a %s attribute %s ",

longname, longattrname);

} else {

(void) fprintf(vfile, "a %s/ ", longname);

}

if (NotTape)

(void) fprintf(vfile, "%" FMT_blkcnt_t "K\n",

K(blocks));

else

(void) fprintf(vfile, gettext("%" FMT_blkcnt_t

" tape blocks\n"), blocks);

}

/*

if (filetype == XATTR_FILE)

break;

if (*shortname != '/')

(void) sprintf(newparent, "%s/%s", parent, shortname);

else

(void) sprintf(newparent, "%s", shortname);

if (chdir(shortname) < 0) {

vperror(0, "%s", newparent);

goto out;

}

if ((dirp = opendir(".")) == NULL) {

vperror(0, gettext(

"can't open directory %s"), longname);

if (chdir(parent) < 0)

vperror(0, gettext("cannot change back?: %s"),

parent);

goto out;

}

/*

while ((dp = readdir(dirp)) != NULL && !term) {

if ((strcmp(".", dp->d_name) == 0) ||

(strcmp("..", dp->d_name) == 0))

continue;

if (((cptr = (file_list_t *)calloc(sizeof (char),

sizeof (file_list_t))) == NULL) ||

((cptr->name = strdup(dp->d_name)) == NULL)) {

vperror(1, gettext(

"Insufficient memory for directory "

"list entry %s/%s\n"),

newparent, dp->d_name);

}

/* Add the file to the list */

if (child == NULL) {

child = cptr;

} else {

child_end->next = cptr;

}

child_end = cptr;

}

(void) closedir(dirp);

/*

while ((child != NULL) && !term) {

(void) strcpy(cp, child->name);

archtype = putfile(buf, cp, newparent, NULL,

NORMAL_FILE, lev + 1, symlink_lev);

if (!exitflag) {

if ((atflag || saflag) &&

(archtype == PUT_NOTAS_LINK)) {

xattrs_put(buf, cp, newparent, NULL);

}

}

if (exitflag)

break;

/* Free each child as we are done processing it. */

cptr = child;

child = child->next;

free(cptr->name);

free(cptr);

}

if ((child != NULL) && !term) {

free_children(child);

}

if (chdir(parent) < 0) {

vperror(0, gettext("cannot change back?: %s"), parent);

}

break;

case S_IFLNK:

readlink_max = NAMSIZ;

if (stbuf.st_size > NAMSIZ) {

if (Eflag > 0) {

xhdr_flgs |= _X_LINKPATH;

readlink_max = PATH_MAX;

} else {

(void) fprintf(stderr, gettext(

"tar: %s: symbolic link too long\n"),

longname);

if (errflag)

exitflag = 1;

Errflg = 1;

goto out;

}

}

/*

stbuf.st_size = (off_t)0;

tomodes(&stbuf);

i = readlink(shortname, filetmp, readlink_max);

if (i < 0) {

vperror(0, gettext(

"can't read symbolic link %s"), longname);

goto out;

} else {

filetmp[i] = 0;

}

if (vflag)

(void) fprintf(vfile, gettext(

"a %s symbolic link to %s\n"),

longname, filetmp);

if (xhdr_flgs & _X_LINKPATH) {

Xtarhdr.x_linkpath = filetmp;

if (build_dblock(name, tchar, '2', filetype, &stbuf,

stbuf.st_dev, prefix) != 0)

goto out;

} else

if (build_dblock(name, filetmp, '2', filetype, &stbuf,

stbuf.st_dev, prefix) != 0)

goto out;

(void) writetbuf((char *)&dblock, 1);

/*

rc = PUT_AS_LINK;

break;

case S_IFREG:

if ((infile = openat(dirfd, shortname, 0)) < 0) {

vperror(0, "unable to open %s%s%s%s", longname,

rw_sysattr ? gettext(" system") : "",

(filetype == XATTR_FILE) ?

gettext(" attribute ") : "",

(filetype == XATTR_FILE) ? (longattrname == NULL) ?

shortname : longattrname : "");

goto out;

}

blocks = TBLOCKS(stbuf.st_size);

if (put_link(name, longname, shortname, longattrname,

prefix, filetype, '1') == 0) {

(void) close(infile);

rc = PUT_AS_LINK;

goto out;

}

tomodes(&stbuf);

/* correctly handle end of volume */

while (mulvol && tapepos + blocks + 1 > blocklim) {

/* file won't fit */

if (eflag) {

if (blocks <= blocklim) {

newvol();

break;

}

(void) fprintf(stderr, gettext(

"tar: Single file cannot fit on volume\n"));

done(3);

}

/* split if floppy has some room and file is large */

if (((blocklim - tapepos) >= EXTMIN) &&

((blocks + 1) >= blocklim/10)) {

splitfile(longname, infile,

name, prefix, filetype);

(void) close(dirfd);

(void) close(infile);

goto out;

}

newvol(); /* not worth it--just get new volume */

}

#ifdef DEBUG

DEBUG("putfile: %s wants %" FMT_blkcnt_t " blocks\n", longname,

blocks);

#endif

if (build_dblock(name, tchar, '0', filetype,

&stbuf, stbuf.st_dev, prefix) != 0) {

goto out;

}

if (vflag) {

#ifdef DEBUG

if (NotTape)

DEBUG("seek = %" FMT_blkcnt_t "K\t", K(tapepos),

0);

#endif

(void) fprintf(vfile, "a %s%s%s%s ", longname,

rw_sysattr ? gettext(" system") : "",

(filetype == XATTR_FILE) ? gettext(

" attribute ") : "",

(filetype == XATTR_FILE) ?

longattrname : "");

if (NotTape)

(void) fprintf(vfile, "%" FMT_blkcnt_t "K\n",

K(blocks));

else

(void) fprintf(vfile,

gettext("%" FMT_blkcnt_t " tape blocks\n"),

blocks);

}

if (put_extra_attributes(longname, shortname, longattrname,

prefix, filetype, '0') != 0)

goto out;

/*

(void) sprintf(dblock.dbuf.chksum, "%07o", checksum(&dblock));

hint = writetbuf((char *)&dblock, 1);

maxread = max(min(stbuf.st_blksize, stbuf.st_size),

(nblock * TBLOCK));

if ((bigbuf = calloc((unsigned)maxread, sizeof (char))) == 0) {

maxread = TBLOCK;

bigbuf = buf;

}

while (((i = (int)

read(infile, bigbuf, min((hint*TBLOCK), maxread))) > 0) &&

blocks) {

blkcnt_t nblks;

nblks = ((i-1)/TBLOCK)+1;

if (nblks > blocks)

nblks = blocks;

hint = writetbuf(bigbuf, nblks);

blocks -= nblks;

}

(void) close(infile);

if (bigbuf != buf)

free(bigbuf);

if (i < 0)

vperror(0, gettext("Read error on %s"), longname);

else if (blocks != 0 || i != 0) {

(void) fprintf(stderr, gettext(

"tar: %s: file changed size\n"), longname);

if (errflag) {

exitflag = 1;

Errflg = 1;

} else if (!Dflag) {

Errflg = 1;

}

}

putempty(blocks);

break;

case S_IFIFO:

blocks = TBLOCKS(stbuf.st_size);

stbuf.st_size = (off_t)0;

if (put_link(name, longname, shortname, longattrname,

prefix, filetype, '6') == 0) {

rc = PUT_AS_LINK;

goto out;

}

tomodes(&stbuf);

while (mulvol && tapepos + blocks + 1 > blocklim) {

if (eflag) {

if (blocks <= blocklim) {

newvol();

break;

}

(void) fprintf(stderr, gettext(

"tar: Single file cannot fit on volume\n"));

done(3);

}

if (((blocklim - tapepos) >= EXTMIN) &&

((blocks + 1) >= blocklim/10)) {

splitfile(longname, infile, name,

prefix, filetype);

(void) close(dirfd);

(void) close(infile);

goto out;

}

newvol();

}

#ifdef DEBUG

DEBUG("putfile: %s wants %" FMT_blkcnt_t " blocks\n", longname,

blocks);

#endif

if (vflag) {

#ifdef DEBUG

if (NotTape)

DEBUG("seek = %" FMT_blkcnt_t "K\t", K(tapepos),

0);

#endif

if (NotTape)

(void) fprintf(vfile, gettext("a %s %"

FMT_blkcnt_t "K\n "), longname, K(blocks));

else

(void) fprintf(vfile, gettext(

"a %s %" FMT_blkcnt_t " tape blocks\n"),

longname, blocks);

}

if (build_dblock(name, tchar, '6', filetype,

&stbuf, stbuf.st_dev, prefix) != 0)

goto out;

if (put_extra_attributes(longname, shortname, longattrname,

prefix, filetype, '6') != 0)

goto out;

(void) sprintf(dblock.dbuf.chksum, "%07o", checksum(&dblock));

dblock.dbuf.typeflag = '6';

(void) writetbuf((char *)&dblock, 1);

break;

case S_IFCHR:

stbuf.st_size = (off_t)0;

blocks = TBLOCKS(stbuf.st_size);

if (put_link(name, longname, shortname, longattrname,

prefix, filetype, '3') == 0) {

rc = PUT_AS_LINK;

goto out;

}

tomodes(&stbuf);

while (mulvol && tapepos + blocks + 1 > blocklim) {

if (eflag) {

if (blocks <= blocklim) {

newvol();

break;

}

(void) fprintf(stderr, gettext(

"tar: Single file cannot fit on volume\n"));

done(3);

}

if (((blocklim - tapepos) >= EXTMIN) &&

((blocks + 1) >= blocklim/10)) {

splitfile(longname, infile, name,

prefix, filetype);

(void) close(dirfd);

goto out;

}

newvol();

}

#ifdef DEBUG

DEBUG("putfile: %s wants %" FMT_blkcnt_t " blocks\n", longname,

blocks);

#endif

if (vflag) {

#ifdef DEBUG

if (NotTape)

DEBUG("seek = %" FMT_blkcnt_t "K\t", K(tapepos),

0);

#endif

if (NotTape)

(void) fprintf(vfile, gettext("a %s %"

FMT_blkcnt_t "K\n"), longname, K(blocks));

else

(void) fprintf(vfile, gettext("a %s %"

FMT_blkcnt_t " tape blocks\n"), longname,

blocks);

}

if (build_dblock(name, tchar, '3',

filetype, &stbuf, stbuf.st_rdev, prefix) != 0)

goto out;

if (put_extra_attributes(longname, shortname, longattrname,

prefix, filetype, '3') != 0)

goto out;

(void) sprintf(dblock.dbuf.chksum, "%07o", checksum(&dblock));

dblock.dbuf.typeflag = '3';

(void) writetbuf((char *)&dblock, 1);

break;

case S_IFBLK:

stbuf.st_size = (off_t)0;

blocks = TBLOCKS(stbuf.st_size);

if (put_link(name, longname, shortname, longattrname,

prefix, filetype, '4') == 0) {

rc = PUT_AS_LINK;

goto out;

}

tomodes(&stbuf);

while (mulvol && tapepos + blocks + 1 > blocklim) {

if (eflag) {

if (blocks <= blocklim) {

newvol();

break;

}

(void) fprintf(stderr, gettext(

"tar: Single file cannot fit on volume\n"));

done(3);

}

if (((blocklim - tapepos) >= EXTMIN) &&

((blocks + 1) >= blocklim/10)) {

splitfile(longname, infile,

name, prefix, filetype);

(void) close(dirfd);

goto out;

}

newvol();

}

#ifdef DEBUG

DEBUG("putfile: %s wants %" FMT_blkcnt_t " blocks\n", longname,